notaz.gp2x.de / pcsx_rearmed.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
psxbios: Add checks for memmove.
[pcsx_rearmed.git] / maemo / hildon.c
CommitLineData
b7b2fb41
B		 1#include <gtk/gtk.h>
2#include <glib.h>
3#include <stdlib.h>
54b4a001 4#include <stdint.h>
b7b2fb41
B		 5#include <unistd.h>
6#include <hildon/hildon.h>
a76fd953
PI		 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"
d64280d6 18#include "maemo_common.h"
a76fd953
PI		 19#include <libosso.h>
20#include <dbus/dbus.h>
b7b2fb41
B		 21
22#define X_RES 800
23#define Y_RES 480
24#define D_WIDTH 640
25#define D_HEIGHT 480
26
a76fd953
PI		 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
35osso_context_t* osso = NULL;
36int bRunning = TRUE;
37extern int bKeepDisplayOn;
38extern int bAutosaveOnExit;
39extern int cornerActions[4];
40extern char keys_config_file[MAXPATHLEN];
41static pthread_t display_thread = (pthread_t)0;
42int g_layer_x = (X_RES - D_WIDTH) / 2;
43int g_layer_y = (Y_RES - D_HEIGHT) / 2;
44int g_layer_w = D_WIDTH, g_layer_h = D_HEIGHT;
45
e0c692d9 46static GdkImage *image;
47static HildonAnimationActor *actor;
a76fd953 48static GtkWidget *window, *drawing = NULL;
e0c692d9 49
bbd471af 50static int pl_buf_w, pl_buf_h;
a76fd953
PI		 51int keymap[65536];
52int direction_keys[4];
e0c692d9 53
54// map psx4m compatible keymap to PSX keys
55static 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,
a76fd953 66 DKEY_L1, // 10
e0c692d9 67 DKEY_R1,
a76fd953
PI		 68 DKEY_L2,
69 DKEY_R2,
e0c692d9 70};
b7b2fb41 71
e0c692d9 72void hildon_quit()
73{
a76fd953 74 maemo_finish();
e0c692d9 75 gtk_main_quit();
76 exit(0);
77}
b7b2fb41 78
a76fd953
PI		 79gdouble press_x = -1;
80gdouble press_y = -1;
81
82int maemo_x11_update_keys();
83void show_notification(char* text);
84
85void 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
97void 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
110void 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
124int 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
142static void
143window_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
198static 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
224void 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
248void 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>
264void 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
319void 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
400static 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
b7b2fb41 412static void
e0c692d9 413window_key_proxy(GtkWidget *widget,
b7b2fb41
B		 414 GdkEventKey *event,
415 gpointer user_data)
416{
a76fd953
PI		 417 key_press_event(event->hardware_keycode, event->type == GDK_KEY_PRESS ? 1 : (event->type == GDK_KEY_RELEASE ? 2 : 0) );
418}
419
420int last_key_pressed = 0;
421inline void key_press_event(int key2,int type)
422{
423 int psxkey1 = -1, psxkey2 = -1;
424 int key=keymap[key2];
e0c692d9 425
e0c692d9 426 if (key < 0)
427 return;
428
a76fd953
PI		 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)){
e0c692d9 435 psxkey1 = keymap2[key];
a76fd953 436 }else switch (key) {
e0c692d9 437 case 14:
a76fd953 438 quit();
e0c692d9 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:
a76fd953
PI		 457 if (type == 1)
458 save(state_slot);
e0c692d9 459 return;
460 case 20:
a76fd953 461 if (type == 1)
bbd471af
B		 462 emu_load_state(state_slot);
463 return;
464 case 21:
a76fd953
PI		 465 if (type == 1)
466 change_slot(1);
bbd471af
B		 467 return;
468 case 22:
a76fd953
PI		 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 }
e0c692d9 479 return;
480 }
481
a76fd953
PI		 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) {
e0c692d9 516 if (psxkey1 >= 0)
54b4a001 517 in_keystate |= 1 << psxkey1;
e0c692d9 518 if (psxkey2 >= 0)
54b4a001 519 in_keystate |= 1 << psxkey2;
a76fd953
PI		 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 }
b7b2fb41 536 }
a76fd953
PI		 537 }
538 else if (type == 2) {
e0c692d9 539 if (psxkey1 >= 0)
54b4a001 540 in_keystate &= ~(1 << psxkey1);
e0c692d9 541 if (psxkey2 >= 0)
54b4a001 542 in_keystate &= ~(1 << psxkey2);
8f892648 543
a76fd953
PI		 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 }
8f892648 556 emu_set_action(SACTION_NONE);
b7b2fb41 557 }
a76fd953 558 }
b7b2fb41 559}
b7b2fb41 560
e0c692d9 561void plat_finish()
b7b2fb41 562{
e0c692d9 563 hildon_quit();
b7b2fb41 564}
b7b2fb41 565
a76fd953 566void set_accel_multipliers()
b7b2fb41 567{
a76fd953
PI		 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>
573int 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
b7b2fb41 581 FILE* pFile;
a76fd953
PI		 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
b7b2fb41
B		 589 int ch;
590 int i=0;
591 for (i=0;i<65536;i++)
a76fd953 592 keymap[i]=-1;
b7b2fb41 593 if (NULL != pFile) {
a76fd953 594 for(i=0;i<24;i++){
b7b2fb41
B		 595 fscanf(pFile, "%i",&ch);
596 keymap[ch]=i;
a76fd953
PI		 597 if (i < 4)
598 direction_keys[i] = ch;
b7b2fb41
B		 599 }
600 fclose(pFile);
601 }
b7b2fb41 602
a76fd953
PI		 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;
bbd471af
B		 614 }
615
a76fd953
PI		 616 if (in_enable_vibration)
617 printf("Vibration enabled\n");
618
619 if (!(g_maemo_opts&8)){
b7b2fb41
B		 620 gtk_init (argc, argv);
621
622 window = hildon_stackable_window_new ();
623 gtk_widget_realize (window);
624 gtk_window_fullscreen (GTK_WINDOW(window));
a76fd953
PI		 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
b7b2fb41
B		 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());
d64280d6 643 if (g_maemo_opts & 2)
bbd471af
B		 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 );
b7b2fb41
B		 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));
a76fd953
PI		 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 }
6469a8c4 662
a76fd953
PI		 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 }
4ea7de6a 669
670 pl_rearmed_cbs.only_16bpp = 1;
a76fd953
PI		 671 return 0;
672}
673
674void 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
688void menu_loop(void)
689{
b7b2fb41
B		 690}
691
6469a8c4 692void *plat_gvideo_set_mode(int *w_, int *h_, int *bpp_)
b7b2fb41 693{
6469a8c4 694 int w = *w_, h = *h_;
695
a76fd953
PI		 696 if (g_maemo_opts&8) return pl_vout_buf;
697 //printf("Setting video mode %ix%i\n", w, h);
698
b7b2fb41 699 if (w <= 0 || h <= 0)
76f7048e 700 return pl_vout_buf;
b7b2fb41
B		 701
702 if (image) gdk_image_destroy(image);
703 image = gdk_image_new( GDK_IMAGE_FASTEST, gdk_visual_get_system(), w, h );
704
76f7048e 705 pl_vout_buf = (void *) image->mem;
b7b2fb41
B		 706
707 gtk_image_set_from_image (GTK_IMAGE(drawing), image, NULL);
708
709 gtk_window_resize (GTK_WINDOW (actor), w, h);
d64280d6 710 if (g_maemo_opts & 2)
bbd471af
B		 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,
b7b2fb41
B		 717 (gdouble)D_WIDTH / (gdouble)w,
718 (gdouble)D_HEIGHT / (gdouble)h
bbd471af
B		 719 );
720 pl_buf_w=w;pl_buf_h=h;
76f7048e 721 return pl_vout_buf;
b7b2fb41
B		 722}
723
6469a8c4 724void *plat_gvideo_flip(void)
b7b2fb41 725{
a76fd953
PI		 726 if (!(g_maemo_opts&8))
727 gtk_widget_queue_draw(drawing);
e0c692d9 728
bbd471af 729 // process accelometer
d64280d6 730 if (g_maemo_opts & 4) {
a76fd953 731 float x, y, z;
bbd471af
B		 732 FILE* f = fopen( "/sys/class/i2c-adapter/i2c-3/3-001d/coord", "r" );
733 if( !f ) {printf ("err in accel"); exit(1);}
a76fd953 734 fscanf( f, "%f %f %f", &x, &y, &z );
bbd471af
B		 735 fclose( f );
736
a76fd953
PI		 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;
d64280d6 766 else {in_keystate &= ~(1 << DKEY_LEFT);in_keystate &= ~(1 << DKEY_RIGHT);}
bbd471af 767
a76fd953
PI		 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;
d64280d6 771 else {in_keystate &= ~(1 << DKEY_DOWN);in_keystate &= ~(1 << DKEY_UP);}
a76fd953 772 }
bbd471af
B		 773 }
774
7010034e 775 return pl_vout_buf;
776}
777
778// for frontend/plugin_lib.c
779void update_input(void)
780{
a76fd953
PI		 781 if (g_maemo_opts & 8)
782 maemo_x11_update_keys();
7010034e 783 else {
784 /* process GTK+ events */
785 while (gtk_events_pending())
786 gtk_main_iteration();
a76fd953 787 }
b7b2fb41
B		 788}
789
a76fd953 790int omap_enable_layer(int enabled)
b7b2fb41 791{
a76fd953 792 return 0;
b7b2fb41
B		 793}
794
a76fd953 795void menu_notify_mode_change(int w, int h, int bpp)
29a8c4f3 796{
29a8c4f3 797}
798
88d6397d 799void *plat_prepare_screenshot(int *w, int *h, int *bpp)
800{
801 return NULL;
802}
803
a76fd953
PI		 804void plat_step_volume(int is_up)
805{
806}
807
d71c7095 808void plat_trigger_vibrate(int pad, int low, int high)
b944a30e 809{
a76fd953
PI		 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);
d71c7095 820 // FIXME: somebody with hardware should tune this
821 int speed = high; // is_strong ? 200 : 150;
a76fd953
PI		 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 }
b944a30e 831}
a805c855 832
a76fd953
PI		 833void plat_minimize(void)
834{
835}
836
837void plat_gvideo_close(void)
838{
839}
840
841void plat_gvideo_open(int is_pal)
a805c855 842{
843}
ARM optimized PCSX fork