redports backport
[pcsx_rearmed.git] / maemo / hildon.c
1 #include <gtk/gtk.h>
2 #include <glib.h>
3 #include <stdlib.h>
4 #include <stdint.h>
5 #include <unistd.h>
6 #include <hildon/hildon.h>
7 #include <string.h>
8 #include <pthread.h>
9
10 #include "../frontend/plugin_lib.h"
11 #include "../frontend/main.h"
12 #include "../libpcsxcore/misc.h"
13 #include "../include/psemu_plugin_defs.h"
14 #include "../libpcsxcore/cdrom.h"
15 #include "../libpcsxcore/cdriso.h"
16 #include "../plugins/dfinput/main.h"
17 #include "../frontend/libpicofe/readpng.h"
18 #include "maemo_common.h"
19 #include <libosso.h>
20 #include <dbus/dbus.h>
21
22 #define X_RES           800
23 #define Y_RES           480
24 #define D_WIDTH                 640
25 #define D_HEIGHT                480
26
27 #define CALL_SIGNAL_IF "com.nokia.csd.Call"
28 #define CALL_SIGNAL_PATH "/com/nokia/csd/call"
29 #define CALL_INCOMING_SIG "Coming"
30
31 #define DBUS_RULE_CALL_INCOMING "type='signal',interface='" CALL_SIGNAL_IF \
32                                 "',path='" CALL_SIGNAL_PATH \
33                                 "',member='" CALL_INCOMING_SIG "'"
34
35 osso_context_t* osso = NULL;
36 int bRunning = TRUE;
37 extern int bKeepDisplayOn;
38 extern int bAutosaveOnExit;
39 extern int cornerActions[4];
40 extern char keys_config_file[MAXPATHLEN];
41 static pthread_t display_thread = (pthread_t)0;
42 int g_layer_x = (X_RES - D_WIDTH) / 2;
43 int g_layer_y = (Y_RES - D_HEIGHT) / 2;
44 int g_layer_w = D_WIDTH, g_layer_h = D_HEIGHT;
45
46 static GdkImage *image;
47 static HildonAnimationActor *actor;
48 static GtkWidget *window, *drawing = NULL;
49
50 static int pl_buf_w, pl_buf_h;
51 int keymap[65536];
52 int direction_keys[4];
53
54 // map psx4m compatible keymap to PSX keys
55 static const unsigned char keymap2[14] = {
56         DKEY_LEFT,   // 0
57         DKEY_RIGHT,
58         DKEY_UP,
59         DKEY_DOWN,
60         DKEY_CIRCLE,
61         DKEY_CROSS,  // 5
62         DKEY_TRIANGLE,
63         DKEY_SQUARE,
64         DKEY_SELECT,
65         DKEY_START,
66         DKEY_L1,     // 10
67         DKEY_R1,
68         DKEY_L2,
69         DKEY_R2,
70 };
71
72 void hildon_quit()
73 {
74         maemo_finish();
75         gtk_main_quit();
76         exit(0);
77 }
78
79 gdouble press_x = -1;
80 gdouble press_y = -1;
81
82 int maemo_x11_update_keys();
83 void show_notification(char* text);
84
85 void change_slot(int delta)
86 {
87         state_slot += delta;
88         if (state_slot > 9)
89                 state_slot = 0;
90         else if (state_slot < 0)
91                 state_slot = 9;
92         char message[50];
93         sprintf(message,"Savestate slot: %i",state_slot + 1);
94         show_notification(message);
95 }
96
97 void save(int state_slot)
98 {
99         emu_save_state(state_slot);
100         char buf[MAXPATHLEN];
101         if (image && image->mem){
102                 sprintf (buf,"/opt/maemo/usr/games/screenshots%s.%3.3d",file_name,state_slot);
103                 writepng(buf, image->mem, pl_buf_w,pl_buf_h);
104         }
105         char message[50];
106         sprintf(message,"Saved savestate slot: %i",state_slot + 1);
107         show_notification(message);
108 }
109
110 void quit()
111 {
112         if (bAutosaveOnExit){
113                 show_notification("Autosaving");
114                 emu_save_state(99);
115                 char buf[MAXPATHLEN];
116                 if (image && image->mem){
117                         sprintf (buf,"/opt/maemo/usr/games/screenshots%s.%3.3d",file_name,99);
118                         writepng(buf, image->mem, pl_buf_w,pl_buf_h);
119                 }
120         }
121         hildon_quit();
122 }
123
124 int show_confirmbox(char* text)
125 {
126         if (!window)
127                 return TRUE;
128
129         GtkWidget *dialog;
130         dialog = gtk_message_dialog_new (GTK_WINDOW(window),
131                                                                          GTK_DIALOG_DESTROY_WITH_PARENT,
132                                                                          GTK_MESSAGE_QUESTION,
133                                                                          GTK_BUTTONS_YES_NO,
134                                                                          text);
135         gint result = gtk_dialog_run (GTK_DIALOG (dialog));
136         gtk_widget_destroy (dialog);
137         if (result == GTK_RESPONSE_YES)
138                 return TRUE;
139         return FALSE;
140 }
141
142 static void
143 window_button_proxy(GtkWidget *widget,
144                                     GdkEventButton *event,
145                                     gpointer user_data)
146 {
147         int corner = -1;
148         int sens = 100;
149
150         switch (event->type){
151         case GDK_BUTTON_PRESS:
152                 //printf("GDK_BUTTON_PRESS: x=%f y=%f\n", event->x, event->y);
153                 press_x = event->x;
154                 press_y = event->y;
155                 break;
156         case GDK_BUTTON_RELEASE:
157                 //printf("GDK_BUTTON_RELEASE: x=%f y=%f\n", event->x, event->y);
158                 if (press_x < sens && press_y < sens && event->x < sens && event->y < sens)
159                         corner = 0;
160                 else if (press_x > 800 - sens && press_y < sens && event->x > 800 - sens && event->y < sens)
161                         corner = 1;
162                 else if (press_x > 800 - sens && press_y > 480 - sens && event->x > 800 - sens && event->y > 480 - sens)
163                         corner = 2;
164                 else if (press_x < sens && press_y > 480 - sens && event->x < sens && event->y > 480 - sens)
165                         corner = 3;
166
167                 press_x = -1;
168                 press_y = -1;
169                 break;
170         default:
171                 break;
172         }
173
174         if (corner >= 0){
175                 switch (cornerActions[corner]){
176                         case 1:
177                                 if (show_confirmbox("Save savestate?"))
178                                         save(state_slot);
179                                 break;
180                         case 2:
181                                 if (show_confirmbox("Load savestate?"))
182                                         emu_load_state(state_slot);
183                                 break;
184                         case 3:
185                                 change_slot(1);
186                                 break;
187                         case 4:
188                                 change_slot(-1);
189                                 break;
190                         case 5:
191                                 if (show_confirmbox("Quit?"))
192                                         quit();
193                                 break;
194                 }
195         }
196 }
197
198 static void *displayThread(void *arg)
199 {
200         DBusConnection* system_bus = (DBusConnection*)osso_get_sys_dbus_connection(osso);
201         DBusMessage* msg = dbus_message_new_method_call("com.nokia.mce",
202                                                                                                     "/com/nokia/mce/request",
203                                                                                                     "com.nokia.mce.request",
204                                                                                                     "req_display_blanking_pause");
205         if (msg && system_bus) {
206                 bRunning = TRUE;
207                 while (bRunning) {
208                         dbus_connection_send(system_bus, msg, NULL);
209                         dbus_connection_flush(system_bus);
210                         int i = 0;
211                         for (i=0; i<8; i++){
212                                 usleep(500000);
213                                 if (!bRunning)
214                                         break;
215                         }
216                 }
217                 dbus_message_unref(msg);
218         }
219
220         pthread_exit(0);
221         return NULL;
222 }
223
224 void show_notification(char* text)
225 {
226         if (window){
227                 GtkWidget* banner = hildon_banner_show_information(GTK_WIDGET(window), NULL, text);
228                 hildon_banner_set_timeout(HILDON_BANNER(banner), 3000);
229         }else{
230                 DBusConnection* session_bus = (DBusConnection*)osso_get_dbus_connection(osso);
231                 DBusMessageIter args;
232                 DBusMessage*msg = dbus_message_new_method_call("org.freedesktop.Notifications",
233                                                                                                            "/org/freedesktop/Notifications",
234                                                                                                            "org.freedesktop.Notifications",
235                                                                                                            "SystemNoteInfoprint");
236                 if (msg) {
237                         dbus_message_iter_init_append(msg, &args);
238                         char* param = text;
239                         if (dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &param)) {
240                                 dbus_connection_send(session_bus, msg, NULL);
241                                 dbus_connection_flush(session_bus);
242                         }
243                         dbus_message_unref(msg);
244                 }
245         }
246 }
247
248 void show_messagebox(char* text)
249 {
250         if (!window)
251                 return;
252
253         GtkWidget *dialog;
254         dialog = gtk_message_dialog_new (GTK_WINDOW(window),
255                                                                          GTK_DIALOG_DESTROY_WITH_PARENT,
256                                                                          GTK_MESSAGE_INFO,
257                                                                          GTK_BUTTONS_OK,
258                                                                          text);
259         gtk_dialog_run (GTK_DIALOG (dialog));
260         gtk_widget_destroy (dialog);
261 }
262
263 #include <hildon/hildon-file-chooser-dialog.h>
264 void change_disc()
265 {
266         GtkWidget *dialog;
267         dialog = hildon_file_chooser_dialog_new (GTK_WINDOW(window), GTK_FILE_CHOOSER_ACTION_OPEN);
268     gtk_window_set_title (GTK_WINDOW (dialog), "Change disc");
269
270         char currentFile[MAXPATHLEN];
271         strcpy(currentFile, GetIsoFile());
272         if (strlen(currentFile))
273                 gtk_file_chooser_set_filename (GTK_FILE_CHOOSER(dialog), currentFile);
274         else
275                 gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER(dialog), "/home/user/MyDocs/");
276
277         GtkFileFilter *filter=gtk_file_filter_new();
278         gtk_file_filter_add_pattern (filter,"*.bin");
279         gtk_file_filter_add_pattern (filter,"*.BIN");
280         gtk_file_filter_add_pattern (filter,"*.iso");
281         gtk_file_filter_add_pattern (filter,"*.ISO");
282         gtk_file_filter_add_pattern (filter,"*.img");
283         gtk_file_filter_add_pattern (filter,"*.IMG");
284         gtk_file_filter_add_pattern (filter,"*.z");
285         gtk_file_filter_add_pattern (filter,"*.Z");
286         gtk_file_filter_add_pattern (filter,"*.znx");
287         gtk_file_filter_add_pattern (filter,"*.ZNX");
288         gtk_file_filter_add_pattern (filter,"*.pbp");
289         gtk_file_filter_add_pattern (filter,"*.PBP");
290         gtk_file_filter_add_pattern (filter,"*.mdf");
291         gtk_file_filter_add_pattern (filter,"*.MDF");
292         gtk_file_chooser_set_filter (GTK_FILE_CHOOSER (dialog),filter);
293
294         if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_OK) {
295                 char *filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
296
297                 //if (strcmp(filename, currentFile)) {
298                         CdromId[0] = '\0';
299                         CdromLabel[0] = '\0';
300
301                         set_cd_image(filename);
302                         if (ReloadCdromPlugin() < 0)
303                                 printf("Failed to load cdr plugin\n");
304
305                         if (CDR_open() < 0)
306                                 printf("Failed to open cdr plugin\n");
307
308                         strcpy(file_name, strrchr(filename,'/'));
309
310                         SetCdOpenCaseTime(time(NULL) + 3);
311                         LidInterrupt();
312                 //}
313                 g_free (filename);
314         }
315
316         gtk_widget_destroy (dialog);
317 }
318
319 void change_multi_disc()
320 {
321     HildonDialog* window = HILDON_DIALOG(hildon_dialog_new());
322     gtk_window_set_title (GTK_WINDOW (window), "Change disc");
323     gtk_window_set_default_size(GTK_WINDOW (window), 480, 300);
324
325     GtkWidget* sw = hildon_pannable_area_new ();
326     gtk_box_pack_start (GTK_BOX(GTK_DIALOG(window)->vbox), sw, TRUE, TRUE, 0);
327
328     GtkWidget* tree_view = hildon_gtk_tree_view_new (HILDON_UI_MODE_EDIT);
329     gtk_widget_set_name (tree_view, "fremantle-widget");
330
331     gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (tree_view), TRUE);
332
333     int i;
334     GtkListStore *store = gtk_list_store_new (1, G_TYPE_STRING);
335     for (i = 0; i < cdrIsoMultidiskCount; i++) {
336         gchar *str;
337
338         str = g_strdup_printf ("Disc %d", i+1);
339         gtk_list_store_insert_with_values (store, NULL, i, 0, str, -1);
340         g_free (str);
341     }
342     GtkTreeModel* model =  GTK_TREE_MODEL (store);
343
344     gtk_tree_view_set_model (GTK_TREE_VIEW (tree_view), model);
345     g_object_unref (model);
346
347     GtkTreeSelection* selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (tree_view));
348     gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE);
349
350     GtkCellRenderer* renderer = gtk_cell_renderer_text_new ();
351     g_object_set (renderer,
352                   "xalign", 0.5,
353                   "weight", PANGO_WEIGHT_NORMAL,
354                   NULL);
355
356     gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (tree_view),
357                                                  0, "Column 0",
358                                                  renderer,
359                                                  "text", 0,
360                                                  NULL);
361
362     char current[5];
363     sprintf(current, "%i", cdrIsoMultidiskSelect);
364     GtkTreePath* path = gtk_tree_path_new_from_string(current);
365     gtk_tree_selection_select_path (selection, path);
366     gtk_tree_path_free(path);
367
368     gtk_widget_set_size_request (tree_view, 480, 800);
369     gtk_container_add (GTK_CONTAINER (sw), tree_view);
370
371     hildon_dialog_add_button (HILDON_DIALOG(window), GTK_STOCK_OK, GTK_RESPONSE_ACCEPT);
372
373     gtk_widget_show_all (GTK_WIDGET(window));
374     gint result = gtk_dialog_run (GTK_DIALOG (window));
375     if (result == GTK_RESPONSE_ACCEPT) {
376       GtkTreeModel* model;
377       GtkTreeIter iter;
378       GtkTreeSelection* selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree_view));
379       if (gtk_tree_selection_get_selected(selection, &model, &iter)){
380             GtkTreePath* path = gtk_tree_model_get_path(model , &iter);
381                 int* i = gtk_tree_path_get_indices(path) ;
382
383                 cdrIsoMultidiskSelect = *i;
384                 CdromId[0] = '\0';
385                 CdromLabel[0] = '\0';
386
387                 CDR_close();
388                 if (CDR_open() < 0) {
389                         printf("Failed to load cdr plugin\n");
390                         return;
391                 }
392
393                 SetCdOpenCaseTime(time(NULL) + 3);
394                 LidInterrupt();
395       }
396     }
397         gtk_widget_destroy(GTK_WIDGET(window));
398 }
399
400 static DBusHandlerResult on_msg_recieved(DBusConnection* connection G_GNUC_UNUSED, DBusMessage* message, void* data)
401 {
402         const char* path = dbus_message_get_path(message);
403         if (path && g_str_equal(path, CALL_SIGNAL_PATH)){
404                 const char* mbr = dbus_message_get_member(message);
405                 if (mbr && g_str_equal(mbr, CALL_INCOMING_SIG))
406                         show_messagebox("Paused");
407         }
408
409         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
410 }
411
412 static void
413 window_key_proxy(GtkWidget *widget,
414                      GdkEventKey *event,
415                      gpointer user_data)
416 {
417         key_press_event(event->hardware_keycode, event->type == GDK_KEY_PRESS ? 1 : (event->type == GDK_KEY_RELEASE ? 2 : 0) );
418 }
419
420 int last_key_pressed = 0;
421 inline void key_press_event(int key2,int type)
422 {
423         int psxkey1 = -1, psxkey2 = -1;
424         int key=keymap[key2];
425
426         if (key < 0)
427                 return;
428
429         if (type == 1 && key2 == last_key_pressed)
430                 return;
431         last_key_pressed = type == 1 ? key2 : 0;
432
433         //printf("Key: %i %s\n", key2, type == 1 ? "Pressed" : (type == 2 ? "Released" : "Unknown"));
434         if (key < ARRAY_SIZE(keymap2)){
435                 psxkey1 = keymap2[key];
436         }else switch (key) {
437                 case 14:
438                         quit();
439                         break;
440                 case 15:
441                         psxkey1 = DKEY_UP;
442                         psxkey2 = DKEY_LEFT;
443                         break;
444                 case 16:
445                         psxkey1 = DKEY_UP;
446                         psxkey2 = DKEY_RIGHT;
447                         break;
448                 case 17:
449                         psxkey1 = DKEY_DOWN;
450                         psxkey2 = DKEY_LEFT;
451                         break;
452                 case 18:
453                         psxkey1 = DKEY_DOWN;
454                         psxkey2 = DKEY_RIGHT;
455                         break;
456                 case 19:
457                         if (type == 1)
458                                 save(state_slot);
459                         return;
460                 case 20:
461                         if (type == 1)
462                                 emu_load_state(state_slot);
463                         return;
464                 case 21:
465                         if (type == 1)
466                                 change_slot(1);
467                         return;
468                 case 22:
469                         if (type == 1)
470                                 change_slot(-1);
471                         return;
472                 case 23:
473                         if (type == 1){
474                                 if (cdrIsoMultidiskCount > 1)
475                                         change_multi_disc();
476                                 else
477                                         change_disc();
478                         }
479                         return;
480         }
481
482         if (in_type1 == PSE_PAD_TYPE_GUNCON){
483                 if (type == 1) {
484                         switch (psxkey1){
485                                 case DKEY_CROSS:
486                                         in_state_gun |= SACTION_GUN_A;
487                                         break;          
488                                 case DKEY_CIRCLE:
489                                         in_state_gun |= SACTION_GUN_B;
490                                         break;          
491                                 case DKEY_TRIANGLE:
492                                         in_state_gun |= SACTION_GUN_TRIGGER2;
493                                         break;          
494                                 case DKEY_SQUARE:
495                                         in_state_gun |= SACTION_GUN_TRIGGER;
496                                         break;          
497                         }
498                 }else if (type == 2) {
499                         switch (psxkey1){
500                                 case DKEY_CROSS:
501                                         in_state_gun &= ~SACTION_GUN_A;
502                                         break;          
503                                 case DKEY_CIRCLE:
504                                         in_state_gun &= ~SACTION_GUN_B;
505                                         break;          
506                                 case DKEY_TRIANGLE:
507                                         in_state_gun &= ~SACTION_GUN_TRIGGER2;
508                                         break;          
509                                 case DKEY_SQUARE:
510                                         in_state_gun &= ~SACTION_GUN_TRIGGER;
511                                         break;          
512                         }
513                 }
514         }else{
515                 if (type == 1) {
516                 if (psxkey1 >= 0)
517                         in_keystate |= 1 << psxkey1;
518                 if (psxkey2 >= 0)
519                         in_keystate |= 1 << psxkey2;
520
521                         if (in_type1 == PSE_PAD_TYPE_ANALOGPAD){
522                                 switch(psxkey1){
523                                         case DKEY_LEFT:
524                                                 in_a1[0] = 0;
525                                                 break;
526                                         case DKEY_RIGHT:
527                                                 in_a1[0] = 255;
528                                                 break;
529                                         case DKEY_UP:
530                                                 in_a1[1] = 0;
531                                                 break;
532                                         case DKEY_DOWN:
533                                                 in_a1[1] = 255;
534                                                 break;
535                                 }
536         }
537                 }
538                 else if (type == 2) {
539                 if (psxkey1 >= 0)
540                         in_keystate &= ~(1 << psxkey1);
541                 if (psxkey2 >= 0)
542                         in_keystate &= ~(1 << psxkey2);
543
544                         if (in_type1 == PSE_PAD_TYPE_ANALOGPAD){
545                                 switch(psxkey1){
546                                         case DKEY_LEFT:
547                                         case DKEY_RIGHT:
548                                                 in_a1[0] = 127;
549                                                 break;
550                                         case DKEY_UP:
551                                         case DKEY_DOWN:
552                                                 in_a1[1] = 127;
553                                                 break;
554                                 }
555                         }
556                 emu_set_action(SACTION_NONE);
557         }
558         }
559 }
560
561 void plat_finish()
562 {
563         hildon_quit();
564 }
565
566 void set_accel_multipliers()
567 {
568         accelOptions.xMultiplier = 255.0 / ( (accelOptions.maxValue - accelOptions.sens) * 2.0);
569         accelOptions.yMultiplier = 255.0 / ( (accelOptions.maxValue - accelOptions.sens) * 2.0);
570 }
571
572 #include <gdk/gdkx.h>
573 int maemo_init(int *argc, char ***argv)
574 {
575         osso = osso_initialize("pcsxrearmed", PACKAGE_VERSION, FALSE, NULL);
576
577         DBusConnection* system_bus = (DBusConnection*)osso_get_sys_dbus_connection(osso);
578     dbus_bus_add_match(system_bus, DBUS_RULE_CALL_INCOMING, NULL);
579         dbus_connection_add_filter(system_bus, on_msg_recieved, NULL, NULL);
580
581         FILE* pFile;
582         pFile = fopen(keys_config_file, "r");
583         if (pFile == NULL){
584                 fprintf(stderr, "Error opening keys config file %s\n", keys_config_file);
585                 return 1;
586         }
587         printf("Keys config read from %s\n", keys_config_file);
588
589         int ch;
590         int i=0;
591         for (i=0;i<65536;i++)
592                 keymap[i]=-1;
593         if (NULL != pFile) {
594                 for(i=0;i<24;i++){
595                         fscanf(pFile, "%i",&ch);
596                         keymap[ch]=i;
597                         if (i < 4)
598                                 direction_keys[i] = ch;
599                 }
600                 fclose(pFile);
601         }
602         
603         switch (in_type1){
604                 case PSE_PAD_TYPE_GUNCON:
605                         memset(cornerActions, 0, sizeof(cornerActions));
606                         printf("Controller set to GUNCON (SLPH-00034)\n");
607                         break;
608                 case PSE_PAD_TYPE_STANDARD:
609                         printf("Controller set to standard (SCPH-1080)\n");
610                         break;
611                 case PSE_PAD_TYPE_ANALOGPAD:
612                         printf("Controller set to analog (SCPH-1150)\n");
613                         break;  
614         }
615
616         if (in_enable_vibration)
617                 printf("Vibration enabled\n");
618
619         if (!(g_maemo_opts&8)){
620         gtk_init (argc, argv);
621
622         window = hildon_stackable_window_new ();
623         gtk_widget_realize (window);
624         gtk_window_fullscreen (GTK_WINDOW(window));
625
626                 if (cornerActions[0] + cornerActions[1] + cornerActions[2] + cornerActions[3] > 0){
627                         g_signal_connect (G_OBJECT (window), "button_release_event",
628                                                 G_CALLBACK (window_button_proxy), NULL);
629                         g_signal_connect (G_OBJECT (window), "button_press_event",
630                                                 G_CALLBACK (window_button_proxy), NULL);
631                 }
632
633         g_signal_connect (G_OBJECT (window), "key-press-event",
634                                 G_CALLBACK (window_key_proxy), NULL);
635         g_signal_connect (G_OBJECT (window), "key-release-event",
636                                 G_CALLBACK (window_key_proxy), NULL);
637         g_signal_connect (G_OBJECT (window), "delete_event",
638                                 G_CALLBACK (hildon_quit), NULL);
639         gtk_widget_add_events (window,
640                                 GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK);
641
642         actor = HILDON_ANIMATION_ACTOR (hildon_animation_actor_new());
643         if (g_maemo_opts & 2)
644                 hildon_animation_actor_set_position (actor, 0, 0 );
645         else
646                 hildon_animation_actor_set_position (actor, (X_RES - D_WIDTH)/2, (Y_RES - D_HEIGHT)/2 );
647         hildon_animation_actor_set_parent (actor, GTK_WINDOW (window));
648
649         drawing = gtk_image_new ();
650
651         gtk_container_add (GTK_CONTAINER (actor), drawing);
652
653         gtk_widget_show_all (GTK_WIDGET (actor));
654         gtk_widget_show_all (GTK_WIDGET (window));
655         }else{
656                 gtk_init (argc, argv);
657                 /*GdkScreen* scr = gdk_screen_get_default();
658                 window = GTK_WIDGET(gdk_screen_get_root_window(scr));
659                 if (!window)
660                         window = GTK_WIDGET(gdk_get_default_root_window());*/
661         }
662
663         set_accel_multipliers();
664
665         if (bKeepDisplayOn){
666                 if (pthread_create(&display_thread, NULL, displayThread, NULL))
667                         printf("Failed to create display thread.\n");           
668         }
669
670         pl_rearmed_cbs.only_16bpp = 1;
671         return 0;
672 }
673
674 void maemo_finish()
675 {
676         if (display_thread > 0){
677                 bRunning = FALSE;
678                 pthread_join(display_thread, NULL);
679         }
680
681         if (osso){
682                 osso_deinitialize(osso);
683                 osso = NULL;
684         }
685         printf("Exiting\n");
686 }
687
688 void menu_loop(void)
689 {
690 }
691
692 void *plat_gvideo_set_mode(int *w_, int *h_, int *bpp_)
693 {
694         int w = *w_, h = *h_;
695
696         if (g_maemo_opts&8) return pl_vout_buf;
697         //printf("Setting video mode %ix%i\n", w, h);
698
699         if (w <= 0 || h <= 0)
700                 return pl_vout_buf;
701
702         if (image) gdk_image_destroy(image);
703         image = gdk_image_new( GDK_IMAGE_FASTEST, gdk_visual_get_system(), w, h );
704
705         pl_vout_buf = (void *) image->mem;
706
707         gtk_image_set_from_image (GTK_IMAGE(drawing), image, NULL);
708
709         gtk_window_resize (GTK_WINDOW (actor), w, h);
710         if (g_maemo_opts & 2)
711                 hildon_animation_actor_set_scale (actor,
712                                 (gdouble)800 / (gdouble)w,
713                                 (gdouble)480 / (gdouble)h
714                                 );
715         else
716                 hildon_animation_actor_set_scale (actor,
717                                 (gdouble)D_WIDTH / (gdouble)w,
718                                 (gdouble)D_HEIGHT / (gdouble)h
719                                 );
720         pl_buf_w=w;pl_buf_h=h;
721         return pl_vout_buf;
722 }
723
724 void *plat_gvideo_flip(void)
725 {
726         if (!(g_maemo_opts&8))
727                 gtk_widget_queue_draw(drawing);
728
729         // process accelometer
730         if (g_maemo_opts & 4) {
731                 float x, y, z;
732                 FILE* f = fopen( "/sys/class/i2c-adapter/i2c-3/3-001d/coord", "r" );
733                 if( !f ) {printf ("err in accel"); exit(1);}
734                 fscanf( f, "%f %f %f", &x, &y, &z );
735                 fclose( f );
736
737                 if (in_type1 == PSE_PAD_TYPE_ANALOGPAD){
738                         if (x > accelOptions.maxValue) x = accelOptions.maxValue;
739                         else if (x < -accelOptions.maxValue) x = -accelOptions.maxValue;
740
741                         const int maxValue = accelOptions.maxValue - accelOptions.sens;
742                         if(x > accelOptions.sens){
743                                 x -= accelOptions.sens;
744                                 in_a1[0] = (-x + maxValue ) *  accelOptions.xMultiplier;
745                         }else if (x < -accelOptions.sens){
746                                 x += accelOptions.sens;
747                                 in_a1[0] = (-x + maxValue ) *  accelOptions.xMultiplier;
748                         }else in_a1[0] = 127;
749
750                         y += accelOptions.y_def;
751                         if (y > accelOptions.maxValue) y = accelOptions.maxValue;
752                         else if (y < -accelOptions.maxValue) y = -accelOptions.maxValue;
753
754                         if(y > accelOptions.sens){
755                                 y -= accelOptions.sens;
756                                 in_a1[1] = (-y + maxValue ) *  accelOptions.yMultiplier;
757                         }else if (y < -accelOptions.sens){
758                                 y += accelOptions.sens;
759                                 in_a1[1] = (-y + maxValue ) *  accelOptions.yMultiplier;
760                         }else in_a1[1] = 127;
761
762                         //printf("x: %i y: %i\n", in_a1[0], in_a1[1]);
763                 }else{
764                         if( x > accelOptions.sens ) in_keystate |= 1 << DKEY_LEFT;
765                         else if( x < -accelOptions.sens ) in_keystate |= 1 << DKEY_RIGHT;
766                 else {in_keystate &= ~(1 << DKEY_LEFT);in_keystate &= ~(1 << DKEY_RIGHT);}
767
768                         y += accelOptions.y_def;
769                         if( y > accelOptions.sens )in_keystate |= 1 << DKEY_UP;
770                         else if( y < -accelOptions.sens ) in_keystate |= 1 << DKEY_DOWN;
771                 else {in_keystate &= ~(1 << DKEY_DOWN);in_keystate &= ~(1 << DKEY_UP);}
772                 }
773         }
774
775         return pl_vout_buf;
776 }
777
778 // for frontend/plugin_lib.c
779 void update_input(void)
780 {
781         if (g_maemo_opts & 8)
782                 maemo_x11_update_keys();
783         else {
784                 /* process GTK+ events */
785                 while (gtk_events_pending())
786                         gtk_main_iteration();
787         }
788 }
789
790 int omap_enable_layer(int enabled)
791 {
792         return 0;
793 }
794
795 void menu_notify_mode_change(int w, int h, int bpp)
796 {
797 }
798
799 void *plat_prepare_screenshot(int *w, int *h, int *bpp)
800 {
801         return NULL;
802 }
803
804 void plat_step_volume(int is_up)
805 {
806 }
807
808 void plat_trigger_vibrate(int pad, int low, int high)
809 {
810         const int vDuration = 10;
811
812         DBusConnection* system_bus = (DBusConnection*)osso_get_sys_dbus_connection(osso);
813         DBusMessageIter args;
814         DBusMessage*msg = dbus_message_new_method_call("com.nokia.mce",
815                                                                                                    "/com/nokia/mce/request",
816                                                                                                    "com.nokia.mce.request",
817                                                                                                    "req_start_manual_vibration");
818         if (msg) {
819                 dbus_message_iter_init_append(msg, &args);
820                 // FIXME: somebody with hardware should tune this
821                 int speed = high; // is_strong ? 200 : 150;
822                 int duration = vDuration;
823                 if (dbus_message_iter_append_basic(&args, DBUS_TYPE_INT32, &speed)) {
824                         if (dbus_message_iter_append_basic(&args, DBUS_TYPE_INT32, &duration)) {
825                                 dbus_connection_send(system_bus, msg, NULL);
826                                 //dbus_connection_flush(system_bus);
827                         }
828                 }
829                 dbus_message_unref(msg);
830         }
831 }
832
833 void plat_minimize(void)
834 {
835 }
836
837 void plat_gvideo_close(void)
838 {
839 }
840
841 void plat_gvideo_open(int is_pal)
842 {
843 }