git.maemo.org Git - drnoksnes/blob - gui/controls.c

   1 /*
   2 * This file is part of DrNokSnes
   3 *
   4 * Copyright (C) 2009 Javier S. Pedro <maemo@javispedro.com>
   5 *
   6 * This software is free software; you can redistribute it and/or
   7 * modify it under the terms of the GNU Lesser General Public License
   8 * as published by the Free Software Foundation; either version 2.1 of
   9 * the License, or (at your option) any later version.
  10 *
  11 * This software is distributed in the hope that it will be useful, but
  12 * WITHOUT ANY WARRANTY; without even the implied warranty of
  13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  14 * Lesser General Public License for more details.
  15 *
  16 * You should have received a copy of the GNU Lesser General Public
  17 * License along with this software; if not, write to the Free Software
  18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
  19 * 02110-1301 USA
  20 *
  21 */
  22
  23 #include <string.h>
  24 #include <gtk/gtk.h>
  25 #include <hildon/hildon-helper.h>
  26
  27 #if MAEMO_VERSION >= 5
  28 #include <hildon/hildon-gtk.h>
  29 #include <hildon/hildon-pannable-area.h>
  30 #include <hildon/hildon-button.h>
  31 #include <hildon/hildon-check-button.h>
  32 #include <hildon/hildon-picker-button.h>
  33 #include <hildon/hildon-touch-selector.h>
  34 #include <pango/pango-attributes.h>
  35 #else
  36 #include <hildon/hildon-caption.h>
  37 #endif
  38
  39 #include "plugin.h"
  40 #include "gconf.h"
  41 #include "i18n.h"
  42
  43 static GtkDialog* dialog;
  44 static int current_player;
  45 #if MAEMO_VERSION >= 5
  46 static HildonCheckButton* keys_chk;
  47 static HildonButton* keys_btn;
  48 static HildonCheckButton* touch_chk;
  49 static HildonCheckButton* touch_show_chk;
  50 #if CONF_ZEEMOTE
  51 static HildonCheckButton* zeemote_chk;
  52 #endif
  53 #else /* MAEMO_VERSION < 5 */
  54 static GtkCheckButton* keys_chk;
  55 static GtkButton* keys_btn;
  56 static GtkCheckButton* touch_chk;
  57 static GtkCheckButton* touch_show_chk;
  58 #if CONF_ZEEMOTE
  59 static GtkCheckButton* zeemote_chk;
  60 #endif
  61 #endif /* MAEMO_VERSION */
  62
  63 static void load_settings()
  64 {
  65         gchar key_base[kGConfPlayerPathBufferLen];
  66         const int key_len = sprintf(key_base, kGConfPlayerPath, current_player);
  67         gchar *key = key_base + key_len;
  68
  69 #if MAEMO_VERSION >= 5
  70         // Keyboard
  71         strcpy(key, kGConfPlayerKeyboardEnable);
  72         hildon_check_button_set_active(keys_chk,
  73                 gconf_client_get_bool(gcc, key_base, NULL));
  74
  75         // Touchscreen
  76         strcpy(key, kGConfPlayerTouchscreenEnable);
  77         hildon_check_button_set_active(touch_chk,
  78                 gconf_client_get_bool(gcc, key_base, NULL));
  79         strcpy(key, kGConfPlayerTouchscreenShow);
  80         hildon_check_button_set_active(touch_show_chk,
  81                 gconf_client_get_bool(gcc, key_base, NULL));
  82
  83 #if CONF_ZEEMOTE
  84         strcpy(key, kGConfPlayerZeemoteEnable);
  85         hildon_check_button_set_active(zeemote_chk,
  86                 gconf_client_get_bool(gcc, key_base, NULL));
  87 #endif
  88 #else /* MAEMO_VERSION < 5 */
  89         // Keyboard
  90         strcpy(key, kGConfPlayerKeyboardEnable);
  91         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(keys_chk),
  92                 gconf_client_get_bool(gcc, key_base, NULL));
  93
  94         // Touchscreen
  95         strcpy(key, kGConfPlayerTouchscreenEnable);
  96         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(touch_chk),
  97                 gconf_client_get_bool(gcc, key_base, NULL));
  98         strcpy(key, kGConfPlayerTouchscreenShow);
  99         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(touch_show_chk),
 100                 gconf_client_get_bool(gcc, key_base, NULL));
 101
 102 #if CONF_ZEEMOTE
 103         strcpy(key, kGConfPlayerZeemoteEnable);
 104         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(zeemote_chk),
 105                 gconf_client_get_bool(gcc, key_base, NULL));
 106 #endif
 107 #endif /* MAEMO_VERSION */
 108 }
 109
 110 static void save_settings()
 111 {
 112         gchar key_base[kGConfPlayerPathBufferLen];
 113         const int key_len = sprintf(key_base, kGConfPlayerPath, current_player);
 114         gchar *key = key_base + key_len;
 115
 116 #if MAEMO_VERSION >= 5
 117         // Keyboard
 118         strcpy(key, kGConfPlayerKeyboardEnable);
 119         gconf_client_set_bool(gcc, key_base,
 120                 hildon_check_button_get_active(keys_chk), NULL);
 121
 122         // Touchscreen
 123         strcpy(key, kGConfPlayerTouchscreenEnable);
 124         gconf_client_set_bool(gcc, key_base,
 125                 hildon_check_button_get_active(touch_chk), NULL);
 126         strcpy(key, kGConfPlayerTouchscreenShow);
 127         gconf_client_set_bool(gcc, key_base,
 128                 hildon_check_button_get_active(touch_show_chk), NULL);
 129
 130 #if CONF_ZEEMOTE
 131         strcpy(key, kGConfPlayerZeemoteEnable);
 132         gconf_client_set_bool(gcc, key_base,
 133                 hildon_check_button_get_active(zeemote_chk), NULL);
 134 #endif
 135 #else /* MAEMO_VERSION < 5 */
 136         // Keyboard
 137         strcpy(key, kGConfPlayerKeyboardEnable);
 138         gconf_client_set_bool(gcc, key_base,
 139                 gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(keys_chk)), NULL);
 140
 141         // Touchscreen
 142         strcpy(key, kGConfPlayerTouchscreenEnable);
 143         gconf_client_set_bool(gcc, key_base,
 144                 gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(touch_chk)), NULL);
 145         strcpy(key, kGConfPlayerTouchscreenShow);
 146         gconf_client_set_bool(gcc, key_base,
 147                 gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(touch_show_chk)), NULL);
 148
 149 #if CONF_ZEEMOTE
 150         strcpy(key, kGConfPlayerZeemoteEnable);
 151         gconf_client_set_bool(gcc, key_base,
 152                 gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(zeemote_chk)), NULL);
 153 #endif
 154 #endif /* MAEMO_VERSION */
 155 }
 156
 157 static void keys_btn_callback(GtkWidget * button, gpointer data)
 158 {
 159         keys_dialog(GTK_WINDOW(dialog), GPOINTER_TO_INT(data));
 160 }
 161
 162 static void cb_dialog_response(GtkWidget * button, gint response, gpointer data)
 163 {
 164         if (response == GTK_RESPONSE_OK) {
 165                 save_settings();
 166                 settings_update_controls(current_player);
 167         }
 168
 169         gtk_widget_destroy(GTK_WIDGET(dialog));
 170 }
 171
 172 #if MAEMO_VERSION >= 5
 173 static void set_button_layout(HildonButton* button,
 174  GtkSizeGroup* titles_size_group, GtkSizeGroup* values_size_group)
 175 {
 176         hildon_button_add_title_size_group(button, titles_size_group);
 177         hildon_button_add_value_size_group(button, values_size_group);
 178         hildon_button_set_alignment(button, 0.0, 0.5, 1.0, 0.0);
 179 }
 180 #endif
 181
 182 gchar* controls_describe(int player)
 183 {
 184         static gchar description[256];
 185         unsigned char count = 0;
 186
 187         gchar key_base[kGConfPlayerPathBufferLen];
 188         const int key_len = sprintf(key_base, kGConfPlayerPath, player);
 189         gchar *key = key_base + key_len;
 190
 191         description[0] = '\0';
 192
 193         strcpy(key, kGConfPlayerKeyboardEnable);
 194         if (gconf_client_get_bool(gcc, key_base, NULL)) {
 195                 strcpy(description, _("Keyboard"));
 196                 count++;
 197         }
 198
 199         strcpy(key, kGConfPlayerTouchscreenEnable);
 200         if (gconf_client_get_bool(gcc, key_base, NULL)) {
 201                 if (count > 0) strcat(description, ", ");
 202                 strcat(description, _("Touchscreen"));
 203                 count++;
 204         }
 205
 206 #if CONF_ZEEMOTE
 207         strcpy(key, kGConfPlayerZeemoteEnable);
 208         if (gconf_client_get_bool(gcc, key_base, NULL)) {
 209                 if (count > 0) strcat(description, ", ");
 210                 strcat(description, _("Zeemote"));
 211                 count++;
 212         }
 213 #endif
 214
 215         if (count == 0) {
 216                 /* Add some text if there are no enabled controls */
 217                 strcpy(description, _("Disabled"));
 218         }
 219
 220         return description;
 221 }
 222
 223 void controls_dialog(GtkWindow* parent, int player)
 224 {
 225         gchar* title = g_strdup_printf(_("Player %d controls"), player);
 226         dialog = GTK_DIALOG(gtk_dialog_new_with_buttons(title,
 227                 parent, GTK_DIALOG_MODAL,
 228                 GTK_STOCK_SAVE, GTK_RESPONSE_OK,
 229                 GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, NULL));
 230         g_free(title);
 231
 232         current_player = player;
 233
 234 #if MAEMO_VERSION >= 5
 235         GtkBox * box = GTK_BOX(gtk_vbox_new(FALSE, HILDON_MARGIN_HALF));
 236         HildonPannableArea * pannable =
 237                 HILDON_PANNABLE_AREA(hildon_pannable_area_new());
 238         GtkSizeGroup * titles_size_group =
 239                  gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);
 240         GtkSizeGroup * values_size_group =
 241                  gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);
 242         PangoAttrList *pattrlist = pango_attr_list_new();
 243         PangoAttribute *attr = pango_attr_size_new(22 * PANGO_SCALE);
 244         attr->start_index = 0;
 245         attr->end_index = G_MAXINT;
 246         pango_attr_list_insert(pattrlist, attr);
 247
 248         GtkLabel* separator_1 = GTK_LABEL(gtk_label_new(_("Keys")));
 249         gtk_label_set_attributes(separator_1, pattrlist);
 250         gtk_label_set_justify(separator_1, GTK_JUSTIFY_CENTER);
 251
 252         keys_chk = HILDON_CHECK_BUTTON(hildon_check_button_new(
 253                 HILDON_SIZE_AUTO_WIDTH | HILDON_SIZE_FINGER_HEIGHT));
 254         gtk_button_set_label(GTK_BUTTON(keys_chk), _("Enable keyboard"));
 255         set_button_layout(HILDON_BUTTON(keys_chk),
 256                 titles_size_group, values_size_group);
 257
 258         keys_btn = HILDON_BUTTON(hildon_button_new_with_text(
 259                 HILDON_SIZE_AUTO_WIDTH | HILDON_SIZE_FINGER_HEIGHT,
 260                 HILDON_BUTTON_ARRANGEMENT_HORIZONTAL,
 261                 _("Configure keys…"), NULL));
 262         set_button_layout(HILDON_BUTTON(keys_btn),
 263                 titles_size_group, values_size_group);
 264         g_signal_connect(G_OBJECT(keys_btn), "clicked",
 265                                         G_CALLBACK(keys_btn_callback), GINT_TO_POINTER(player));
 266
 267         GtkLabel* separator_2 = GTK_LABEL(gtk_label_new(_("Touchscreen")));
 268         gtk_label_set_attributes(separator_2, pattrlist);
 269         gtk_label_set_justify(separator_2, GTK_JUSTIFY_CENTER);
 270
 271         touch_chk = HILDON_CHECK_BUTTON(hildon_check_button_new(
 272                 HILDON_SIZE_AUTO_WIDTH | HILDON_SIZE_FINGER_HEIGHT));
 273         gtk_button_set_label(GTK_BUTTON(touch_chk),
 274                 _("Enable touchscreen buttons"));
 275         set_button_layout(HILDON_BUTTON(touch_chk),
 276                 titles_size_group, values_size_group);
 277
 278         touch_show_chk = HILDON_CHECK_BUTTON(hildon_check_button_new(
 279                 HILDON_SIZE_AUTO_WIDTH | HILDON_SIZE_FINGER_HEIGHT));
 280         gtk_button_set_label(GTK_BUTTON(touch_show_chk),
 281                 _("Show on-screen button grid"));
 282         set_button_layout(HILDON_BUTTON(touch_show_chk),
 283                 titles_size_group, values_size_group);
 284
 285 #if 0
 286         GtkLabel* separator_3 = GTK_LABEL(gtk_label_new(_("Accelerometer")));
 287         gtk_label_set_attributes(separator_3, pattrlist);
 288         gtk_label_set_justify(separator_3, GTK_JUSTIFY_CENTER);
 289
 290         GtkLabel* separator_4 = GTK_LABEL(gtk_label_new(_("Wiimote")));
 291         gtk_label_set_attributes(separator_4, pattrlist);
 292         gtk_label_set_justify(separator_4, GTK_JUSTIFY_CENTER);
 293 #endif
 294 #if CONF_ZEEMOTE
 295         GtkLabel* separator_5 = GTK_LABEL(gtk_label_new(_("Zeemote")));
 296         gtk_label_set_attributes(separator_5, pattrlist);
 297         gtk_label_set_justify(separator_5, GTK_JUSTIFY_CENTER);
 298
 299         zeemote_chk = HILDON_CHECK_BUTTON(hildon_check_button_new(
 300                 HILDON_SIZE_AUTO_WIDTH | HILDON_SIZE_FINGER_HEIGHT));
 301         gtk_button_set_label(GTK_BUTTON(zeemote_chk), _("Enable Zeemote joystick"));
 302         set_button_layout(HILDON_BUTTON(zeemote_chk),
 303                 titles_size_group, values_size_group);
 304 #endif
 305         gtk_box_pack_start(box, GTK_WIDGET(separator_1),
 306                 FALSE, FALSE, HILDON_MARGIN_HALF);
 307         gtk_box_pack_start(box, GTK_WIDGET(keys_chk),
 308                 FALSE, FALSE, 0);
 309         gtk_box_pack_start(box, GTK_WIDGET(keys_btn),
 310                 FALSE, FALSE, 0);
 311         gtk_box_pack_start(box, GTK_WIDGET(separator_2),
 312                 FALSE, FALSE, HILDON_MARGIN_HALF);
 313         gtk_box_pack_start(box, GTK_WIDGET(touch_chk),
 314                 FALSE, FALSE, 0);
 315         gtk_box_pack_start(box, GTK_WIDGET(touch_show_chk),
 316                 FALSE, FALSE, 0);
 317 #if 0
 318         gtk_box_pack_start(box, GTK_WIDGET(separator_3),
 319                 FALSE, FALSE, HILDON_MARGIN_HALF);
 320         gtk_box_pack_start(box, GTK_WIDGET(separator_4),
 321                 FALSE, FALSE, HILDON_MARGIN_HALF);
 322 #endif
 323 #if CONF_ZEEMOTE
 324         gtk_box_pack_start(box, GTK_WIDGET(separator_5),
 325                 FALSE, FALSE, HILDON_MARGIN_HALF);
 326         gtk_box_pack_start(box, GTK_WIDGET(zeemote_chk),
 327                 FALSE, FALSE, 0);
 328 #endif
 329
 330         hildon_pannable_area_add_with_viewport(pannable, GTK_WIDGET(box));
 331         gtk_box_pack_start_defaults(GTK_BOX(dialog->vbox), GTK_WIDGET(pannable));
 332
 333         pango_attr_list_unref(pattrlist);
 334         g_object_unref(titles_size_group);
 335         g_object_unref(values_size_group);
 336 #else
 337         GtkBox* keys_box = GTK_BOX(gtk_hbox_new(FALSE, HILDON_MARGIN_DEFAULT));
 338
 339         keys_chk = GTK_CHECK_BUTTON(gtk_check_button_new_with_label(
 340                 _("Enable keyboard")));
 341         keys_btn = GTK_BUTTON(gtk_button_new_with_label(_("Configure keys…")));
 342         g_signal_connect(G_OBJECT(keys_btn), "clicked",
 343                                         G_CALLBACK(keys_btn_callback), GINT_TO_POINTER(player));
 344
 345         gtk_box_pack_start_defaults(keys_box, GTK_WIDGET(keys_chk));
 346         gtk_box_pack_start_defaults(keys_box, GTK_WIDGET(keys_btn));
 347
 348         GtkWidget* sep_1 = GTK_WIDGET(gtk_hseparator_new());
 349         GtkBox* touch_box = GTK_BOX(gtk_vbox_new(FALSE, HILDON_MARGIN_HALF));
 350
 351         touch_chk = GTK_CHECK_BUTTON(gtk_check_button_new_with_label(
 352                 _("Enable touchscreen buttons")));
 353         touch_show_chk = GTK_CHECK_BUTTON(gtk_check_button_new_with_label(
 354                 _("Show on-screen button grid")));
 355
 356         gtk_box_pack_start_defaults(touch_box, GTK_WIDGET(touch_chk));
 357         gtk_box_pack_start_defaults(touch_box, GTK_WIDGET(touch_show_chk));
 358
 359 #if CONF_ZEEMOTE
 360         GtkWidget* sep_2 = GTK_WIDGET(gtk_hseparator_new());
 361         zeemote_chk = GTK_CHECK_BUTTON(gtk_check_button_new_with_label(
 362                 _("Enable Zeemote joystick")));
 363 #endif
 364
 365         gtk_box_pack_start_defaults(GTK_BOX(dialog->vbox), GTK_WIDGET(keys_box));
 366         gtk_box_pack_start_defaults(GTK_BOX(dialog->vbox), sep_1);
 367         gtk_box_pack_start_defaults(GTK_BOX(dialog->vbox), GTK_WIDGET(touch_box));
 368 #if CONF_ZEEMOTE
 369         gtk_box_pack_start_defaults(GTK_BOX(dialog->vbox), sep_2);
 370         gtk_box_pack_start_defaults(GTK_BOX(dialog->vbox), GTK_WIDGET(zeemote_chk));
 371 #endif
 372 #endif /* MAEMO_VERSION */
 373
 374         load_settings();
 375
 376 #if MAEMO_VERSION >= 5
 377         gtk_window_resize(GTK_WINDOW(dialog), 800, 360);
 378 #else
 379         gtk_window_resize(GTK_WINDOW(dialog), 450, 250);
 380 #endif
 381
 382         g_signal_connect(G_OBJECT(dialog), "response",
 383                                         G_CALLBACK (cb_dialog_response), NULL);
 384
 385         gtk_widget_show_all(GTK_WIDGET(dialog));
 386 }
 387