irreco/src/core/irreco_hardkey_map.c

   1 /*
   2  * irreco - Ir Remote Control
   3  * Copyright (C) 2007  Arto Karppinen (arto.karppinen@iki.fi)
   4  *
   5  * This program is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU General Public License
   7  * as published by the Free Software Foundation; either version 2
   8  * of the License, or (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  18  */
  19
  20 #include "irreco_hardkey_map.h"
  21
  22 /**
  23  * @addtogroup IrrecoHardkeyMap
  24  * @ingroup Irreco
  25  *
  26  * @todo PURPOCE OF CLASS.
  27  *
  28  * @{
  29  */
  30
  31 /**
  32  * @file
  33  * Source file of @ref IrrecoHardkeyMap.
  34  */
  35
  36 /**
  37  * IrrecoHardkey
  38  */
  39
  40 gchar *irreco_hardkey_to_str(guint keyval)
  41 {
  42         gchar *name = NULL;
  43         GString *string;
  44         IRRECO_ENTER
  45
  46         switch (keyval) {
  47         case IRRECO_HARDKEY_UP:         name = "UP"; break;
  48         case IRRECO_HARDKEY_DOWN:       name = "DOWN"; break;
  49         case IRRECO_HARDKEY_LEFT:       name = "LEFT"; break;
  50         case IRRECO_HARDKEY_RIGHT:      name = "RIGHT"; break;
  51         case IRRECO_HARDKEY_SELECT:     name = "SELECT"; break;
  52         case IRRECO_HARDKEY_BACK:       name = "BACK"; break;
  53         case IRRECO_HARDKEY_MENU:       name = "MENU"; break;
  54         case IRRECO_HARDKEY_HOME:       name = "HOME"; break;
  55         case IRRECO_HARDKEY_FULLSCREEN: name = "FULLSCREEN"; break;
  56         case IRRECO_HARDKEY_PLUS:       name = "PLUS"; break;
  57         case IRRECO_HARDKEY_MINUS:      name = "MINUS"; break;
  58         }
  59
  60         string = g_string_new(NULL);
  61         if (name) {
  62                 g_string_printf(string, "%u %s", keyval, name);
  63         } else {
  64                 g_string_printf(string, "%u", keyval);
  65         }
  66         IRRECO_RETURN_STR(g_string_free(string, FALSE));
  67 }
  68
  69
  70 /**
  71  * @typedef IrrecoHardkeyMap
  72  *
  73  * Store data assosiated with device keys. That is only IrrecoCmdChains at the
  74  * moment.
  75  */
  76
  77 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  78 /* Prototypes                                                                 */
  79 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  80 static gboolean irreco_hardkey_map_free_foreach(gpointer key,
  81                                                 gpointer value,
  82                                                 gpointer user_data);
  83 static gboolean irreco_hardkey_map_find_cmd_chain_id_foreach(gpointer key,
  84                                                              gpointer value,
  85                                                              gpointer data);
  86 static void irreco_hardkey_map_chain_foreach_frapper(gpointer key,
  87                                                      gpointer value,
  88                                                      gpointer user_data);
  89
  90
  91
  92 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  93 /* Datatypes                                                                  */
  94 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
  95
  96 typedef struct _IrrecoHardkeyMapForeachData IrrecoHardkeyMapForeachData;
  97 struct _IrrecoHardkeyMapForeachData {
  98         IrrecoHardkeyMap     *self;
  99         IrrecoHardkeyMapFunc  func;
 100         gpointer              user_data;
 101 };
 102
 103 typedef struct _IrrecoHardkeyMapFindChainData IrrecoHardkeyMapFindChainData;
 104 struct _IrrecoHardkeyMapFindChainData {
 105         guint            *keyval;
 106         IrrecoCmdChainId id;
 107 };
 108
 109
 110
 111 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
 112 /* Construction & Destruction                                                 */
 113 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
 114
 115 /**
 116  * @name Construction & Destruction
 117  * @{
 118  */
 119
 120 IrrecoHardkeyMap *irreco_hardkey_map_new(IrrecoCmdChainManager *manager)
 121 {
 122         IrrecoHardkeyMap *self;
 123         IRRECO_ENTER
 124
 125         self = g_slice_new0(IrrecoHardkeyMap);
 126         self->manager = manager;
 127         self->table = g_hash_table_new(NULL, NULL);
 128         IRRECO_RETURN_PTR(self);
 129 }
 130
 131 void irreco_hardkey_map_free(IrrecoHardkeyMap *self)
 132 {
 133         IRRECO_ENTER
 134         if (self == NULL) IRRECO_RETURN;
 135         g_hash_table_foreach_remove(self->table,
 136                                     irreco_hardkey_map_free_foreach, self);
 137         g_hash_table_destroy(self->table);
 138         g_slice_free(IrrecoHardkeyMap, self);
 139         IRRECO_RETURN
 140 }
 141 static gboolean irreco_hardkey_map_free_foreach(gpointer key,
 142                                                 gpointer value,
 143                                                 gpointer user_data)
 144 {
 145         irreco_cmd_chain_manager_free_chain(
 146                 ((IrrecoHardkeyMap *) user_data )->manager,
 147                 (IrrecoCmdChainId) value );
 148         return TRUE;
 149 }
 150
 151 /** @} */
 152
 153
 154
 155 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
 156 /* Functions                                                                  */
 157 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/
 158
 159 /**
 160  * @name Private Functions
 161  * @{
 162  */
 163
 164 /**
 165  * Make sure some IrrecoCmdChain is assosiated with a keyval.
 166  */
 167 void irreco_hardkey_map_assosiate_chain(IrrecoHardkeyMap *self,
 168                                         guint keyval)
 169 {
 170         IrrecoCmdChainId id;
 171         IRRECO_ENTER
 172
 173         g_assert(self != NULL);
 174
 175         id = (IrrecoCmdChainId) g_hash_table_lookup(self->table,
 176                                                     (gpointer) keyval);
 177         if (id == 0) {
 178                 gchar *hardkey_str;
 179                 hardkey_str = irreco_hardkey_to_str(keyval);
 180                 IRRECO_DEBUG("Creating new chain for key \"%s\".\n",
 181                              hardkey_str);
 182                 g_free(hardkey_str);
 183                 id = irreco_cmd_chain_manager_new_chain(self->manager);
 184                 g_hash_table_insert(self->table,
 185                                     (gpointer) keyval,
 186                                     (gpointer) id);
 187         }
 188         IRRECO_RETURN
 189 }
 190
 191 /**
 192  * Assosiate IrrecoCmdChain with a particular keyval.
 193  */
 194 gboolean irreco_hardkey_map_assosiate_chain_with_id(IrrecoHardkeyMap *self,
 195                                                     guint keyval,
 196                                                     IrrecoCmdChainId id)
 197 {
 198         guint old_keyval;
 199         gchar *hardkey_str;
 200         IRRECO_ENTER
 201
 202         g_assert(self != NULL);
 203         g_assert(id > 0);
 204
 205         if (irreco_hardkey_map_find_cmd_chain_id(self, id, &old_keyval)) {
 206
 207                 gchar *keyval_str = irreco_hardkey_to_str(keyval);
 208                 gchar *old_keyval_str = irreco_hardkey_to_str(old_keyval);
 209
 210                 if (keyval == old_keyval) {
 211                         IRRECO_DEBUG("Keyval \"%s\" is already assosiated "
 212                                      "with command chain \"%i\".\n",
 213                                      keyval_str, id);
 214                 } else {
 215
 216                         IRRECO_DEBUG("Id \"%i\" cannot be assosiated with "
 217                                      "keyval \"%s\" because is is already "
 218                                      "assosited with keyval \"%s\".\n",
 219                                      id, keyval_str, old_keyval_str);
 220                 }
 221
 222                 g_free(keyval_str);
 223                 g_free(old_keyval_str);
 224                 IRRECO_RETURN_BOOL(FALSE);
 225         }
 226
 227         hardkey_str = irreco_hardkey_to_str(keyval);
 228         IRRECO_DEBUG("Creating new chain for key \"%s\" with id \"%i\".\n",
 229                      hardkey_str, id);
 230         g_free(hardkey_str);
 231
 232         irreco_cmd_chain_manager_new_chain_with_id(self->manager, id);
 233         g_hash_table_insert(self->table,
 234                             (gpointer) keyval,
 235                             (gpointer) id);
 236         IRRECO_RETURN_BOOL(TRUE);
 237 }
 238
 239 /**
 240  * Get a IrrecoCmdChain assosiated with a keyval.
 241  */
 242 IrrecoCmdChain *irreco_hardkey_map_get_cmd_chain(IrrecoHardkeyMap *self,
 243                                                  guint keyval)
 244 {
 245         gchar *hardkey_str;
 246         IrrecoCmdChain *chain;
 247         IrrecoCmdChainId id;
 248         IRRECO_ENTER
 249
 250         g_assert(self != NULL);
 251
 252         id = (IrrecoCmdChainId) g_hash_table_lookup(self->table,
 253                                                     (gpointer) keyval);
 254         chain = irreco_cmd_chain_manager_get_chain(self->manager, id);
 255
 256         hardkey_str = irreco_hardkey_to_str(keyval);
 257         if (id == 0) {
 258                 IRRECO_DEBUG("Hardkey \"%s\" is not assositead with a command "
 259                              "chain.\n", hardkey_str);
 260         } else {
 261                 IRRECO_DEBUG("Hardkey \"%s\" is assositead with command "
 262                              "chain \"%i\".\n", hardkey_str, id);
 263         }
 264         g_free(hardkey_str);
 265
 266         IRRECO_RETURN_PTR(chain);
 267 }
 268
 269 /**
 270  * Find out which keyval is assosiated with some IrrecoCmdChainId.
 271  *
 272  * The assosiated keyval will se stored to keyval pointer.
 273  *
 274  * @return TRUE if found. FALSE if not assosiated.
 275  */
 276 gboolean irreco_hardkey_map_find_cmd_chain_id(IrrecoHardkeyMap *self,
 277                                               IrrecoCmdChainId id,
 278                                               guint *keyval)
 279 {
 280         IrrecoHardkeyMapFindChainData find_data;
 281         IRRECO_ENTER
 282
 283         find_data.id = id;
 284         find_data.keyval = keyval;
 285         IRRECO_RETURN_BOOL(g_hash_table_find(self->table,
 286                           irreco_hardkey_map_find_cmd_chain_id_foreach,
 287                           &find_data) != NULL);
 288 }
 289 static gboolean irreco_hardkey_map_find_cmd_chain_id_foreach(gpointer key,
 290                                                              gpointer value,
 291                                                              gpointer data)
 292 {
 293         IrrecoHardkeyMapFindChainData *find_data = data;
 294         if ((IrrecoCmdChainId) value == find_data->id) {
 295                 if (find_data->keyval != NULL) *find_data->keyval = (guint) key;
 296                 return TRUE;
 297         }
 298         return FALSE;
 299 }
 300
 301 /**
 302  * Check if a IrrecoCmdChain has been assosiated with a keyval.
 303  */
 304 gboolean irreco_hardkey_map_cmd_chain_exists(IrrecoHardkeyMap *self, guint keyval)
 305 {
 306         IRRECO_ENTER
 307         IRRECO_RETURN_BOOL(g_hash_table_lookup(self->table, (gpointer) keyval)
 308                            != NULL);
 309 }
 310
 311 /**
 312  * For iterating trough the map.
 313  */
 314 void irreco_hardkey_map_chain_foreach(IrrecoHardkeyMap *self,
 315                                       IrrecoHardkeyMapFunc func,
 316                                       gpointer user_data)
 317 {
 318         IrrecoHardkeyMapForeachData data;
 319         IRRECO_ENTER
 320
 321         data.self = self;
 322         data.func = func;
 323         data.user_data = user_data;
 324         g_hash_table_foreach(self->table,
 325                              irreco_hardkey_map_chain_foreach_frapper, &data);
 326         IRRECO_RETURN
 327 }
 328 static void irreco_hardkey_map_chain_foreach_frapper(gpointer key,
 329                                                      gpointer value,
 330                                                      gpointer user_data)
 331 {
 332         IrrecoCmdChain *chain;
 333         IrrecoHardkeyMapForeachData *data = user_data;
 334         IRRECO_ENTER
 335
 336         chain = irreco_cmd_chain_manager_get_chain(data->self->manager,
 337                                                    (IrrecoCmdChainId) value);
 338         if (chain == NULL) IRRECO_RETURN;
 339         data->func(data->self,
 340                    (guint) key,
 341                    (IrrecoCmdChainId) value,
 342                    chain,
 343                    data->user_data);
 344         IRRECO_RETURN
 345 }
 346
 347 /** @} */
 348 /** @} */
 349
 350
 351
 352
 353
 354
 355
 356
 357
 358
 359
 360
 361
 362
 363
 364
 365
 366
 367
 368
 369
 370
 371
 372
 373
 374