cppconsui/InputProcessor.h

   1 // Copyright (C) 2009-2015 Petr Pavlu <setup@dagobah.cz>
   2 //
   3 // This file is part of CenterIM.
   4 //
   5 // CenterIM is free software; you can redistribute it and/or modify
   6 // it under the terms of the GNU General Public License as published by
   7 // the Free Software Foundation; either version 2 of the License, or
   8 // (at your option) any later version.
   9 //
  10 // CenterIM 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 CenterIM.  If not, see <http://www.gnu.org/licenses/>.
  17
  18 /// @file
  19 /// InputProcessor base class.
  20 ///
  21 /// @ingroup cppconsui
  22
  23 #ifndef INPUTPROCESSOR_H
  24 #define INPUTPROCESSOR_H
  25
  26 #include "CppConsUI.h"
  27
  28 #include <sigc++/sigc++.h>
  29 #include <sigc++/signal.h>
  30
  31 #include <termkey.h>
  32
  33 #include <map>
  34 #include <string>
  35
  36 namespace CppConsUI {
  37
  38 /// Base class that takes care of input processing.
  39 ///
  40 /// It allows to define:
  41 /// - key-action bindings,
  42 /// - a chain of input processors (top to bottom).
  43 class InputProcessor {
  44 public:
  45   /// Defines when a key binding will be processed comparing with the child
  46   /// input processor, @see ProcessInput.
  47   enum BindableType {
  48     /// Key bindings will be processed after the child input processor.
  49     BINDABLE_NORMAL,
  50
  51     /// Key bindings will be processed before the child input processor.
  52     BINDABLE_OVERRIDE,
  53   };
  54
  55   InputProcessor();
  56   virtual ~InputProcessor() {}
  57
  58   /// There are 4 steps when processing input:
  59   /// <ol>
  60   /// <li>
  61   /// <i>Overriding key combos</i><br>
  62   /// Input is processed by checking for overriding key combinations. If a match
  63   /// is found, the function for that combo is executed.
  64   /// </li>
  65   /// <li>
  66   /// <i>Input child processing</i><br>
  67   /// If an input child is assigned, processing is done recursively by this
  68   /// child object.
  69   /// </li>
  70   /// <li>
  71   /// <i>Other key combos</i><br>
  72   /// Input is processed by checking for normal key combinations. If a match is
  73   /// found, the signal for that combo is sent.
  74   /// </li>
  75   /// <li>
  76   /// <i>Raw input processing</i><br>
  77   /// Non key combo raw input processing by objects. Used for e.g. input
  78   /// widgets.
  79   /// </li>
  80   /// </ol>
  81   ///
  82   /// @return True if the input was successfully processed, false otherwise.
  83   virtual bool processInput(const TermKeyKey &key);
  84
  85 protected:
  86   /// Bindable struct holds a function and a bindable type that is associated to
  87   /// some {context:action} pair.
  88   struct Bindable {
  89     Bindable() : type(BINDABLE_NORMAL) {}
  90     Bindable(const sigc::slot<void> &function, BindableType type)
  91       : function(function), type(type)
  92     {
  93     }
  94     virtual ~Bindable() {}
  95     // CONSUI_DISABLE_COPY(Bindable);
  96
  97     sigc::slot<void> function;
  98     BindableType type;
  99   };
 100
 101   /// Holds all actions and Bindables for a context, {action: Bindable}.
 102   typedef std::map<std::string, Bindable> BindableContext;
 103
 104   /// Holds all Key contexts for this class, {context: KeyContext}.
 105   typedef std::map<std::string, BindableContext> Bindables;
 106
 107   /// The set of declared Bindables.
 108   Bindables keybindings_;
 109
 110   /// A child that will get to process the input.
 111   InputProcessor *input_child_;
 112
 113   /// Set the child object that must process input before this object.
 114   virtual void setInputChild(InputProcessor &child);
 115   virtual void clearInputChild();
 116   virtual InputProcessor *getInputChild() { return input_child_; }
 117
 118   /// Binds a (context, action) pair with a function.
 119   ///
 120   /// The bind can be normal or override, depending on whether it needs to be
 121   /// called after or before the @ref input_child_.
 122   virtual void declareBindable(const char *context, const char *action,
 123     const sigc::slot<void> &function, BindableType type);
 124
 125   /// Tries to match an appropriate bound action to the input and process it.
 126   /// @return True if a match was found and processed.
 127   virtual bool process(BindableType type, const TermKeyKey &key);
 128
 129   virtual bool processInputText(const TermKeyKey &key);
 130
 131 private:
 132   CONSUI_DISABLE_COPY(InputProcessor);
 133 };
 134
 135 } // namespace CppConsUI
 136
 137 #endif // INPUTPROCESSOR_H
 138
 139 // vim: set tabstop=2 shiftwidth=2 textwidth=80 expandtab: