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

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
22	using namespace LinuxSampler;
23
24	/**
25	* Implements a FIFO object that is constantly reading from stdin on a separate
26	* thread. The reader thread can call a callback function as soon as new data
27	* arrived from stdin. The reader thread will react on every single key stroke,
28	* that is it will already fire before line end (RETURN / ENTER) was received.
29	*/
30	class KeyboardReader : protected Thread {
31	public:
32	typedef void(Callback_t)(KeyboardReader);
33
34	KeyboardReader();
35	virtual ~KeyboardReader();
36	void setCallback(Callback_t fn);
37	void callback(bool b);
38	bool charAvailable() const;
39	char popChar();
40	void startReading();
41	void stopReading();
42	std::string popStringToDelimiterSync(char delimiter, bool includeDelimiter = false);
43
44	static KeyboardReader* singleton();
45	protected:
46	int Main() OVERRIDE;
47	private:
48	TerminalSetting m_originalTerminalSetting;
49	Callback_t m_callback;
50	std::list<char> m_fifo;
51	Mutex m_fifoMutex;
52	bool m_doCallback;
53	Condition m_sync;
54	char m_syncDelimiter;
55	};
56
57	#endif // KEYBOARDREADER_H