GNU Octave  4.2.1
A high-level interpreted language, primarily intended for numerical computations, mostly compatible with Matlab
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Pages
KeyboardTranslator.h
Go to the documentation of this file.
1 /*
2  This source file is part of Konsole, a terminal emulator.
3 
4  Copyright (C) 2007, 2013 by Robert Knight <robertknight@gmail.com>
5 
6  Rewritten for QT4 by e_k <e_k at users.sourceforge.net>, Copyright (C)2008
7 
8  This program is free software; you can redistribute it and/or modify
9  it under the terms of the GNU General Public License as published by
10  the Free Software Foundation; either version 2 of the License, or
11  (at your option) any later version.
12 
13  This program is distributed in the hope that it will be useful,
14  but WITHOUT ANY WARRANTY; without even the implied warranty of
15  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16  GNU General Public License for more details.
17 
18  You should have received a copy of the GNU General Public License
19  along with this program; if not, write to the Free Software
20  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
21  02110-1301 USA.
22 */
23 
24 #ifndef KEYBOARDTRANSLATOR_H
25 #define KEYBOARDTRANSLATOR_H
26 
27 // Qt
28 #include <QtCore/QHash>
29 #include <QtCore/QList>
30 #include <QKeySequence>
31 #include <QtCore/QMetaType>
32 #include <QtCore/QVarLengthArray>
33 #include <QtCore>
34 
35 #if QT_VERSION >= 0x050100
36 # define K_GLOBAL_STATIC Q_GLOBAL_STATIC
37 #else
38 
39 typedef void (*CleanUpFunction)();
40 
41 /**
42  * @internal
43  *
44  * Helper class for K_GLOBAL_STATIC to clean up the object on library unload or application
45  * shutdown.
46  */
48 {
49  public:
51 
52  inline ~CleanUpGlobalStatic() { func(); }
53 };
54 
55 
56 //these directives are taken from the heart of kdecore
57 
58 # define K_GLOBAL_STATIC_STRUCT_NAME(NAME)
59 
60 #if QT_VERSION < 0x040400
61 # define Q_BASIC_ATOMIC_INITIALIZER Q_ATOMIC_INIT
62 # define testAndSetOrdered testAndSet
63 #endif
64 
65 #define K_GLOBAL_STATIC(TYPE, NAME) K_GLOBAL_STATIC_WITH_ARGS(TYPE, NAME, ())
66 
67 #define K_GLOBAL_STATIC_WITH_ARGS(TYPE, NAME, ARGS) \
68 static QBasicAtomicPointer<TYPE > _k_static_##NAME = Q_BASIC_ATOMIC_INITIALIZER(0); \
69 static bool _k_static_##NAME##_destroyed; \
70 static struct K_GLOBAL_STATIC_STRUCT_NAME(NAME) \
71 { \
72  bool isDestroyed() \
73  { \
74  return _k_static_##NAME##_destroyed; \
75  } \
76  inline operator TYPE*() \
77  { \
78  return operator->(); \
79  } \
80  inline TYPE *operator->() \
81  { \
82  if (!_k_static_##NAME) { \
83  if (isDestroyed()) { \
84  qFatal("Fatal Error: Accessed global static '%s *%s()' after destruction. " \
85  "Defined at %s:%d", #TYPE, #NAME, __FILE__, __LINE__); \
86  } \
87  TYPE *x = new TYPE ARGS; \
88  if (!_k_static_##NAME.testAndSetOrdered(0, x) \
89  && _k_static_##NAME != x ) { \
90  delete x; \
91  } else { \
92  static CleanUpGlobalStatic cleanUpObject = { destroy }; \
93  } \
94  } \
95  return _k_static_##NAME; \
96  } \
97  inline TYPE &operator*() \
98  { \
99  return *operator->(); \
100  } \
101  static void destroy() \
102  { \
103  _k_static_##NAME##_destroyed = true; \
104  TYPE *x = _k_static_##NAME; \
105  _k_static_##NAME = 0; \
106  delete x; \
107  } \
108 } NAME;
109 
110 #endif
111 
112 class QIODevice;
113 class QTextStream;
114 
115 /**
116  * A convertor which maps between key sequences pressed by the user and the
117  * character strings which should be sent to the terminal and commands
118  * which should be invoked when those character sequences are pressed.
119  *
120  * Konsole supports multiple keyboard translators, allowing the user to
121  * specify the character sequences which are sent to the terminal
122  * when particular key sequences are pressed.
123  *
124  * A key sequence is defined as a key code, associated keyboard modifiers
125  * (Shift,Ctrl,Alt,Meta etc.) and state flags which indicate the state
126  * which the terminal must be in for the key sequence to apply.
127  */
129 {
130 public:
131  /**
132  * The meaning of a particular key sequence may depend upon the state which
133  * the terminal emulation is in. Therefore findEntry() may return a different
134  * Entry depending upon the state flags supplied.
135  *
136  * This enum describes the states which may be associated with with a particular
137  * entry in the keyboard translation entry.
138  */
139  enum State
140  {
141  /** Indicates that no special state is active */
142  NoState = 0,
143  /**
144  * TODO More documentation
145  */
147  /**
148  * Indicates that the terminal is in 'Ansi' mode.
149  * TODO: More documentation
150  */
152  /**
153  * TODO More documentation
154  */
156  /**
157  * Indicates that the alternate screen ( typically used by interactive programs
158  * such as screen or vim ) is active
159  */
161  /** Indicates that any of the modifier keys is active. */
163  };
164  Q_DECLARE_FLAGS(States,State)
165 
166  /**
167  * This enum describes commands which are associated with particular key sequences.
168  */
169  enum Command
170  {
171  /** Indicates that no command is associated with this command sequence */
173  /** TODO Document me */
175  /** Scroll the terminal display up one page */
177  /** Scroll the terminal display down one page */
179  /** Scroll the terminal display up one line */
181  /** Scroll the terminal display down one line */
183  /** Toggles scroll lock mode */
185  /** Echos the operating system specific erase character. */
187  };
188  Q_DECLARE_FLAGS(Commands,Command)
189 
190  /**
191  * Represents an association between a key sequence pressed by the user
192  * and the character sequence and commands associated with it for a particular
193  * KeyboardTranslator.
194  */
195  class Entry
196  {
197  public:
198  /**
199  * Constructs a new entry for a keyboard translator.
200  */
201  Entry();
202 
203  /**
204  * Returns true if this entry is null.
205  * This is true for newly constructed entries which have no properties set.
206  */
207  bool isNull() const;
208 
209  /** Returns the commands associated with this entry */
210  Command command() const;
211  /** Sets the command associated with this entry. */
212  void setCommand(Command command);
213 
214  /**
215  * Returns the character sequence associated with this entry, optionally replacing
216  * wildcard '*' characters with numbers to indicate the keyboard modifiers being pressed.
217  *
218  * TODO: The numbers used to replace '*' characters are taken from the Konsole/KDE 3 code.
219  * Document them.
220  *
221  * @param expandWildCards Specifies whether wild cards (occurrences of the '*' character) in
222  * the entry should be replaced with a number to indicate the modifier keys being pressed.
223  *
224  * @param modifiers The keyboard modifiers being pressed.
225  */
226  QByteArray text(bool expandWildCards = false,
227  Qt::KeyboardModifiers modifiers = Qt::NoModifier) const;
228 
229  /** Sets the character sequence associated with this entry */
230  void setText(const QByteArray& text);
231 
232  /**
233  * Returns the character sequence associated with this entry,
234  * with any non-printable characters replaced with escape sequences.
235  *
236  * eg. \\E for Escape, \\t for tab, \\n for new line.
237  *
238  * @param expandWildCards See text()
239  * @param modifiers See text()
240  */
241  QByteArray escapedText(bool expandWildCards = false,
242  Qt::KeyboardModifiers modifiers = Qt::NoModifier) const;
243 
244  /** Returns the character code ( from the Qt::Key enum ) associated with this entry */
245  int keyCode() const;
246  /** Sets the character code associated with this entry */
247  void setKeyCode(int keyCode);
248 
249  /**
250  * Returns a bitwise-OR of the enabled keyboard modifiers associated with this entry.
251  * If a modifier is set in modifierMask() but not in modifiers(), this means that the entry
252  * only matches when that modifier is NOT pressed.
253  *
254  * If a modifier is not set in modifierMask() then the entry matches whether the modifier
255  * is pressed or not.
256  */
257  Qt::KeyboardModifiers modifiers() const;
258 
259  /** Returns the keyboard modifiers which are valid in this entry. See modifiers() */
260  Qt::KeyboardModifiers modifierMask() const;
261 
262  /** See modifiers() */
263  void setModifiers( Qt::KeyboardModifiers modifiers );
264  /** See modifierMask() and modifiers() */
265  void setModifierMask( Qt::KeyboardModifiers modifiers );
266 
267  /**
268  * Returns a bitwise-OR of the enabled state flags associated with this entry.
269  * If flag is set in stateMask() but not in state(), this means that the entry only
270  * matches when the terminal is NOT in that state.
271  *
272  * If a state is not set in stateMask() then the entry matches whether the terminal
273  * is in that state or not.
274  */
275  States state() const;
276 
277  /** Returns the state flags which are valid in this entry. See state() */
278  States stateMask() const;
279 
280  /** See state() */
281  void setState( States state );
282  /** See stateMask() */
283  void setStateMask( States mask );
284 
285  /**
286  * Returns the key code and modifiers associated with this entry
287  * as a QKeySequence
288  */
289  //QKeySequence keySequence() const;
290 
291  /**
292  * Returns this entry's conditions ( ie. its key code, modifier and state criteria )
293  * as a string.
294  */
295  QString conditionToString() const;
296 
297  /**
298  * Returns this entry's result ( ie. its command or character sequence )
299  * as a string.
300  *
301  * @param expandWildCards See text()
302  * @param modifiers See text()
303  */
304  QString resultToString(bool expandWildCards = false,
305  Qt::KeyboardModifiers modifiers = Qt::NoModifier) const;
306 
307  /**
308  * Returns true if this entry matches the given key sequence, specified
309  * as a combination of @p keyCode , @p modifiers and @p state.
310  */
311  bool matches( int keyCode ,
312  Qt::KeyboardModifiers modifiers ,
313  States flags ) const;
314 
315  bool operator==(const Entry& rhs) const;
316 
317  private:
318  void insertModifier( QString& item , int modifier ) const;
319  void insertState( QString& item , int state ) const;
320  QByteArray unescape(const QByteArray& text) const;
321 
322  int _keyCode;
323  Qt::KeyboardModifiers _modifiers;
324  Qt::KeyboardModifiers _modifierMask;
325  States _state;
326  States _stateMask;
327 
329  QByteArray _text;
330  };
331 
332  /** Constructs a new keyboard translator with the given @p name */
333  KeyboardTranslator(const QString& name);
334 
335  //KeyboardTranslator(const KeyboardTranslator& other);
336 
337  /** Returns the name of this keyboard translator */
338  QString name() const;
339 
340  /** Sets the name of this keyboard translator */
341  void setName(const QString& name);
342 
343  /** Returns the descriptive name of this keyboard translator */
344  QString description() const;
345 
346  /** Sets the descriptive name of this keyboard translator */
347  void setDescription(const QString& description);
348 
349  /**
350  * Looks for an entry in this keyboard translator which matches the given
351  * key code, keyboard modifiers and state flags.
352  *
353  * Returns the matching entry if found or a null Entry otherwise ( ie.
354  * entry.isNull() will return true )
355  *
356  * @param keyCode A key code from the Qt::Key enum
357  * @param modifiers A combination of modifiers
358  * @param state Optional flags which specify the current state of the terminal
359  */
360  Entry findEntry(int keyCode ,
361  Qt::KeyboardModifiers modifiers ,
362  States state = NoState) const;
363 
364  /**
365  * Adds an entry to this keyboard translator's table. Entries can be looked up according
366  * to their key sequence using findEntry()
367  */
368  void addEntry(const Entry& entry);
369 
370  /**
371  * Replaces an entry in the translator. If the @p existing entry is null,
372  * then this is equivalent to calling addEntry(@p replacement)
373  */
374  void replaceEntry(const Entry& existing , const Entry& replacement);
375 
376  /**
377  * Removes an entry from the table.
378  */
379  void removeEntry(const Entry& entry);
380 
381  /** Returns a list of all entries in the translator. */
382  QList<Entry> entries() const;
383 
384 private:
385 
386  QHash<int,Entry> _entries; // entries in this keyboard translation,
387  // entries are indexed according to
388  // their keycode
389  QString _name;
390  QString _description;
391 };
392 Q_DECLARE_OPERATORS_FOR_FLAGS(KeyboardTranslator::States)
393 Q_DECLARE_OPERATORS_FOR_FLAGS(KeyboardTranslator::Commands)
394 
395 /**
396  * Parses the contents of a Keyboard Translator (.keytab) file and
397  * returns the entries found in it.
398  *
399  * Usage example:
400  *
401  * @code
402  * QFile source( "/path/to/keytab" );
403  * source.open( QIODevice::ReadOnly );
404  *
405  * KeyboardTranslator* translator = new KeyboardTranslator( "name-of-translator" );
406  *
407  * KeyboardTranslatorReader reader(source);
408  * while ( reader.hasNextEntry() )
409  * translator->addEntry(reader.nextEntry());
410  *
411  * source.close();
412  *
413  * if ( !reader.parseError() )
414  * {
415  * // parsing succeeded, do something with the translator
416  * }
417  * else
418  * {
419  * // parsing failed
420  * }
421  * @endcode
422  */
424 {
425 public:
426  /** Constructs a new reader which parses the given @p source */
427  KeyboardTranslatorReader( QIODevice* source );
428 
429  /**
430  * Returns the description text.
431  * TODO: More documentation
432  */
433  QString description() const;
434 
435  /** Returns true if there is another entry in the source stream */
436  bool hasNextEntry();
437  /** Returns the next entry found in the source stream */
438  KeyboardTranslator::Entry nextEntry();
439 
440  /**
441  * Returns true if an error occurred whilst parsing the input or
442  * false if no error occurred.
443  */
444  bool parseError();
445 
446  /**
447  * Parses a condition and result string for a translator entry
448  * and produces a keyboard translator entry.
449  *
450  * The condition and result strings are in the same format as in
451  */
452  static KeyboardTranslator::Entry createEntry( const QString& condition ,
453  const QString& result );
454 private:
455  struct Token
456  {
457  enum Type
458  {
464  OutputText
465  };
467  QString text;
468  };
469  QList<Token> tokenize(const QString&);
470  void readNext();
471  bool decodeSequence(const QString& ,
472  int& keyCode,
473  Qt::KeyboardModifiers& modifiers,
474  Qt::KeyboardModifiers& modifierMask,
475  KeyboardTranslator::States& state,
476  KeyboardTranslator::States& stateFlags);
477 
478  static bool parseAsModifier(const QString& item , Qt::KeyboardModifier& modifier);
479  static bool parseAsStateFlag(const QString& item , KeyboardTranslator::State& state);
480  static bool parseAsKeyCode(const QString& item , int& keyCode);
481  static bool parseAsCommand(const QString& text , KeyboardTranslator::Command& command);
482 
483  QIODevice* _source;
484  QString _description;
486  bool _hasNext;
487 };
488 
489 /** Writes a keyboard translation to disk. */
491 {
492 public:
493  /**
494  * Constructs a new writer which saves data into @p destination.
495  * The caller is responsible for closing the device when writing is complete.
496  */
497  KeyboardTranslatorWriter(QIODevice* destination);
499 
500  /**
501  * Writes the header for the keyboard translator.
502  * @param description Description of the keyboard translator.
503  */
504  void writeHeader( const QString& description );
505  /** Writes a translator entry. */
506  void writeEntry( const KeyboardTranslator::Entry& entry );
507 
508 private:
509  QIODevice* _destination;
510  QTextStream* _writer;
511 };
512 
513 /**
514  * Manages the keyboard translations available for use by terminal sessions,
515  * see KeyboardTranslator.
516  */
518 {
519 public:
520  /**
521  * Constructs a new KeyboardTranslatorManager and loads the list of
522  * available keyboard translations.
523  *
524  * The keyboard translations themselves are not loaded until they are
525  * first requested via a call to findTranslator()
526  */
529 
530  /**
531  * Adds a new translator. If a translator with the same name
532  * already exists, it will be replaced by the new translator.
533  *
534  * TODO: More documentation.
535  */
536  void addTranslator(KeyboardTranslator* translator);
537 
538  /**
539  * Deletes a translator. Returns true on successful deletion or false otherwise.
540  *
541  * TODO: More documentation
542  */
543  bool deleteTranslator(const QString& name);
544 
545  /** Returns the default translator for Konsole. */
547 
548  /**
549  * Returns the keyboard translator with the given name or 0 if no translator
550  * with that name exists.
551  *
552  * The first time that a translator with a particular name is requested,
553  * the on-disk .keyboard file is loaded and parsed.
554  */
555  const KeyboardTranslator* findTranslator(const QString& name);
556  /**
557  * Returns a list of the names of available keyboard translators.
558  *
559  * The first time this is called, a search for available
560  * translators is started.
561  */
563 
564  /** Returns the global KeyboardTranslatorManager instance. */
566 
567 private:
568  static const char* defaultTranslatorText;
569 
570  void findTranslators(); // locate the available translators
571  KeyboardTranslator* loadTranslator(const QString& name); // loads the translator
572  // with the given name
573  KeyboardTranslator* loadTranslator(QIODevice* device,const QString& name);
574 
575  bool saveTranslator(const KeyboardTranslator* translator);
576  QString findTranslatorPath(const QString& name);
577 
578  QHash<QString,KeyboardTranslator*> _translators; // maps translator-name -> KeyboardTranslator
579  // instance
581 };
582 
583 inline int KeyboardTranslator::Entry::keyCode() const { return _keyCode; }
584 inline void KeyboardTranslator::Entry::setKeyCode(int keyCode) { _keyCode = keyCode; }
585 
586 inline void KeyboardTranslator::Entry::setModifiers( Qt::KeyboardModifiers modifier )
587 {
588  _modifiers = modifier;
589 }
590 inline Qt::KeyboardModifiers KeyboardTranslator::Entry::modifiers() const { return _modifiers; }
591 
592 inline void KeyboardTranslator::Entry::setModifierMask( Qt::KeyboardModifiers mask )
593 {
594  _modifierMask = mask;
595 }
596 inline Qt::KeyboardModifiers KeyboardTranslator::Entry::modifierMask() const { return _modifierMask; }
597 
599 {
600  return ( *this == Entry() );
601 }
602 
604 {
605  _command = command;
606 }
608 
609 inline void KeyboardTranslator::Entry::setText( const QByteArray& text )
610 {
611  _text = unescape(text);
612 }
613 inline int oneOrZero(int value)
614 {
615  return value ? 1 : 0;
616 }
617 inline QByteArray KeyboardTranslator::Entry::text(bool expandWildCards,Qt::KeyboardModifiers modifiers) const
618 {
619  QByteArray expandedText = _text;
620 
621  if (expandWildCards)
622  {
623  int modifierValue = 1;
624  modifierValue += oneOrZero(modifiers & Qt::ShiftModifier);
625  modifierValue += oneOrZero(modifiers & Qt::AltModifier) << 1;
626  modifierValue += oneOrZero(modifiers & Qt::ControlModifier) << 2;
627 
628  for (int i=0;i<_text.length();i++)
629  {
630  if (expandedText[i] == '*')
631  expandedText[i] = '0' + modifierValue;
632  }
633  }
634 
635  return expandedText;
636 }
637 
639 {
640  _state = state;
641 }
642 inline KeyboardTranslator::States KeyboardTranslator::Entry::state() const { return _state; }
643 
644 inline void KeyboardTranslator::Entry::setStateMask( States stateMask )
645 {
646  _stateMask = stateMask;
647 }
648 inline KeyboardTranslator::States KeyboardTranslator::Entry::stateMask() const { return _stateMask; }
649 
650 
651 #endif // KEYBOARDTRANSLATOR_H
652 
void setKeyCode(int keyCode)
Sets the character code associated with this entry.
QHash< int, Entry > _entries
Scroll the terminal display up one page.
Qt::KeyboardModifiers modifierMask() const
Returns the keyboard modifiers which are valid in this entry.
static const char * defaultTranslatorText
Command
This enum describes commands which are associated with particular key sequences.
Echos the operating system specific erase character.
Qt::KeyboardModifiers _modifierMask
Command command() const
Returns the commands associated with this entry.
void writeHeader(const QString &description)
Writes the header for the keyboard translator.
Entry findEntry(int keyCode, Qt::KeyboardModifiers modifiers, States state=NoState) const
Looks for an entry in this keyboard translator which matches the given key code, keyboard modifiers a...
void addTranslator(KeyboardTranslator *translator)
Adds a new translator.
bool isNull() const
Returns true if this entry is null.
QString findTranslatorPath(const QString &name)
CleanUpFunction func
void setModifiers(Qt::KeyboardModifiers modifiers)
See modifiers()
Indicates that no special state is active.
bool deleteTranslator(const QString &name)
Deletes a translator.
QByteArray text(bool expandWildCards=false, Qt::KeyboardModifiers modifiers=Qt::NoModifier) const
Returns the character sequence associated with this entry, optionally replacing wildcard '*' characte...
to define functions rather than attempting to enter them directly on the command line The block of commands is executed as soon as you exit the editor To avoid executing any simply delete all the lines from the buffer before leaving the editor When invoked with no edit the previously executed command
Definition: oct-hist.cc:587
State
The meaning of a particular key sequence may depend upon the state which the terminal emulation is in...
QString description() const
Returns the descriptive name of this keyboard translator.
const KeyboardTranslator * findTranslator(const QString &name)
Returns the keyboard translator with the given name or 0 if no translator with that name exists...
void writeEntry(const KeyboardTranslator::Entry &entry)
Writes a translator entry.
States state() const
Returns a bitwise-OR of the enabled state flags associated with this entry.
OCTAVE_EXPORT octave_value_list any number nd example oindent prints the prompt xample Pick a any number!nd example oindent and waits for the user to enter a value The string entered by the user is evaluated as an so it may be a literal a variable name
Definition: input.cc:871
void setText(const QByteArray &text)
Sets the character sequence associated with this entry.
KeyboardTranslatorWriter(QIODevice *destination)
Constructs a new writer which saves data into destination.
KeyboardTranslator(const QString &name)
Constructs a new keyboard translator with the given name.
States stateMask() const
Returns the state flags which are valid in this entry.
QList< QString > allTranslators()
Returns a list of the names of available keyboard translators.
QList< Entry > entries() const
Returns a list of all entries in the translator.
Manages the keyboard translations available for use by terminal sessions, see KeyboardTranslator.
Indicates that the alternate screen ( typically used by interactive programs such as screen or vim ) ...
Indicates that the terminal is in 'Ansi' mode.
int oneOrZero(int value)
bool saveTranslator(const KeyboardTranslator *translator)
void setStateMask(States mask)
See stateMask()
void setDescription(const QString &description)
Sets the descriptive name of this keyboard translator.
static KeyboardTranslatorManager * instance()
Returns the global KeyboardTranslatorManager instance.
Indicates that no command is associated with this command sequence.
Scroll the terminal display up one line.
void setCommand(Command command)
Sets the command associated with this entry.
void setName(const QString &name)
Sets the name of this keyboard translator.
const KeyboardTranslator * defaultTranslator()
Returns the default translator for Konsole.
A convertor which maps between key sequences pressed by the user and the character strings which shou...
void setModifierMask(Qt::KeyboardModifiers modifiers)
See modifierMask() and modifiers()
KeyboardTranslator * loadTranslator(const QString &name)
Scroll the terminal display down one line.
Parses the contents of a Keyboard Translator (.keytab) file and returns the entries found in it...
With real return the complex result
Definition: data.cc:3375
bool operator==(const dim_vector &a, const dim_vector &b)
Definition: dim-vector.h:538
static uint32_t state[624]
Definition: randmtzig.cc:184
QString name() const
Returns the name of this keyboard translator.
void(* CleanUpFunction)()
Qt::KeyboardModifiers modifiers() const
Returns a bitwise-OR of the enabled keyboard modifiers associated with this entry.
void setState(States state)
See state()
OCTAVE_EXPORT octave_value_list the first data row corresponds to an index of zero The a spreadsheet style form such as the file is read until end of file is reached The such as text
Definition: dlmread.cc:191
KeyboardTranslator::Entry _nextEntry
void replaceEntry(const Entry &existing, const Entry &replacement)
Replaces an entry in the translator.
Represents an association between a key sequence pressed by the user and the character sequence and c...
=val(i)}if ode{val(i)}occurs in table i
Definition: lookup.cc:239
OCTAVE_EXPORT octave_value_list or N dimensional array whose elements are all equal to the IEEE symbol zero divided by nd tex zero divided by nd ifnottex and any operation involving another NaN value(5+NaN).Note that NaN always compares not equal to NaN(NaN!
Writes a keyboard translation to disk.
KeyboardTranslatorManager()
Constructs a new KeyboardTranslatorManager and loads the list of available keyboard translations...
Indicates that any of the modifier keys is active.
Scroll the terminal display down one page.
QHash< QString, KeyboardTranslator * > _translators
int keyCode() const
Returns the character code ( from the Qt::Key enum ) associated with this entry.
void removeEntry(const Entry &entry)
Removes an entry from the table.
Qt::KeyboardModifiers _modifiers
void addEntry(const Entry &entry)
Adds an entry to this keyboard translator's table.