src/shell/KeyboardReader.h

/*
 * LSCP Shell
 *
 * Copyright (c) 2014 Christian Schoenebeck
 *
 * This program is part of LinuxSampler and released under the same terms.
 */

#ifndef KEYBOARDREADER_H
#define KEYBOARDREADER_H

#include <list>
#include <string>

#include "../common/global.h"
#include "../common/Thread.h"
#include "../common/Condition.h"
#include "TerminalCtrl.h"

#define KBD_BACKSPACE 127
#define KBD_ESCAPE    27

using namespace LinuxSampler;

/**
 * Implements a FIFO object that is constantly reading from stdin on a separate
 * thread. The reader thread can call a callback function as soon as new data
 * arrived from stdin. The reader thread will react on every single key stroke,
 * that is it will already fire before line end (RETURN / ENTER) was received.
 */
class KeyboardReader : protected Thread {
public:
    typedef void(*Callback_t)(KeyboardReader*);

    KeyboardReader();
    virtual ~KeyboardReader();
    void setCallback(Callback_t fn);
    void callback(bool b);
    bool charAvailable() const;
    char popChar();
    void startReading();
        void stopReading();
    std::string popStringToDelimiterSync(char delimiter, bool includeDelimiter = false);
    
    static KeyboardReader* singleton();
protected:
    int Main() OVERRIDE;
private:
    TerminalSetting m_originalTerminalSetting;
    Callback_t m_callback;
    std::list<char> m_fifo;
    Mutex m_fifoMutex;
    bool m_doCallback;
    Condition m_sync;
    char m_syncDelimiter;
};

#endif // KEYBOARDREADER_H
1	/*
2	* LSCP Shell
3	*
4	* Copyright (c) 2014 Christian Schoenebeck
5	*
6	* This program is part of LinuxSampler and released under the same terms.
7	*/
8
9	#ifndef KEYBOARDREADER_H
10	#define KEYBOARDREADER_H
11
12	#include <list>
13	#include <string>
14
15	#include "../common/global.h"
16	#include "../common/Thread.h"
17	#include "../common/Condition.h"
18	#include "TerminalCtrl.h"
19
20	#define KBD_BACKSPACE 127
21	#define KBD_ESCAPE 27
22
23	using namespace LinuxSampler;
24
25	/**
26	* Implements a FIFO object that is constantly reading from stdin on a separate
27	* thread. The reader thread can call a callback function as soon as new data
28	* arrived from stdin. The reader thread will react on every single key stroke,
29	* that is it will already fire before line end (RETURN / ENTER) was received.
30	*/
31	class KeyboardReader : protected Thread {
32	public:
33	typedef void(Callback_t)(KeyboardReader);
34
35	KeyboardReader();
36	virtual ~KeyboardReader();
37	void setCallback(Callback_t fn);
38	void callback(bool b);
39	bool charAvailable() const;
40	char popChar();
41	void startReading();
42	void stopReading();
43	std::string popStringToDelimiterSync(char delimiter, bool includeDelimiter = false);
44
45	static KeyboardReader* singleton();
46	protected:
47	int Main() OVERRIDE;
48	private:
49	TerminalSetting m_originalTerminalSetting;
50	Callback_t m_callback;
51	std::list<char> m_fifo;
52	Mutex m_fifoMutex;
53	bool m_doCallback;
54	Condition m_sync;
55	char m_syncDelimiter;
56	};
57
58	#endif // KEYBOARDREADER_H