adam/g13gui
1
0
Fork 0
mirror of https://github.com/jtgans/g13gui.git synced 2025-06-20 08:23:50 -04:00
Code Issues Actions Packages Projects Releases Wiki Activity

g13d: Reformat all the files using clang-format

Browse Source 
This should help with maintainability.
This commit is contained in:
June Tate-Gans 2021-04-25 12:51:26 -05:00
parent c32950bfcb
commit c7992d52b5
13 changed files with 2010 additions and 1961 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

137
.clang-format Normal file
View File

@ -0,0 +1,137 @@
---
Language: Cpp
# BasedOnStyle: LLVM
AccessModifierOffset: -2
AlignAfterOpenBracket: Align
AlignConsecutiveMacros: false
AlignConsecutiveAssignments: false
AlignConsecutiveDeclarations: false
AlignEscapedNewlines: Right
AlignOperands: true
AlignTrailingComments: true
AllowAllArgumentsOnNextLine: true
AllowAllConstructorInitializersOnNextLine: true
AllowAllParametersOfDeclarationOnNextLine: true
AllowShortBlocksOnASingleLine: Never
AllowShortCaseLabelsOnASingleLine: false
AllowShortFunctionsOnASingleLine: All
AllowShortLambdasOnASingleLine: All
AllowShortIfStatementsOnASingleLine: Never
AllowShortLoopsOnASingleLine: false
AlwaysBreakAfterDefinitionReturnType: None
AlwaysBreakAfterReturnType: None
AlwaysBreakBeforeMultilineStrings: false
AlwaysBreakTemplateDeclarations: MultiLine
BinPackArguments: true
BinPackParameters: true
BraceWrapping:
AfterCaseLabel: false
AfterClass: false
AfterControlStatement: false
AfterEnum: false
AfterFunction: false
AfterNamespace: false
AfterObjCDeclaration: false
AfterStruct: false
AfterUnion: false
AfterExternBlock: false
BeforeCatch: false
BeforeElse: false
IndentBraces: false
SplitEmptyFunction: true
SplitEmptyRecord: true
SplitEmptyNamespace: true
BreakBeforeBinaryOperators: None
BreakBeforeBraces: Attach
BreakBeforeInheritanceComma: false
BreakInheritanceList: BeforeColon
BreakBeforeTernaryOperators: true
BreakConstructorInitializersBeforeComma: false
BreakConstructorInitializers: BeforeColon
BreakAfterJavaFieldAnnotations: false
BreakStringLiterals: true
ColumnLimit: 80
CommentPragmas: '^ IWYU pragma:'
CompactNamespaces: false
ConstructorInitializerAllOnOneLineOrOnePerLine: false
ConstructorInitializerIndentWidth: 4
ContinuationIndentWidth: 4
Cpp11BracedListStyle: true
DeriveLineEnding: true
DerivePointerAlignment: false
DisableFormat: false
ExperimentalAutoDetectBinPacking: false
FixNamespaceComments: true
ForEachMacros:
- foreach
- Q_FOREACH
- BOOST_FOREACH
IncludeBlocks: Preserve
IncludeCategories:
- Regex: '^"(llvm|llvm-c|clang|clang-c)/'
Priority: 2
SortPriority: 0
- Regex: '^(<|"(gtest|gmock|isl|json)/)'
Priority: 3
SortPriority: 0
- Regex: '.*'
Priority: 1
SortPriority: 0
IncludeIsMainRegex: '(Test)?$'
IncludeIsMainSourceRegex: ''
IndentCaseLabels: false
IndentGotoLabels: true
IndentPPDirectives: None
IndentWidth: 2
IndentWrappedFunctionNames: false
JavaScriptQuotes: Leave
JavaScriptWrapImports: true
KeepEmptyLinesAtTheStartOfBlocks: true
MacroBlockBegin: ''
MacroBlockEnd: ''
MaxEmptyLinesToKeep: 1
NamespaceIndentation: None
ObjCBinPackProtocolList: Auto
ObjCBlockIndentWidth: 2
ObjCSpaceAfterProperty: false
ObjCSpaceBeforeProtocolList: true
PenaltyBreakAssignment: 2
PenaltyBreakBeforeFirstCallParameter: 19
PenaltyBreakComment: 300
PenaltyBreakFirstLessLess: 120
PenaltyBreakString: 1000
PenaltyBreakTemplateDeclaration: 10
PenaltyExcessCharacter: 1000000
PenaltyReturnTypeOnItsOwnLine: 60
PointerAlignment: Right
ReflowComments: true
SortIncludes: true
SortUsingDeclarations: true
SpaceAfterCStyleCast: false
SpaceAfterLogicalNot: false
SpaceAfterTemplateKeyword: true
SpaceBeforeAssignmentOperators: true
SpaceBeforeCpp11BracedList: false
SpaceBeforeCtorInitializerColon: true
SpaceBeforeInheritanceColon: true
SpaceBeforeParens: ControlStatements
SpaceBeforeRangeBasedForLoopColon: true
SpaceInEmptyBlock: false
SpaceInEmptyParentheses: false
SpacesBeforeTrailingComments: 1
SpacesInAngles: false
SpacesInConditionalStatement: false
SpacesInContainerLiterals: true
SpacesInCStyleCastParentheses: false
SpacesInParentheses: false
SpacesInSquareBrackets: false
SpaceBeforeSquareBrackets: false
Standard: Latest
StatementMacros:
- Q_UNUSED
- QT_REQUIRE_VERSION
TabWidth: 8
UseCRLF: false
UseTab: Never
...

1151
g13d/g13.cc
View File

File diff suppressed because it is too large Load Diff

492
g13d/g13.h
View File

@ -1,28 +1,27 @@
#ifndef __G13_H__ #ifndef __G13_H__
#define __G13_H__ #define __G13_H__
#include "helper.h" #include "helper.h"
#include <boost/log/trivial.hpp> #include <boost/log/trivial.hpp>
#include <libusb-1.0/libusb.h> #include <libusb-1.0/libusb.h>
#include <sys/stat.h> #include <fcntl.h>
#include <string.h>
#include <signal.h>
#include <stdlib.h>
#include <unistd.h>
#include <fstream> #include <fstream>
#include <linux/uinput.h> #include <linux/uinput.h>
#include <fcntl.h> #include <signal.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <unistd.h>
// ************************************************************************* // *************************************************************************
namespace G13 { namespace G13 {
#define G13_LOG( level, message ) BOOST_LOG_TRIVIAL( level ) << message #define G13_LOG(level, message) BOOST_LOG_TRIVIAL(level) << message
#define G13_OUT( message ) BOOST_LOG_TRIVIAL( info ) << message #define G13_OUT(message) BOOST_LOG_TRIVIAL(info) << message
const size_t G13_INTERFACE = 0; const size_t G13_INTERFACE = 0;
const size_t G13_KEY_ENDPOINT = 1; const size_t G13_KEY_ENDPOINT = 1;
@ -34,15 +33,21 @@ const size_t G13_REPORT_SIZE = 8;
const size_t G13_LCD_BUFFER_SIZE = 0x3c0; const size_t G13_LCD_BUFFER_SIZE = 0x3c0;
const size_t G13_NUM_KEYS = 40; const size_t G13_NUM_KEYS = 40;
const size_t G13_LCD_COLUMNS = 160; const size_t G13_LCD_COLUMNS = 160;
const size_t G13_LCD_ROWS = 48; const size_t G13_LCD_ROWS = 48;
const size_t G13_LCD_BYTES_PER_ROW = G13_LCD_COLUMNS/8; const size_t G13_LCD_BYTES_PER_ROW = G13_LCD_COLUMNS / 8;
const size_t G13_LCD_BUF_SIZE = G13_LCD_ROWS * G13_LCD_BYTES_PER_ROW; const size_t G13_LCD_BUF_SIZE = G13_LCD_ROWS * G13_LCD_BYTES_PER_ROW;
const size_t G13_LCD_TEXT_CHEIGHT = 8; const size_t G13_LCD_TEXT_CHEIGHT = 8;
const size_t G13_LCD_TEXT_ROWS = 160 / G13_LCD_TEXT_CHEIGHT; const size_t G13_LCD_TEXT_ROWS = 160 / G13_LCD_TEXT_CHEIGHT;
enum stick_mode_t { STICK_ABSOLUTE, STICK_RELATIVE, STICK_KEYS, STICK_CALCENTER, STICK_CALBOUNDS, STICK_CALNORTH }; enum stick_mode_t {
STICK_ABSOLUTE,
STICK_RELATIVE,
STICK_KEYS,
STICK_CALCENTER,
STICK_CALBOUNDS,
STICK_CALNORTH
};
typedef int LINUX_KEY_VALUE; typedef int LINUX_KEY_VALUE;
const LINUX_KEY_VALUE BAD_KEY_VALUE = -1; const LINUX_KEY_VALUE BAD_KEY_VALUE = -1;
@ -51,8 +56,8 @@ typedef int G13_KEY_INDEX;
// ************************************************************************* // *************************************************************************
using Helper::repr;
using Helper::find_or_throw; using Helper::find_or_throw;
using Helper::repr;
// ************************************************************************* // *************************************************************************
@ -65,11 +70,11 @@ class G13_Manager;
class G13_CommandException : public std::exception { class G13_CommandException : public std::exception {
public: public:
G13_CommandException( const std::string &reason ) : _reason(reason) {} G13_CommandException(const std::string &reason) : _reason(reason) {}
virtual ~G13_CommandException() throw () {} virtual ~G13_CommandException() throw() {}
virtual const char *what() const throw () { return _reason.c_str(); } virtual const char *what() const throw() { return _reason.c_str(); }
std::string _reason; std::string _reason;
}; };
// ************************************************************************* // *************************************************************************
@ -79,37 +84,36 @@ public:
*/ */
class G13_Action { class G13_Action {
public: public:
G13_Action( G13_Device & keypad ) : _keypad(keypad) {} G13_Action(G13_Device &keypad) : _keypad(keypad) {}
virtual ~G13_Action(); virtual ~G13_Action();
virtual void act( G13_Device &, bool is_down ) = 0; virtual void act(G13_Device &, bool is_down) = 0;
virtual void dump( std::ostream & ) const = 0; virtual void dump(std::ostream &) const = 0;
void act( bool is_down ) { act( keypad(), is_down ); } void act(bool is_down) { act(keypad(), is_down); }
G13_Device & keypad() { return _keypad; } G13_Device &keypad() { return _keypad; }
const G13_Device & keypad() const { return _keypad; } const G13_Device &keypad() const { return _keypad; }
G13_Manager &manager(); G13_Manager &manager();
const G13_Manager &manager() const; const G13_Manager &manager() const;
private: private:
G13_Device & _keypad; G13_Device &_keypad;
}; };
/*! /*!
* action to send one or more keystrokes * action to send one or more keystrokes
*/ */
class G13_Action_Keys : public G13_Action { class G13_Action_Keys : public G13_Action {
public: public:
G13_Action_Keys( G13_Device & keypad, const std::string &keys ); G13_Action_Keys(G13_Device &keypad, const std::string &keys);
virtual ~G13_Action_Keys(); virtual ~G13_Action_Keys();
virtual void act( G13_Device &, bool is_down ); virtual void act(G13_Device &, bool is_down);
virtual void dump( std::ostream & ) const; virtual void dump(std::ostream &) const;
std::vector<LINUX_KEY_VALUE> _keys; std::vector<LINUX_KEY_VALUE> _keys;
}; };
/*! /*!
@ -117,13 +121,13 @@ public:
*/ */
class G13_Action_PipeOut : public G13_Action { class G13_Action_PipeOut : public G13_Action {
public: public:
G13_Action_PipeOut( G13_Device & keypad, const std::string &out ); G13_Action_PipeOut(G13_Device &keypad, const std::string &out);
virtual ~G13_Action_PipeOut(); virtual ~G13_Action_PipeOut();
virtual void act( G13_Device &, bool is_down ); virtual void act(G13_Device &, bool is_down);
virtual void dump( std::ostream & ) const; virtual void dump(std::ostream &) const;
std::string _out; std::string _out;
}; };
/*! /*!
@ -131,45 +135,39 @@ public:
*/ */
class G13_Action_Command : public G13_Action { class G13_Action_Command : public G13_Action {
public: public:
G13_Action_Command( G13_Device & keypad, const std::string &cmd ); G13_Action_Command(G13_Device &keypad, const std::string &cmd);
virtual ~G13_Action_Command(); virtual ~G13_Action_Command();
virtual void act( G13_Device &, bool is_down ); virtual void act(G13_Device &, bool is_down);
virtual void dump( std::ostream & ) const; virtual void dump(std::ostream &) const;
std::string _cmd; std::string _cmd;
}; };
typedef boost::shared_ptr<G13_Action> G13_ActionPtr; typedef boost::shared_ptr<G13_Action> G13_ActionPtr;
// ************************************************************************* // *************************************************************************
template <class PARENT_T> template <class PARENT_T> class G13_Actionable {
class G13_Actionable {
public: public:
G13_Actionable( PARENT_T &parent_arg, const std::string &name ) : G13_Actionable(PARENT_T &parent_arg, const std::string &name)
_parent_ptr(&parent_arg), _name(name) : _parent_ptr(&parent_arg), _name(name) {}
{} virtual ~G13_Actionable() { _parent_ptr = 0; }
virtual ~G13_Actionable() { _parent_ptr = 0; }
G13_ActionPtr action() const { return _action; } G13_ActionPtr action() const { return _action; }
const std::string & name() const { return _name; } const std::string &name() const { return _name; }
PARENT_T & parent() { return *_parent_ptr; } PARENT_T &parent() { return *_parent_ptr; }
const PARENT_T & parent() const { return *_parent_ptr; } const PARENT_T &parent() const { return *_parent_ptr; }
G13_Manager & manager() { return _parent_ptr->manager(); } G13_Manager &manager() { return _parent_ptr->manager(); }
const G13_Manager & manager() const { return _parent_ptr->manager(); } const G13_Manager &manager() const { return _parent_ptr->manager(); }
virtual void set_action( const G13_ActionPtr &action ) { virtual void set_action(const G13_ActionPtr &action) { _action = action; }
_action = action;
}
protected: protected:
std::string _name;
std::string _name; G13_ActionPtr _action;
G13_ActionPtr _action;
private: private:
PARENT_T *_parent_ptr; PARENT_T *_parent_ptr;
}; };
// ************************************************************************* // *************************************************************************
@ -178,47 +176,35 @@ private:
*/ */
class G13_Key : public G13_Actionable<G13_Profile> { class G13_Key : public G13_Actionable<G13_Profile> {
public: public:
void dump(std::ostream &o) const;
G13_KEY_INDEX index() const { return _index.index; }
void parse_key(unsigned char *byte, G13_Device *g13);
void dump( std::ostream &o ) const;
G13_KEY_INDEX index() const { return _index.index; }
void parse_key( unsigned char *byte, G13_Device *g13 );
protected: protected:
struct KeyIndex {
KeyIndex(int key) : index(key), offset(key / 8), mask(1 << (key % 8)) {}
int index;
unsigned char offset;
unsigned char mask;
};
struct KeyIndex { // G13_Profile is the only class able to instantiate G13_Keys
KeyIndex( int key ) : friend class G13_Profile;
index(key),
offset( key / 8 ),
mask( 1 << (key % 8) )
{}
int index; G13_Key(G13_Profile &mode, const std::string &name, int index)
unsigned char offset; : G13_Actionable<G13_Profile>(mode, name), _index(index),
unsigned char mask; _should_parse(true) {}
};
// G13_Profile is the only class able to instantiate G13_Keys G13_Key(G13_Profile &mode, const G13_Key &key)
friend class G13_Profile; : G13_Actionable<G13_Profile>(mode, key.name()), _index(key._index),
_should_parse(key._should_parse) {
set_action(key.action());
}
G13_Key( G13_Profile & mode, const std::string &name, int index ) : G13_Actionable<G13_Profile>( mode, name ), KeyIndex _index;
_index(index), bool _should_parse;
_should_parse(true)
{
}
G13_Key( G13_Profile & mode, const G13_Key &key ) : G13_Actionable<G13_Profile>( mode, key.name() ),
_index(key._index),
_should_parse(key._should_parse)
{
set_action(key.action());
}
KeyIndex _index;
bool _should_parse;
}; };
/*! /*!
@ -229,109 +215,99 @@ protected:
*/ */
class G13_Profile { class G13_Profile {
public: public:
G13_Profile(G13_Device &keypad, const std::string &name_arg ) : _keypad(keypad), _name(name_arg) { G13_Profile(G13_Device &keypad, const std::string &name_arg)
_init_keys(); : _keypad(keypad), _name(name_arg) {
} _init_keys();
G13_Profile(const G13_Profile &other, const std::string &name_arg ) : _keypad(other._keypad), _name(name_arg), _keys(other._keys) }
{ G13_Profile(const G13_Profile &other, const std::string &name_arg)
} : _keypad(other._keypad), _name(name_arg), _keys(other._keys) {}
// search key by G13 keyname
G13_Key *find_key(const std::string &keyname);
// search key by G13 keyname void dump(std::ostream &o) const;
G13_Key * find_key( const std::string &keyname );
void dump( std::ostream &o ) const; void parse_keys(unsigned char *buf);
const std::string &name() const { return _name; }
void parse_keys( unsigned char *buf ); const G13_Manager &manager() const;
const std::string &name() const { return _name; }
const G13_Manager &manager() const;
protected: protected:
G13_Device &_keypad; G13_Device &_keypad;
std::vector<G13_Key> _keys; std::vector<G13_Key> _keys;
std::string _name; std::string _name;
void _init_keys(); void _init_keys();
}; };
typedef boost::shared_ptr<G13_Profile> ProfilePtr; typedef boost::shared_ptr<G13_Profile> ProfilePtr;
class G13_FontChar { class G13_FontChar {
public: public:
static const int CHAR_BUF_SIZE = 8; static const int CHAR_BUF_SIZE = 8;
enum FONT_FLAGS { FF_ROTATE= 0x01 }; enum FONT_FLAGS { FF_ROTATE = 0x01 };
G13_FontChar() { G13_FontChar() {
memset(bits_regular, 0, CHAR_BUF_SIZE); memset(bits_regular, 0, CHAR_BUF_SIZE);
memset(bits_inverted, 0, CHAR_BUF_SIZE); memset(bits_inverted, 0, CHAR_BUF_SIZE);
} }
void set_character( unsigned char *data, int width, unsigned flags ); void set_character(unsigned char *data, int width, unsigned flags);
unsigned char bits_regular[CHAR_BUF_SIZE]; unsigned char bits_regular[CHAR_BUF_SIZE];
unsigned char bits_inverted[CHAR_BUF_SIZE]; unsigned char bits_inverted[CHAR_BUF_SIZE];
}; };
class G13_Font { class G13_Font {
public: public:
G13_Font(); G13_Font();
G13_Font( const std::string &name, unsigned int width = 8 ); G13_Font(const std::string &name, unsigned int width = 8);
void set_character(unsigned int c, unsigned char *data);
void set_character( unsigned int c, unsigned char *data ); template <class ARRAY_T, class FLAGST>
void install_font(ARRAY_T &data, FLAGST flags, int first = 0);
template < class ARRAY_T, class FLAGST > const std::string &name() const { return _name; }
void install_font( ARRAY_T &data, FLAGST flags, int first = 0 ); unsigned int width() const { return _width; }
const std::string &name() const { return _name; } const G13_FontChar &char_data(unsigned int x) { return _chars[x]; }
unsigned int width() const { return _width; }
const G13_FontChar &char_data( unsigned int x ) { return _chars[x]; }
protected: protected:
std::string _name; std::string _name;
unsigned int _width; unsigned int _width;
G13_FontChar _chars[256]; G13_FontChar _chars[256];
//unsigned char font_basic[256][8]; // unsigned char font_basic[256][8];
//unsigned char font_inverted[256][8]; // unsigned char font_inverted[256][8];
}; };
typedef boost::shared_ptr<G13_Font> FontPtr; typedef boost::shared_ptr<G13_Font> FontPtr;
class G13_LCD { class G13_LCD {
public: public:
G13_LCD(G13_Device &keypad);
G13_Device &_keypad;
G13_LCD( G13_Device &keypad ); unsigned char image_buf[G13_LCD_BUF_SIZE + 8];
unsigned cursor_row;
G13_Device &_keypad; unsigned cursor_col;
unsigned char image_buf[G13_LCD_BUF_SIZE+8]; int text_mode;
unsigned cursor_row;
unsigned cursor_col;
int text_mode;
void image(unsigned char *data, int size); void image(unsigned char *data, int size);
void image_send() { void image_send() { image(image_buf, G13_LCD_BUF_SIZE); }
image( image_buf, G13_LCD_BUF_SIZE );
void image_test(int x, int y);
void image_clear() { memset(image_buf, 0, G13_LCD_BUF_SIZE); }
unsigned image_byte_offset(unsigned row, unsigned col) {
return col + (row / 8) * G13_LCD_BYTES_PER_ROW * 8;
} }
void image_test( int x, int y ); void image_setpixel(unsigned row, unsigned col);
void image_clear() { void image_clearpixel(unsigned row, unsigned col);
memset( image_buf, 0, G13_LCD_BUF_SIZE );
}
unsigned image_byte_offset( unsigned row, unsigned col ) {
return col + (row /8 ) * G13_LCD_BYTES_PER_ROW * 8;
}
void image_setpixel( unsigned row, unsigned col );
void image_clearpixel( unsigned row, unsigned col );
void write_char( char c, int row = -1, int col = -1);
void write_string( const char *str );
void write_pos(int row, int col );
void write_char(char c, int row = -1, int col = -1);
void write_string(const char *str);
void write_pos(int row, int col);
}; };
using Helper::repr; using Helper::repr;
@ -342,70 +318,65 @@ typedef Helper::Bounds<double> G13_ZoneBounds;
// ************************************************************************* // *************************************************************************
class G13_StickZone : public G13_Actionable<G13_Stick> { class G13_StickZone : public G13_Actionable<G13_Stick> {
public: public:
G13_StickZone(G13_Stick &, const std::string &name, const G13_ZoneBounds &,
G13_ActionPtr = 0);
G13_StickZone( G13_Stick &, const std::string &name, const G13_ZoneBounds &, G13_ActionPtr = 0 ); bool operator==(const G13_StickZone &other) const {
return _name == other._name;
}
bool operator == ( const G13_StickZone &other ) const { return _name == other._name; } void dump(std::ostream &) const;
void dump( std::ostream & ) const;
void parse_key( unsigned char *byte, G13_Device *g13);
void test( const G13_ZoneCoord &loc );
void set_bounds( const G13_ZoneBounds &bounds ) { _bounds = bounds; }
void parse_key(unsigned char *byte, G13_Device *g13);
void test(const G13_ZoneCoord &loc);
void set_bounds(const G13_ZoneBounds &bounds) { _bounds = bounds; }
protected: protected:
bool _active;
bool _active; G13_ZoneBounds _bounds;
G13_ZoneBounds _bounds;
}; };
typedef boost::shared_ptr< G13_StickZone> G13_StickZonePtr; typedef boost::shared_ptr<G13_StickZone> G13_StickZonePtr;
// ************************************************************************* // *************************************************************************
class G13_Stick { class G13_Stick {
public: public:
G13_Stick( G13_Device &keypad ); G13_Stick(G13_Device &keypad);
void parse_joystick(unsigned char *buf); void parse_joystick(unsigned char *buf);
void set_mode( stick_mode_t ); void set_mode(stick_mode_t);
G13_StickZone * zone( const std::string &, bool create=false ); G13_StickZone *zone(const std::string &, bool create = false);
void remove_zone( const G13_StickZone &zone ); void remove_zone(const G13_StickZone &zone);
const std::vector<G13_StickZone> & zones() const { return _zones; } const std::vector<G13_StickZone> &zones() const { return _zones; }
void dump( std::ostream & ) const; void dump(std::ostream &) const;
protected: protected:
void _recalc_calibrated();
void _recalc_calibrated(); G13_Device &_keypad;
std::vector<G13_StickZone> _zones;
G13_Device &_keypad; G13_StickBounds _bounds;
std::vector<G13_StickZone> _zones; G13_StickCoord _center_pos;
G13_StickCoord _north_pos;
G13_StickBounds _bounds; G13_StickCoord _current_pos;
G13_StickCoord _center_pos;
G13_StickCoord _north_pos;
G13_StickCoord _current_pos;
stick_mode_t _stick_mode;
stick_mode_t _stick_mode;
}; };
// ************************************************************************* // *************************************************************************
class G13_Device { class G13_Device {
public: public:
G13_Device(G13_Manager &manager, libusb_device_handle *handle, int id);
G13_Device( G13_Manager &manager, libusb_device_handle *handle, int id );
G13_Manager &manager() { return _manager; } G13_Manager &manager() { return _manager; }
const G13_Manager &manager() const { return _manager; } const G13_Manager &manager() const { return _manager; }
@ -415,54 +386,51 @@ public:
G13_Stick &stick() { return _stick; } G13_Stick &stick() { return _stick; }
const G13_Stick &stick() const { return _stick; } const G13_Stick &stick() const { return _stick; }
FontPtr switch_to_font( const std::string &name ); FontPtr switch_to_font(const std::string &name);
void switch_to_profile( const std::string &name ); void switch_to_profile(const std::string &name);
ProfilePtr profile( const std::string &name ); ProfilePtr profile(const std::string &name);
void dump(std::ostream &, int detail = 0 ); void dump(std::ostream &, int detail = 0);
void command(char const *str); void command(char const *str);
void read_commands(); void read_commands();
void read_config_file( const std::string &filename ); void read_config_file(const std::string &filename);
int read_keys(); int read_keys();
void parse_joystick(unsigned char *buf); void parse_joystick(unsigned char *buf);
G13_ActionPtr make_action( const std::string & ); G13_ActionPtr make_action(const std::string &);
void set_key_color( int red, int green, int blue ); void set_key_color(int red, int green, int blue);
void set_mode_leds( int leds ); void set_mode_leds(int leds);
void send_event(int type, int code, int val);
void write_output_pipe(const std::string &out);
void send_event( int type, int code, int val ); void write_lcd(unsigned char *data, size_t size);
void write_output_pipe( const std::string &out );
void write_lcd( unsigned char *data, size_t size ); bool is_set(int key);
bool update(int key, bool v);
bool is_set(int key) ;
bool update(int key, bool v) ;
// used by G13_Manager // used by G13_Manager
void cleanup(); void cleanup();
void register_context(libusb_context *ctx); void register_context(libusb_context *ctx);
void write_lcd_file( const std::string &filename); void write_lcd_file(const std::string &filename);
G13_Font &current_font() { return *_current_font; } G13_Font &current_font() { return *_current_font; }
G13_Profile &current_profile() { return *_current_profile; } G13_Profile &current_profile() { return *_current_profile; }
int id_within_manager() const { return _id_within_manager; } int id_within_manager() const { return _id_within_manager; }
typedef boost::function<void ( const char * )> COMMAND_FUNCTION; typedef boost::function<void(const char *)> COMMAND_FUNCTION;
typedef std::map<std::string, COMMAND_FUNCTION> CommandFunctionTable; typedef std::map<std::string, COMMAND_FUNCTION> CommandFunctionTable;
protected: protected:
void _init_fonts(); void _init_fonts();
void init_lcd(); void init_lcd();
void _init_commands(); void _init_commands();
// typedef void (COMMAND_FUNCTION)( G13_Device*, const char *, const char * );
//typedef void (COMMAND_FUNCTION)( G13_Device*, const char *, const char * );
CommandFunctionTable _command_table; CommandFunctionTable _command_table;
struct timeval _event_time; struct timeval _event_time;
@ -479,105 +447,93 @@ protected:
int _output_pipe_fid; int _output_pipe_fid;
std::string _output_pipe_name; std::string _output_pipe_name;
std::map<std::string,FontPtr> _fonts; std::map<std::string, FontPtr> _fonts;
FontPtr _current_font; FontPtr _current_font;
std::map<std::string,ProfilePtr> _profiles; std::map<std::string, ProfilePtr> _profiles;
ProfilePtr _current_profile; ProfilePtr _current_profile;
G13_Manager &_manager; G13_Manager &_manager;
G13_LCD _lcd; G13_LCD _lcd;
G13_Stick _stick; G13_Stick _stick;
bool keys[G13_NUM_KEYS]; bool keys[G13_NUM_KEYS];
}; };
// ************************************************************************* // *************************************************************************
/*! /*!
* top level class, holds what would otherwise be in global variables * top level class, holds what would otherwise be in global variables
*/ */
class G13_Manager { class G13_Manager {
public: public:
G13_Manager(); G13_Manager();
G13_KEY_INDEX find_g13_key_value( const std::string &keyname ) const; G13_KEY_INDEX find_g13_key_value(const std::string &keyname) const;
std::string find_g13_key_name( G13_KEY_INDEX ) const; std::string find_g13_key_name(G13_KEY_INDEX) const;
LINUX_KEY_VALUE find_input_key_value( const std::string &keyname ) const; LINUX_KEY_VALUE find_input_key_value(const std::string &keyname) const;
std::string find_input_key_name( LINUX_KEY_VALUE ) const; std::string find_input_key_name(LINUX_KEY_VALUE) const;
void set_logo( const std::string &fn ) { logo_filename = fn; } void set_logo(const std::string &fn) { logo_filename = fn; }
int run(); int run();
std::string string_config_value( const std::string &name ) const; std::string string_config_value(const std::string &name) const;
void set_string_config_value( const std::string &name, const std::string &val ); void set_string_config_value(const std::string &name, const std::string &val);
std::string make_pipe_name( G13_Device *d, bool is_input ); std::string make_pipe_name(G13_Device *d, bool is_input);
void set_log_level( ::boost::log::trivial::severity_level lvl ); void set_log_level(::boost::log::trivial::severity_level lvl);
void set_log_level( const std::string & ); void set_log_level(const std::string &);
protected: protected:
void init_keynames();
void display_keys();
void discover_g13s(libusb_device **devs, ssize_t count,
std::vector<G13_Device *> &g13s);
void cleanup();
void init_keynames(); std::string logo_filename;
void display_keys(); libusb_device **devs;
void discover_g13s(libusb_device **devs, ssize_t count, std::vector<G13_Device*>& g13s);
void cleanup();
libusb_context *ctx;
std::vector<G13_Device *> g13s;
std::map<G13_KEY_INDEX, std::string> g13_key_to_name;
std::map<std::string, G13_KEY_INDEX> g13_name_to_key;
std::map<LINUX_KEY_VALUE, std::string> input_key_to_name;
std::map<std::string, LINUX_KEY_VALUE> input_name_to_key;
std::string logo_filename; std::map<std::string, std::string> _string_config_values;
libusb_device **devs;
libusb_context *ctx; static bool running;
std::vector<G13_Device*> g13s; static void set_stop(int);
std::map<G13_KEY_INDEX,std::string> g13_key_to_name;
std::map<std::string,G13_KEY_INDEX> g13_name_to_key;
std::map<LINUX_KEY_VALUE,std::string> input_key_to_name;
std::map<std::string,LINUX_KEY_VALUE> input_name_to_key;
std::map<std::string, std::string> _string_config_values;
static bool running;
static void set_stop(int);
}; };
// ************************************************************************* // *************************************************************************
// inlines // inlines
inline G13_Manager &G13_Action::manager() { inline G13_Manager &G13_Action::manager() { return _keypad.manager(); }
return _keypad.manager();
inline const G13_Manager &G13_Action::manager() const {
return _keypad.manager();
} }
inline const G13_Manager &G13_Action::manager() const{ inline bool G13_Device::is_set(int key) { return keys[key]; }
return _keypad.manager();
}
inline bool G13_Device::is_set(int key)
{
return keys[key];
}
inline bool G13_Device::update(int key, bool v) { inline bool G13_Device::update(int key, bool v) {
bool old = keys[key]; bool old = keys[key];
keys[key] = v; keys[key] = v;
return old != v; return old != v;
} }
inline const G13_Manager &G13_Profile::manager() const inline const G13_Manager &G13_Profile::manager() const {
{ return _keypad.manager();
return _keypad.manager();
} }
// ************************************************************************* // *************************************************************************
} // namespace G13 } // namespace G13
#endif // __G13_H__ #endif // __G13_H__

793
g13d/g13_fonts.cc
View File

@ -4,419 +4,414 @@ using namespace std;
namespace G13 { namespace G13 {
// font data from https://github.com/dhepper/font8x8 // font data from https://github.com/dhepper/font8x8
// Constant: font8x8_basic // Constant: font8x8_basic
// Contains an 8x8 font map for unicode points U+0000 - U+007F (basic latin) // Contains an 8x8 font map for unicode points U+0000 - U+007F (basic latin)
unsigned char font8x8_basic[128][8] = { unsigned char font8x8_basic[128][8] = {
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+0000 (nul) {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+0000 (nul)
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+0001 {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+0001
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+0002 {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+0002
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+0003 {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+0003
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+0004 {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+0004
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+0005 {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+0005
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+0006 {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+0006
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+0007 {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+0007
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+0008 {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+0008
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+0009 {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+0009
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+000A {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+000A
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+000B {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+000B
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+000C {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+000C
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+000D {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+000D
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+000E {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+000E
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+000F {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+000F
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+0010 {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+0010
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+0011 {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+0011
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+0012 {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+0012
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+0013 {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+0013
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+0014 {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+0014
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+0015 {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+0015
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+0016 {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+0016
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+0017 {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+0017
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+0018 {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+0018
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+0019 {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+0019
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+001A {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+001A
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+001B {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+001B
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+001C {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+001C
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+001D {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+001D
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+001E {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+001E
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+001F {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+001F
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+0020 (space) {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+0020 (space)
{ 0x18, 0x3C, 0x3C, 0x18, 0x18, 0x00, 0x18, 0x00}, // U+0021 (!) {0x18, 0x3C, 0x3C, 0x18, 0x18, 0x00, 0x18, 0x00}, // U+0021 (!)
{ 0x36, 0x36, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+0022 (") {0x36, 0x36, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+0022 (")
{ 0x36, 0x36, 0x7F, 0x36, 0x7F, 0x36, 0x36, 0x00}, // U+0023 (#) {0x36, 0x36, 0x7F, 0x36, 0x7F, 0x36, 0x36, 0x00}, // U+0023 (#)
{ 0x0C, 0x3E, 0x03, 0x1E, 0x30, 0x1F, 0x0C, 0x00}, // U+0024 ($) {0x0C, 0x3E, 0x03, 0x1E, 0x30, 0x1F, 0x0C, 0x00}, // U+0024 ($)
{ 0x00, 0x63, 0x33, 0x18, 0x0C, 0x66, 0x63, 0x00}, // U+0025 (%) {0x00, 0x63, 0x33, 0x18, 0x0C, 0x66, 0x63, 0x00}, // U+0025 (%)
{ 0x1C, 0x36, 0x1C, 0x6E, 0x3B, 0x33, 0x6E, 0x00}, // U+0026 (&) {0x1C, 0x36, 0x1C, 0x6E, 0x3B, 0x33, 0x6E, 0x00}, // U+0026 (&)
{ 0x06, 0x06, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+0027 (') {0x06, 0x06, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+0027 (')
{ 0x18, 0x0C, 0x06, 0x06, 0x06, 0x0C, 0x18, 0x00}, // U+0028 (() {0x18, 0x0C, 0x06, 0x06, 0x06, 0x0C, 0x18, 0x00}, // U+0028 (()
{ 0x06, 0x0C, 0x18, 0x18, 0x18, 0x0C, 0x06, 0x00}, // U+0029 ()) {0x06, 0x0C, 0x18, 0x18, 0x18, 0x0C, 0x06, 0x00}, // U+0029 ())
{ 0x00, 0x66, 0x3C, 0xFF, 0x3C, 0x66, 0x00, 0x00}, // U+002A (*) {0x00, 0x66, 0x3C, 0xFF, 0x3C, 0x66, 0x00, 0x00}, // U+002A (*)
{ 0x00, 0x0C, 0x0C, 0x3F, 0x0C, 0x0C, 0x00, 0x00}, // U+002B (+) {0x00, 0x0C, 0x0C, 0x3F, 0x0C, 0x0C, 0x00, 0x00}, // U+002B (+)
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x0C, 0x0C, 0x06}, // U+002C (,) {0x00, 0x00, 0x00, 0x00, 0x00, 0x0C, 0x0C, 0x06}, // U+002C (,)
{ 0x00, 0x00, 0x00, 0x3F, 0x00, 0x00, 0x00, 0x00}, // U+002D (-) {0x00, 0x00, 0x00, 0x3F, 0x00, 0x00, 0x00, 0x00}, // U+002D (-)
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x0C, 0x0C, 0x00}, // U+002E (.) {0x00, 0x00, 0x00, 0x00, 0x00, 0x0C, 0x0C, 0x00}, // U+002E (.)
{ 0x60, 0x30, 0x18, 0x0C, 0x06, 0x03, 0x01, 0x00}, // U+002F (/) {0x60, 0x30, 0x18, 0x0C, 0x06, 0x03, 0x01, 0x00}, // U+002F (/)
{ 0x3E, 0x63, 0x73, 0x7B, 0x6F, 0x67, 0x3E, 0x00}, // U+0030 (0) {0x3E, 0x63, 0x73, 0x7B, 0x6F, 0x67, 0x3E, 0x00}, // U+0030 (0)
{ 0x0C, 0x0E, 0x0C, 0x0C, 0x0C, 0x0C, 0x3F, 0x00}, // U+0031 (1) {0x0C, 0x0E, 0x0C, 0x0C, 0x0C, 0x0C, 0x3F, 0x00}, // U+0031 (1)
{ 0x1E, 0x33, 0x30, 0x1C, 0x06, 0x33, 0x3F, 0x00}, // U+0032 (2) {0x1E, 0x33, 0x30, 0x1C, 0x06, 0x33, 0x3F, 0x00}, // U+0032 (2)
{ 0x1E, 0x33, 0x30, 0x1C, 0x30, 0x33, 0x1E, 0x00}, // U+0033 (3) {0x1E, 0x33, 0x30, 0x1C, 0x30, 0x33, 0x1E, 0x00}, // U+0033 (3)
{ 0x38, 0x3C, 0x36, 0x33, 0x7F, 0x30, 0x78, 0x00}, // U+0034 (4) {0x38, 0x3C, 0x36, 0x33, 0x7F, 0x30, 0x78, 0x00}, // U+0034 (4)
{ 0x3F, 0x03, 0x1F, 0x30, 0x30, 0x33, 0x1E, 0x00}, // U+0035 (5) {0x3F, 0x03, 0x1F, 0x30, 0x30, 0x33, 0x1E, 0x00}, // U+0035 (5)
{ 0x1C, 0x06, 0x03, 0x1F, 0x33, 0x33, 0x1E, 0x00}, // U+0036 (6) {0x1C, 0x06, 0x03, 0x1F, 0x33, 0x33, 0x1E, 0x00}, // U+0036 (6)
{ 0x3F, 0x33, 0x30, 0x18, 0x0C, 0x0C, 0x0C, 0x00}, // U+0037 (7) {0x3F, 0x33, 0x30, 0x18, 0x0C, 0x0C, 0x0C, 0x00}, // U+0037 (7)
{ 0x1E, 0x33, 0x33, 0x1E, 0x33, 0x33, 0x1E, 0x00}, // U+0038 (8) {0x1E, 0x33, 0x33, 0x1E, 0x33, 0x33, 0x1E, 0x00}, // U+0038 (8)
{ 0x1E, 0x33, 0x33, 0x3E, 0x30, 0x18, 0x0E, 0x00}, // U+0039 (9) {0x1E, 0x33, 0x33, 0x3E, 0x30, 0x18, 0x0E, 0x00}, // U+0039 (9)
{ 0x00, 0x0C, 0x0C, 0x00, 0x00, 0x0C, 0x0C, 0x00}, // U+003A (:) {0x00, 0x0C, 0x0C, 0x00, 0x00, 0x0C, 0x0C, 0x00}, // U+003A (:)
{ 0x00, 0x0C, 0x0C, 0x00, 0x00, 0x0C, 0x0C, 0x06}, // U+003B (//) {0x00, 0x0C, 0x0C, 0x00, 0x00, 0x0C, 0x0C, 0x06}, // U+003B (//)
{ 0x18, 0x0C, 0x06, 0x03, 0x06, 0x0C, 0x18, 0x00}, // U+003C (<) {0x18, 0x0C, 0x06, 0x03, 0x06, 0x0C, 0x18, 0x00}, // U+003C (<)
{ 0x00, 0x00, 0x3F, 0x00, 0x00, 0x3F, 0x00, 0x00}, // U+003D (=) {0x00, 0x00, 0x3F, 0x00, 0x00, 0x3F, 0x00, 0x00}, // U+003D (=)
{ 0x06, 0x0C, 0x18, 0x30, 0x18, 0x0C, 0x06, 0x00}, // U+003E (>) {0x06, 0x0C, 0x18, 0x30, 0x18, 0x0C, 0x06, 0x00}, // U+003E (>)
{ 0x1E, 0x33, 0x30, 0x18, 0x0C, 0x00, 0x0C, 0x00}, // U+003F (?) {0x1E, 0x33, 0x30, 0x18, 0x0C, 0x00, 0x0C, 0x00}, // U+003F (?)
{ 0x3E, 0x63, 0x7B, 0x7B, 0x7B, 0x03, 0x1E, 0x00}, // U+0040 (@) {0x3E, 0x63, 0x7B, 0x7B, 0x7B, 0x03, 0x1E, 0x00}, // U+0040 (@)
{ 0x0C, 0x1E, 0x33, 0x33, 0x3F, 0x33, 0x33, 0x00}, // U+0041 (A) {0x0C, 0x1E, 0x33, 0x33, 0x3F, 0x33, 0x33, 0x00}, // U+0041 (A)
{ 0x3F, 0x66, 0x66, 0x3E, 0x66, 0x66, 0x3F, 0x00}, // U+0042 (B) {0x3F, 0x66, 0x66, 0x3E, 0x66, 0x66, 0x3F, 0x00}, // U+0042 (B)
{ 0x3C, 0x66, 0x03, 0x03, 0x03, 0x66, 0x3C, 0x00}, // U+0043 (C) {0x3C, 0x66, 0x03, 0x03, 0x03, 0x66, 0x3C, 0x00}, // U+0043 (C)
{ 0x1F, 0x36, 0x66, 0x66, 0x66, 0x36, 0x1F, 0x00}, // U+0044 (D) {0x1F, 0x36, 0x66, 0x66, 0x66, 0x36, 0x1F, 0x00}, // U+0044 (D)
{ 0x7F, 0x46, 0x16, 0x1E, 0x16, 0x46, 0x7F, 0x00}, // U+0045 (E) {0x7F, 0x46, 0x16, 0x1E, 0x16, 0x46, 0x7F, 0x00}, // U+0045 (E)
{ 0x7F, 0x46, 0x16, 0x1E, 0x16, 0x06, 0x0F, 0x00}, // U+0046 (F) {0x7F, 0x46, 0x16, 0x1E, 0x16, 0x06, 0x0F, 0x00}, // U+0046 (F)
{ 0x3C, 0x66, 0x03, 0x03, 0x73, 0x66, 0x7C, 0x00}, // U+0047 (G) {0x3C, 0x66, 0x03, 0x03, 0x73, 0x66, 0x7C, 0x00}, // U+0047 (G)
{ 0x33, 0x33, 0x33, 0x3F, 0x33, 0x33, 0x33, 0x00}, // U+0048 (H) {0x33, 0x33, 0x33, 0x3F, 0x33, 0x33, 0x33, 0x00}, // U+0048 (H)
{ 0x1E, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x1E, 0x00}, // U+0049 (I) {0x1E, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x1E, 0x00}, // U+0049 (I)
{ 0x78, 0x30, 0x30, 0x30, 0x33, 0x33, 0x1E, 0x00}, // U+004A (J) {0x78, 0x30, 0x30, 0x30, 0x33, 0x33, 0x1E, 0x00}, // U+004A (J)
{ 0x67, 0x66, 0x36, 0x1E, 0x36, 0x66, 0x67, 0x00}, // U+004B (K) {0x67, 0x66, 0x36, 0x1E, 0x36, 0x66, 0x67, 0x00}, // U+004B (K)
{ 0x0F, 0x06, 0x06, 0x06, 0x46, 0x66, 0x7F, 0x00}, // U+004C (L) {0x0F, 0x06, 0x06, 0x06, 0x46, 0x66, 0x7F, 0x00}, // U+004C (L)
{ 0x63, 0x77, 0x7F, 0x7F, 0x6B, 0x63, 0x63, 0x00}, // U+004D (M) {0x63, 0x77, 0x7F, 0x7F, 0x6B, 0x63, 0x63, 0x00}, // U+004D (M)
{ 0x63, 0x67, 0x6F, 0x7B, 0x73, 0x63, 0x63, 0x00}, // U+004E (N) {0x63, 0x67, 0x6F, 0x7B, 0x73, 0x63, 0x63, 0x00}, // U+004E (N)
{ 0x1C, 0x36, 0x63, 0x63, 0x63, 0x36, 0x1C, 0x00}, // U+004F (O) {0x1C, 0x36, 0x63, 0x63, 0x63, 0x36, 0x1C, 0x00}, // U+004F (O)
{ 0x3F, 0x66, 0x66, 0x3E, 0x06, 0x06, 0x0F, 0x00}, // U+0050 (P) {0x3F, 0x66, 0x66, 0x3E, 0x06, 0x06, 0x0F, 0x00}, // U+0050 (P)
{ 0x1E, 0x33, 0x33, 0x33, 0x3B, 0x1E, 0x38, 0x00}, // U+0051 (Q) {0x1E, 0x33, 0x33, 0x33, 0x3B, 0x1E, 0x38, 0x00}, // U+0051 (Q)
{ 0x3F, 0x66, 0x66, 0x3E, 0x36, 0x66, 0x67, 0x00}, // U+0052 (R) {0x3F, 0x66, 0x66, 0x3E, 0x36, 0x66, 0x67, 0x00}, // U+0052 (R)
{ 0x1E, 0x33, 0x07, 0x0E, 0x38, 0x33, 0x1E, 0x00}, // U+0053 (S) {0x1E, 0x33, 0x07, 0x0E, 0x38, 0x33, 0x1E, 0x00}, // U+0053 (S)
{ 0x3F, 0x2D, 0x0C, 0x0C, 0x0C, 0x0C, 0x1E, 0x00}, // U+0054 (T) {0x3F, 0x2D, 0x0C, 0x0C, 0x0C, 0x0C, 0x1E, 0x00}, // U+0054 (T)
{ 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x3F, 0x00}, // U+0055 (U) {0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x3F, 0x00}, // U+0055 (U)
{ 0x33, 0x33, 0x33, 0x33, 0x33, 0x1E, 0x0C, 0x00}, // U+0056 (V) {0x33, 0x33, 0x33, 0x33, 0x33, 0x1E, 0x0C, 0x00}, // U+0056 (V)
{ 0x63, 0x63, 0x63, 0x6B, 0x7F, 0x77, 0x63, 0x00}, // U+0057 (W) {0x63, 0x63, 0x63, 0x6B, 0x7F, 0x77, 0x63, 0x00}, // U+0057 (W)
{ 0x63, 0x63, 0x36, 0x1C, 0x1C, 0x36, 0x63, 0x00}, // U+0058 (X) {0x63, 0x63, 0x36, 0x1C, 0x1C, 0x36, 0x63, 0x00}, // U+0058 (X)
{ 0x33, 0x33, 0x33, 0x1E, 0x0C, 0x0C, 0x1E, 0x00}, // U+0059 (Y) {0x33, 0x33, 0x33, 0x1E, 0x0C, 0x0C, 0x1E, 0x00}, // U+0059 (Y)
{ 0x7F, 0x63, 0x31, 0x18, 0x4C, 0x66, 0x7F, 0x00}, // U+005A (Z) {0x7F, 0x63, 0x31, 0x18, 0x4C, 0x66, 0x7F, 0x00}, // U+005A (Z)
{ 0x1E, 0x06, 0x06, 0x06, 0x06, 0x06, 0x1E, 0x00}, // U+005B ([) {0x1E, 0x06, 0x06, 0x06, 0x06, 0x06, 0x1E, 0x00}, // U+005B ([)
{ 0x03, 0x06, 0x0C, 0x18, 0x30, 0x60, 0x40, 0x00}, // U+005C (\) {0x03, 0x06, 0x0C, 0x18, 0x30, 0x60, 0x40, 0x00}, // U+005C (\)
{ 0x1E, 0x18, 0x18, 0x18, 0x18, 0x18, 0x1E, 0x00}, // U+005D (]) {0x1E, 0x18, 0x18, 0x18, 0x18, 0x18, 0x1E, 0x00}, // U+005D (])
{ 0x08, 0x1C, 0x36, 0x63, 0x00, 0x00, 0x00, 0x00}, // U+005E (^) {0x08, 0x1C, 0x36, 0x63, 0x00, 0x00, 0x00, 0x00}, // U+005E (^)
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF}, // U+005F (_) {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF}, // U+005F (_)
{ 0x0C, 0x0C, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+0060 (`) {0x0C, 0x0C, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+0060 (`)
{ 0x00, 0x00, 0x1E, 0x30, 0x3E, 0x33, 0x6E, 0x00}, // U+0061 (a) {0x00, 0x00, 0x1E, 0x30, 0x3E, 0x33, 0x6E, 0x00}, // U+0061 (a)
{ 0x07, 0x06, 0x06, 0x3E, 0x66, 0x66, 0x3B, 0x00}, // U+0062 (b) {0x07, 0x06, 0x06, 0x3E, 0x66, 0x66, 0x3B, 0x00}, // U+0062 (b)
{ 0x00, 0x00, 0x1E, 0x33, 0x03, 0x33, 0x1E, 0x00}, // U+0063 (c) {0x00, 0x00, 0x1E, 0x33, 0x03, 0x33, 0x1E, 0x00}, // U+0063 (c)
{ 0x38, 0x30, 0x30, 0x3e, 0x33, 0x33, 0x6E, 0x00}, // U+0064 (d) {0x38, 0x30, 0x30, 0x3e, 0x33, 0x33, 0x6E, 0x00}, // U+0064 (d)
{ 0x00, 0x00, 0x1E, 0x33, 0x3f, 0x03, 0x1E, 0x00}, // U+0065 (e) {0x00, 0x00, 0x1E, 0x33, 0x3f, 0x03, 0x1E, 0x00}, // U+0065 (e)
{ 0x1C, 0x36, 0x06, 0x0f, 0x06, 0x06, 0x0F, 0x00}, // U+0066 (f) {0x1C, 0x36, 0x06, 0x0f, 0x06, 0x06, 0x0F, 0x00}, // U+0066 (f)
{ 0x00, 0x00, 0x6E, 0x33, 0x33, 0x3E, 0x30, 0x1F}, // U+0067 (g) {0x00, 0x00, 0x6E, 0x33, 0x33, 0x3E, 0x30, 0x1F}, // U+0067 (g)
{ 0x07, 0x06, 0x36, 0x6E, 0x66, 0x66, 0x67, 0x00}, // U+0068 (h) {0x07, 0x06, 0x36, 0x6E, 0x66, 0x66, 0x67, 0x00}, // U+0068 (h)
{ 0x0C, 0x00, 0x0E, 0x0C, 0x0C, 0x0C, 0x1E, 0x00}, // U+0069 (i) {0x0C, 0x00, 0x0E, 0x0C, 0x0C, 0x0C, 0x1E, 0x00}, // U+0069 (i)
{ 0x30, 0x00, 0x30, 0x30, 0x30, 0x33, 0x33, 0x1E}, // U+006A (j) {0x30, 0x00, 0x30, 0x30, 0x30, 0x33, 0x33, 0x1E}, // U+006A (j)
{ 0x07, 0x06, 0x66, 0x36, 0x1E, 0x36, 0x67, 0x00}, // U+006B (k) {0x07, 0x06, 0x66, 0x36, 0x1E, 0x36, 0x67, 0x00}, // U+006B (k)
{ 0x0E, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x1E, 0x00}, // U+006C (l) {0x0E, 0x0C, 0x0C, 0x0C, 0x0C, 0x0C, 0x1E, 0x00}, // U+006C (l)
{ 0x00, 0x00, 0x33, 0x7F, 0x7F, 0x6B, 0x63, 0x00}, // U+006D (m) {0x00, 0x00, 0x33, 0x7F, 0x7F, 0x6B, 0x63, 0x00}, // U+006D (m)
{ 0x00, 0x00, 0x1F, 0x33, 0x33, 0x33, 0x33, 0x00}, // U+006E (n) {0x00, 0x00, 0x1F, 0x33, 0x33, 0x33, 0x33, 0x00}, // U+006E (n)
{ 0x00, 0x00, 0x1E, 0x33, 0x33, 0x33, 0x1E, 0x00}, // U+006F (o) {0x00, 0x00, 0x1E, 0x33, 0x33, 0x33, 0x1E, 0x00}, // U+006F (o)
{ 0x00, 0x00, 0x3B, 0x66, 0x66, 0x3E, 0x06, 0x0F}, // U+0070 (p) {0x00, 0x00, 0x3B, 0x66, 0x66, 0x3E, 0x06, 0x0F}, // U+0070 (p)
{ 0x00, 0x00, 0x6E, 0x33, 0x33, 0x3E, 0x30, 0x78}, // U+0071 (q) {0x00, 0x00, 0x6E, 0x33, 0x33, 0x3E, 0x30, 0x78}, // U+0071 (q)
{ 0x00, 0x00, 0x3B, 0x6E, 0x66, 0x06, 0x0F, 0x00}, // U+0072 (r) {0x00, 0x00, 0x3B, 0x6E, 0x66, 0x06, 0x0F, 0x00}, // U+0072 (r)
{ 0x00, 0x00, 0x3E, 0x03, 0x1E, 0x30, 0x1F, 0x00}, // U+0073 (s) {0x00, 0x00, 0x3E, 0x03, 0x1E, 0x30, 0x1F, 0x00}, // U+0073 (s)
{ 0x08, 0x0C, 0x3E, 0x0C, 0x0C, 0x2C, 0x18, 0x00}, // U+0074 (t) {0x08, 0x0C, 0x3E, 0x0C, 0x0C, 0x2C, 0x18, 0x00}, // U+0074 (t)
{ 0x00, 0x00, 0x33, 0x33, 0x33, 0x33, 0x6E, 0x00}, // U+0075 (u) {0x00, 0x00, 0x33, 0x33, 0x33, 0x33, 0x6E, 0x00}, // U+0075 (u)
{ 0x00, 0x00, 0x33, 0x33, 0x33, 0x1E, 0x0C, 0x00}, // U+0076 (v) {0x00, 0x00, 0x33, 0x33, 0x33, 0x1E, 0x0C, 0x00}, // U+0076 (v)
{ 0x00, 0x00, 0x63, 0x6B, 0x7F, 0x7F, 0x36, 0x00}, // U+0077 (w) {0x00, 0x00, 0x63, 0x6B, 0x7F, 0x7F, 0x36, 0x00}, // U+0077 (w)
{ 0x00, 0x00, 0x63, 0x36, 0x1C, 0x36, 0x63, 0x00}, // U+0078 (x) {0x00, 0x00, 0x63, 0x36, 0x1C, 0x36, 0x63, 0x00}, // U+0078 (x)
{ 0x00, 0x00, 0x33, 0x33, 0x33, 0x3E, 0x30, 0x1F}, // U+0079 (y) {0x00, 0x00, 0x33, 0x33, 0x33, 0x3E, 0x30, 0x1F}, // U+0079 (y)
{ 0x00, 0x00, 0x3F, 0x19, 0x0C, 0x26, 0x3F, 0x00}, // U+007A (z) {0x00, 0x00, 0x3F, 0x19, 0x0C, 0x26, 0x3F, 0x00}, // U+007A (z)
{ 0x38, 0x0C, 0x0C, 0x07, 0x0C, 0x0C, 0x38, 0x00}, // U+007B ({) {0x38, 0x0C, 0x0C, 0x07, 0x0C, 0x0C, 0x38, 0x00}, // U+007B ({)
{ 0x18, 0x18, 0x18, 0x00, 0x18, 0x18, 0x18, 0x00}, // U+007C (|) {0x18, 0x18, 0x18, 0x00, 0x18, 0x18, 0x18, 0x00}, // U+007C (|)
{ 0x07, 0x0C, 0x0C, 0x38, 0x0C, 0x0C, 0x07, 0x00}, // U+007D (}) {0x07, 0x0C, 0x0C, 0x38, 0x0C, 0x0C, 0x07, 0x00}, // U+007D (})
{ 0x6E, 0x3B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+007E (~) {0x6E, 0x3B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // U+007E (~)
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00} // U+007F {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00} // U+007F
}; };
unsigned char font5x8[][5] = { unsigned char font5x8[][5] = {
{ 0x00, 0x00, 0x00, 0x00, 0x00 }, // 0x20 (Space) {0x00, 0x00, 0x00, 0x00, 0x00}, // 0x20 (Space)
{ 0x00, 0x00, 0x9E, 0x00, 0x00 }, // 0x21 ! {0x00, 0x00, 0x9E, 0x00, 0x00}, // 0x21 !
{ 0x00, 0x0E, 0x00, 0x0E, 0x00 },// 0x22 " {0x00, 0x0E, 0x00, 0x0E, 0x00}, // 0x22 "
{ 0x28, 0xFE, 0x28, 0xFE, 0x28 },// 0x23 # {0x28, 0xFE, 0x28, 0xFE, 0x28}, // 0x23 #
{ 0x48, 0x54, 0xFE, 0x54, 0x24 },// 0x24 $ {0x48, 0x54, 0xFE, 0x54, 0x24}, // 0x24 $
{ 0x46, 0x26, 0x10, 0xC8, 0xC4 },// 0x25 % {0x46, 0x26, 0x10, 0xC8, 0xC4}, // 0x25 %
{ 0x6C, 0x92, 0xAA, 0x44, 0xA0 },// 0x26 & {0x6C, 0x92, 0xAA, 0x44, 0xA0}, // 0x26 &
{ 0x00, 0x0A, 0x06, 0x00, 0x00 },// 0x27 ' {0x00, 0x0A, 0x06, 0x00, 0x00}, // 0x27 '
{ 0x00, 0x38, 0x44, 0x82, 0x00 },// 0x28 ( {0x00, 0x38, 0x44, 0x82, 0x00}, // 0x28 (
{ 0x00, 0x82, 0x44, 0x38, 0x00 },// 0x29 ) {0x00, 0x82, 0x44, 0x38, 0x00}, // 0x29 )
{ 0x10, 0x54, 0x38, 0x54, 0x10 },// 0x2A * {0x10, 0x54, 0x38, 0x54, 0x10}, // 0x2A *
{ 0x10, 0x10, 0x7C, 0x10, 0x10 },// 0x2B + {0x10, 0x10, 0x7C, 0x10, 0x10}, // 0x2B +
{ 0x00, 0xA0, 0x60, 0x00, 0x00 },// 0x2C , {0x00, 0xA0, 0x60, 0x00, 0x00}, // 0x2C ,
{ 0x10, 0x10, 0x10, 0x10, 0x10 },// 0x2D - {0x10, 0x10, 0x10, 0x10, 0x10}, // 0x2D -
{ 0x00, 0x60, 0x60, 0x00, 0x00 },// 0x2E . {0x00, 0x60, 0x60, 0x00, 0x00}, // 0x2E .
{ 0x40, 0x20, 0x10, 0x08, 0x04 },// 0x2F / {0x40, 0x20, 0x10, 0x08, 0x04}, // 0x2F /
{ 0x7C, 0xA2, 0x92, 0x8A, 0x7C },// 0x30 0 {0x7C, 0xA2, 0x92, 0x8A, 0x7C}, // 0x30 0
{ 0x00, 0x84, 0xFE, 0x80, 0x00 },// 0x31 1 {0x00, 0x84, 0xFE, 0x80, 0x00}, // 0x31 1
{ 0x84, 0xC2, 0xA2, 0x92, 0x8C },// 0x32 2 {0x84, 0xC2, 0xA2, 0x92, 0x8C}, // 0x32 2
{ 0x42, 0x82, 0x8A, 0x96, 0x62 },// 0x33 3 {0x42, 0x82, 0x8A, 0x96, 0x62}, // 0x33 3
{ 0x30, 0x28, 0x24, 0xFE, 0x20 },// 0x34 4 {0x30, 0x28, 0x24, 0xFE, 0x20}, // 0x34 4
{ 0x4E, 0x8A, 0x8A, 0x8A, 0x72 },// 0x35 5 {0x4E, 0x8A, 0x8A, 0x8A, 0x72}, // 0x35 5
{ 0x78, 0x94, 0x92, 0x92, 0x60 },// 0x36 6 {0x78, 0x94, 0x92, 0x92, 0x60}, // 0x36 6
{ 0x02, 0xE2, 0x12, 0x0A, 0x06 },// 0x37 7 {0x02, 0xE2, 0x12, 0x0A, 0x06}, // 0x37 7
{ 0x6C, 0x92, 0x92, 0x92, 0x6C },// 0x38 8 {0x6C, 0x92, 0x92, 0x92, 0x6C}, // 0x38 8
{ 0x0C, 0x92, 0x92, 0x52, 0x3C },// 0x39 9 {0x0C, 0x92, 0x92, 0x52, 0x3C}, // 0x39 9
{ 0x00, 0x6C, 0x6C, 0x00, 0x00 },// 0x3A : {0x00, 0x6C, 0x6C, 0x00, 0x00}, // 0x3A :
{ 0x00, 0xAC, 0x6C, 0x00, 0x00 },// 0x3B ; {0x00, 0xAC, 0x6C, 0x00, 0x00}, // 0x3B ;
{ 0x00, 0x10, 0x28, 0x44, 0x82 },// 0x3C < {0x00, 0x10, 0x28, 0x44, 0x82}, // 0x3C <
{ 0x28, 0x28, 0x28, 0x28, 0x28 },// 0x3D = {0x28, 0x28, 0x28, 0x28, 0x28}, // 0x3D =
{ 0x82, 0x44, 0x28, 0x10, 0x00 },// 0x3E > {0x82, 0x44, 0x28, 0x10, 0x00}, // 0x3E >
{ 0x04, 0x02, 0xA2, 0x12, 0x0C },// 0x3F ? {0x04, 0x02, 0xA2, 0x12, 0x0C}, // 0x3F ?
{ 0x64, 0x92, 0xF2, 0x82, 0x7C },// 0x40 @ {0x64, 0x92, 0xF2, 0x82, 0x7C}, // 0x40 @
{ 0xFC, 0x22, 0x22, 0x22, 0xFC },// 0x41 A {0xFC, 0x22, 0x22, 0x22, 0xFC}, // 0x41 A
{ 0xFE, 0x92, 0x92, 0x92, 0x6C },// 0x42 B {0xFE, 0x92, 0x92, 0x92, 0x6C}, // 0x42 B
{ 0x7C, 0x82, 0x82, 0x82, 0x44 },// 0x43 C {0x7C, 0x82, 0x82, 0x82, 0x44}, // 0x43 C
{ 0xFE, 0x82, 0x82, 0x44, 0x38 },// 0x44 D {0xFE, 0x82, 0x82, 0x44, 0x38}, // 0x44 D
{ 0xFE, 0x92, 0x92, 0x92, 0x82 },// 0x45 E {0xFE, 0x92, 0x92, 0x92, 0x82}, // 0x45 E
{ 0xFE, 0x12, 0x12, 0x02, 0x02 },// 0x46 F {0xFE, 0x12, 0x12, 0x02, 0x02}, // 0x46 F
{ 0x7C, 0x82, 0x82, 0xA2, 0x64 },// 0x47 G {0x7C, 0x82, 0x82, 0xA2, 0x64}, // 0x47 G
{ 0xFE, 0x10, 0x10, 0x10, 0xFE },// 0x48 H {0xFE, 0x10, 0x10, 0x10, 0xFE}, // 0x48 H
{ 0x00, 0x82, 0xFE, 0x82, 0x00 },// 0x49 I {0x00, 0x82, 0xFE, 0x82, 0x00}, // 0x49 I
{ 0x40, 0x80, 0x82, 0x7E, 0x02 },// 0x4A J {0x40, 0x80, 0x82, 0x7E, 0x02}, // 0x4A J
{ 0xFE, 0x10, 0x28, 0x44, 0x82 },// 0x4B K {0xFE, 0x10, 0x28, 0x44, 0x82}, // 0x4B K
{ 0xFE, 0x80, 0x80, 0x80, 0x80 },// 0x4C L {0xFE, 0x80, 0x80, 0x80, 0x80}, // 0x4C L
{ 0xFE, 0x04, 0x08, 0x04, 0xFE },// 0x4D M {0xFE, 0x04, 0x08, 0x04, 0xFE}, // 0x4D M
{ 0xFE, 0x08, 0x10, 0x20, 0xFE },// 0x4E N {0xFE, 0x08, 0x10, 0x20, 0xFE}, // 0x4E N
{ 0x7C, 0x82, 0x82, 0x82, 0x7C },// 0x4F O {0x7C, 0x82, 0x82, 0x82, 0x7C}, // 0x4F O
{ 0xFE, 0x12, 0x12, 0x12, 0x0C },// 0x50 P {0xFE, 0x12, 0x12, 0x12, 0x0C}, // 0x50 P
{ 0x7C, 0x82, 0xA2, 0x42, 0xBC },// 0x51 Q {0x7C, 0x82, 0xA2, 0x42, 0xBC}, // 0x51 Q
{ 0xFE, 0x12, 0x32, 0x52, 0x8C },// 0x52 R {0xFE, 0x12, 0x32, 0x52, 0x8C}, // 0x52 R
{ 0x8C, 0x92, 0x92, 0x92, 0x62 },// 0x53 S {0x8C, 0x92, 0x92, 0x92, 0x62}, // 0x53 S
{ 0x02, 0x02, 0xFE, 0x02, 0x02 },// 0x54 T {0x02, 0x02, 0xFE, 0x02, 0x02}, // 0x54 T
{ 0x7E, 0x80, 0x80, 0x80, 0x7E },// 0x55 U {0x7E, 0x80, 0x80, 0x80, 0x7E}, // 0x55 U
{ 0x3E, 0x40, 0x80, 0x40, 0x3E },// 0x56 V {0x3E, 0x40, 0x80, 0x40, 0x3E}, // 0x56 V
{ 0xFE, 0x40, 0x30, 0x40, 0xFE },// 0x57 W {0xFE, 0x40, 0x30, 0x40, 0xFE}, // 0x57 W
{ 0xC6, 0x28, 0x10, 0x28, 0xC6 },// 0x58 X {0xC6, 0x28, 0x10, 0x28, 0xC6}, // 0x58 X
{ 0x06, 0x08, 0xF0, 0x08, 0x06 },// 0x59 Y {0x06, 0x08, 0xF0, 0x08, 0x06}, // 0x59 Y
{ 0xC2, 0xA2, 0x92, 0x8A, 0x86 },// 0x5A Z {0xC2, 0xA2, 0x92, 0x8A, 0x86}, // 0x5A Z
{ 0x00, 0x00, 0xFE, 0x82, 0x82 },// 0x5B [ {0x00, 0x00, 0xFE, 0x82, 0x82}, // 0x5B [
{ 0x04, 0x08, 0x10, 0x20, 0x40 },// 0x5C "\" {0x04, 0x08, 0x10, 0x20, 0x40}, // 0x5C "\"
{ 0x82, 0x82, 0xFE, 0x00, 0x00 },// 0x5D ] {0x82, 0x82, 0xFE, 0x00, 0x00}, // 0x5D ]
{ 0x08, 0x04, 0x02, 0x04, 0x08 },// 0x5E ^ {0x08, 0x04, 0x02, 0x04, 0x08}, // 0x5E ^
{ 0x80, 0x80, 0x80, 0x80, 0x80 },// 0x5F _ {0x80, 0x80, 0x80, 0x80, 0x80}, // 0x5F _
{ 0x00, 0x02, 0x04, 0x08, 0x00 },// 0x60 ` {0x00, 0x02, 0x04, 0x08, 0x00}, // 0x60 `
{ 0x40, 0xA8, 0xA8, 0xA8, 0xF0 },// 0x61 a {0x40, 0xA8, 0xA8, 0xA8, 0xF0}, // 0x61 a
{ 0xFE, 0x90, 0x88, 0x88, 0x70 },// 0x62 b {0xFE, 0x90, 0x88, 0x88, 0x70}, // 0x62 b
{ 0x70, 0x88, 0x88, 0x88, 0x40 },// 0x63 c {0x70, 0x88, 0x88, 0x88, 0x40}, // 0x63 c
{ 0x70, 0x88, 0x88, 0x90, 0xFE },// 0x64 d {0x70, 0x88, 0x88, 0x90, 0xFE}, // 0x64 d
{ 0x70, 0xA8, 0xA8, 0xA8, 0x30 },// 0x65 e {0x70, 0xA8, 0xA8, 0xA8, 0x30}, // 0x65 e
{ 0x10, 0xFC, 0x12, 0x02, 0x04 },// 0x66 f {0x10, 0xFC, 0x12, 0x02, 0x04}, // 0x66 f
{ 0x10, 0x28, 0xA8, 0xA8, 0x78 },// 0x67 g {0x10, 0x28, 0xA8, 0xA8, 0x78}, // 0x67 g
{ 0xFE, 0x10, 0x08, 0x08, 0xF0 },// 0x68 h {0xFE, 0x10, 0x08, 0x08, 0xF0}, // 0x68 h
{ 0x00, 0x88, 0xFA, 0x80, 0x00 },// 0x69 i {0x00, 0x88, 0xFA, 0x80, 0x00}, // 0x69 i
{ 0x40, 0x80, 0x88, 0x7A, 0x00 },// 0x6A j {0x40, 0x80, 0x88, 0x7A, 0x00}, // 0x6A j
{ 0x00, 0xFE, 0x20, 0x50, 0x88 },// 0x6B k {0x00, 0xFE, 0x20, 0x50, 0x88}, // 0x6B k
{ 0x00, 0x82, 0xFE, 0x80, 0x00 },// 0x6C l {0x00, 0x82, 0xFE, 0x80, 0x00}, // 0x6C l
{ 0xF8, 0x08, 0x30, 0x08, 0xF0 },// 0x6D m {0xF8, 0x08, 0x30, 0x08, 0xF0}, // 0x6D m
{ 0xF8, 0x10, 0x08, 0x08, 0xF0 },// 0x6E n {0xF8, 0x10, 0x08, 0x08, 0xF0}, // 0x6E n
{ 0x70, 0x88, 0x88, 0x88, 0x70 },// 0x6F o {0x70, 0x88, 0x88, 0x88, 0x70}, // 0x6F o
{ 0xF8, 0x28, 0x28, 0x28, 0x10 },// 0x70 p {0xF8, 0x28, 0x28, 0x28, 0x10}, // 0x70 p
{ 0x10, 0x28, 0x28, 0x30, 0xF8 },// 0x71 q {0x10, 0x28, 0x28, 0x30, 0xF8}, // 0x71 q
{ 0xF8, 0x10, 0x08, 0x08, 0x10 },// 0x72 r {0xF8, 0x10, 0x08, 0x08, 0x10}, // 0x72 r
{ 0x90, 0xA8, 0xA8, 0xA8, 0x40 },// 0x73 s {0x90, 0xA8, 0xA8, 0xA8, 0x40}, // 0x73 s
{ 0x08, 0x7E, 0x88, 0x80, 0x40 },// 0x74 t {0x08, 0x7E, 0x88, 0x80, 0x40}, // 0x74 t
{ 0x78, 0x80, 0x80, 0x40, 0xF8 },// 0x75 u {0x78, 0x80, 0x80, 0x40, 0xF8}, // 0x75 u
{ 0x38, 0x40, 0x80, 0x40, 0x38 },// 0x76 v {0x38, 0x40, 0x80, 0x40, 0x38}, // 0x76 v
{ 0x78, 0x80, 0x60, 0x80, 0x78 },// 0x77 w {0x78, 0x80, 0x60, 0x80, 0x78}, // 0x77 w
{ 0x88, 0x50, 0x20, 0x50, 0x88 },// 0x78 x {0x88, 0x50, 0x20, 0x50, 0x88}, // 0x78 x
{ 0x18, 0xA0, 0xA0, 0xA0, 0x78 },// 0x79 y {0x18, 0xA0, 0xA0, 0xA0, 0x78}, // 0x79 y
{ 0x88, 0xC8, 0xA8, 0x98, 0x88 },// 0x7A z {0x88, 0xC8, 0xA8, 0x98, 0x88}, // 0x7A z
{ 0x00, 0x10, 0x6C, 0x82, 0x00 },// 0x7B { {0x00, 0x10, 0x6C, 0x82, 0x00}, // 0x7B {
{ 0x00, 0x00, 0xFE, 0x00, 0x00 },// 0x7C | {0x00, 0x00, 0xFE, 0x00, 0x00}, // 0x7C |
{ 0x00, 0x82, 0x6C, 0x10, 0x00 },// 0x7D } {0x00, 0x82, 0x6C, 0x10, 0x00}, // 0x7D }
{ 0x20, 0x10, 0x10, 0x20, 0x10 },// 0x7E {0x20, 0x10, 0x10, 0x20, 0x10}, // 0x7E
{ 0xF0, 0x88, 0x84, 0x88, 0xF0 },// 0x7F  {0xF0, 0x88, 0x84, 0x88, 0xF0}, // 0x7F 
{ 0x28, 0x7C, 0xAA, 0x82, 0x44 },// 0x80 € {0x28, 0x7C, 0xAA, 0x82, 0x44}, // 0x80 €
{ 0xF0, 0x29, 0x27, 0x21, 0xFF },// 0x81  {0xF0, 0x29, 0x27, 0x21, 0xFF}, // 0x81 
{ 0x00, 0xA0, 0x60, 0x00, 0x00 },// 0x82 ‚ {0x00, 0xA0, 0x60, 0x00, 0x00}, // 0x82 ‚
{ 0x40, 0x90, 0x7C, 0x12, 0x04 },// 0x83 ƒ {0x40, 0x90, 0x7C, 0x12, 0x04}, // 0x83 ƒ
{ 0xC0, 0xA0, 0x00, 0xC0, 0xA0 },// 0x84 „ {0xC0, 0xA0, 0x00, 0xC0, 0xA0}, // 0x84 „
{ 0x80, 0x00, 0x80, 0x00, 0x80 },// 0x85 … {0x80, 0x00, 0x80, 0x00, 0x80}, // 0x85 …
{ 0x00, 0x04, 0xFE, 0x04, 0x00 },// 0x86 † {0x00, 0x04, 0xFE, 0x04, 0x00}, // 0x86 †
{ 0x00, 0x44, 0xFE, 0x44, 0x00 },// 0x87 ‡ {0x00, 0x44, 0xFE, 0x44, 0x00}, // 0x87 ‡
{ 0x00, 0x04, 0x02, 0x04, 0x00 },// 0x88 ˆ {0x00, 0x04, 0x02, 0x04, 0x00}, // 0x88 ˆ
{ 0xC3, 0xD3, 0x08, 0xC4, 0xC2 },// 0x89 ‰ {0xC3, 0xD3, 0x08, 0xC4, 0xC2}, // 0x89 ‰
{ 0x4C, 0x93, 0x92, 0x93, 0x64 },// 0x8A Š {0x4C, 0x93, 0x92, 0x93, 0x64}, // 0x8A Š
{ 0x00, 0x10, 0x28, 0x00, 0x00 },// 0x8B ‹ {0x00, 0x10, 0x28, 0x00, 0x00}, // 0x8B ‹
{ 0x7C, 0x82, 0x82, 0x7C, 0x92 },// 0x8C Œ {0x7C, 0x82, 0x82, 0x7C, 0x92}, // 0x8C Œ
{ 0x02, 0xFE, 0x90, 0x90, 0x60 },// 0x8D  {0x02, 0xFE, 0x90, 0x90, 0x60}, // 0x8D 
{ 0xC2, 0xA3, 0x92, 0x8B, 0x86 },// 0x8E Ž {0xC2, 0xA3, 0x92, 0x8B, 0x86}, // 0x8E Ž
{ 0x44, 0x92, 0x8A, 0x92, 0x7C },// 0x8F  {0x44, 0x92, 0x8A, 0x92, 0x7C}, // 0x8F 
{ 0x70, 0x88, 0x90, 0x60, 0x98 },// 0x90  {0x70, 0x88, 0x90, 0x60, 0x98}, // 0x90 
{ 0x00, 0x02, 0x04, 0x08, 0x00 },// 0x91 ‘ {0x00, 0x02, 0x04, 0x08, 0x00}, // 0x91 ‘
{ 0x00, 0x08, 0x04, 0x02, 0x00 },// 0x92 ’ {0x00, 0x08, 0x04, 0x02, 0x00}, // 0x92 ’
{ 0x02, 0x04, 0x0A, 0x04, 0x08 },// 0x93 “ {0x02, 0x04, 0x0A, 0x04, 0x08}, // 0x93 “
{ 0x08, 0x04, 0x0A, 0x04, 0x02 },// 0x94 ” {0x08, 0x04, 0x0A, 0x04, 0x02}, // 0x94 ”
{ 0x00, 0x38, 0x38, 0x38, 0x00 },// 0x95 • {0x00, 0x38, 0x38, 0x38, 0x00}, // 0x95 •
{ 0x00, 0x10, 0x10, 0x10, 0x10 },// 0x96 – {0x00, 0x10, 0x10, 0x10, 0x10}, // 0x96 –
{ 0x10, 0x10, 0x10, 0x10, 0x10 },// 0x97 — {0x10, 0x10, 0x10, 0x10, 0x10}, // 0x97 —
{ 0x02, 0x01, 0x02, 0x04, 0x02 },// 0x98 ˜ {0x02, 0x01, 0x02, 0x04, 0x02}, // 0x98 ˜
{ 0xF1, 0x5B, 0x55, 0x51, 0x51 },// 0x99 ™ {0xF1, 0x5B, 0x55, 0x51, 0x51}, // 0x99 ™
{ 0x90, 0xA9, 0xAA, 0xA9, 0x40 },// 0x9A š {0x90, 0xA9, 0xAA, 0xA9, 0x40}, // 0x9A š
{ 0x00, 0x88, 0x50, 0x20, 0x00 },// 0x9B › {0x00, 0x88, 0x50, 0x20, 0x00}, // 0x9B ›
{ 0x70, 0x88, 0x70, 0xA8, 0xB0 },// 0x9C ϡ {0x70, 0x88, 0x70, 0xA8, 0xB0}, // 0x9C ϡ
{ 0x38, 0x7C, 0xF8, 0x7C, 0x38 },// 0x9D  {0x38, 0x7C, 0xF8, 0x7C, 0x38}, // 0x9D 
{ 0x88, 0xC9, 0xAA, 0x99, 0x88 },// 0x9E ž {0x88, 0xC9, 0xAA, 0x99, 0x88}, // 0x9E ž
{ 0x1C, 0x21, 0xC0, 0x21, 0x1C },// 0x9F Ÿ {0x1C, 0x21, 0xC0, 0x21, 0x1C}, // 0x9F Ÿ
{ 0x00, 0x00, 0x00, 0x00, 0x00 },// 0xA0 {0x00, 0x00, 0x00, 0x00, 0x00}, // 0xA0
{ 0x00, 0x00, 0xF2, 0x00, 0x00 },// 0xA1 ¡ {0x00, 0x00, 0xF2, 0x00, 0x00}, // 0xA1 ¡
{ 0x38, 0x44, 0xFE, 0x44, 0x20 },// 0xA2 ¢ {0x38, 0x44, 0xFE, 0x44, 0x20}, // 0xA2 ¢
{ 0x90, 0x7C, 0x92, 0x82, 0x40 },// 0xA3 £ {0x90, 0x7C, 0x92, 0x82, 0x40}, // 0xA3 £
{ 0x44, 0x38, 0x28, 0x38, 0x44 },// 0xA4 ¤ {0x44, 0x38, 0x28, 0x38, 0x44}, // 0xA4 ¤
{ 0x2A, 0x2C, 0xF8, 0x2C, 0x2A },// 0xA5 ¥ {0x2A, 0x2C, 0xF8, 0x2C, 0x2A}, // 0xA5 ¥
{ 0x00, 0x00, 0xEE, 0x00, 0x00 },// 0xA6 ¦ {0x00, 0x00, 0xEE, 0x00, 0x00}, // 0xA6 ¦
{ 0x40, 0x94, 0xAA, 0x52, 0x04 },// 0xA7 § {0x40, 0x94, 0xAA, 0x52, 0x04}, // 0xA7 §
{ 0x00, 0x02, 0x00, 0x02, 0x00 },// 0xA8 ¨ {0x00, 0x02, 0x00, 0x02, 0x00}, // 0xA8 ¨
{ 0xFE, 0x82, 0xBA, 0x92, 0xFE },// 0xA9 © {0xFE, 0x82, 0xBA, 0x92, 0xFE}, // 0xA9 ©
{ 0x90, 0xAA, 0xAA, 0xAA, 0xBC },// 0xAA ª {0x90, 0xAA, 0xAA, 0xAA, 0xBC}, // 0xAA ª
{ 0x20, 0x50, 0xA8, 0x50, 0x88 },// 0xAB « {0x20, 0x50, 0xA8, 0x50, 0x88}, // 0xAB «
{ 0x20, 0x20, 0x20, 0x20, 0xE0 },// 0xAC ¬ {0x20, 0x20, 0x20, 0x20, 0xE0}, // 0xAC ¬
{ 0x20, 0x20, 0x20, 0x20, 0x20 },// 0xAD ­ {0x20, 0x20, 0x20, 0x20, 0x20}, // 0xAD ­
{ 0xFE, 0x82, 0xCA, 0xA2, 0xFE },// 0xAE ® {0xFE, 0x82, 0xCA, 0xA2, 0xFE}, // 0xAE ®
{ 0x02, 0x02, 0x02, 0x02, 0x02 },// 0xAF ¯ {0x02, 0x02, 0x02, 0x02, 0x02}, // 0xAF ¯
{ 0x0E, 0x11, 0x11, 0x0E, 0x00 },// 0xB0 ° {0x0E, 0x11, 0x11, 0x0E, 0x00}, // 0xB0 °
{ 0x88, 0x88, 0xBE, 0x88, 0x88 },// 0xB1 ± {0x88, 0x88, 0xBE, 0x88, 0x88}, // 0xB1 ±
{ 0x12, 0x19, 0x15, 0x12, 0x00 },// 0xB2 ² {0x12, 0x19, 0x15, 0x12, 0x00}, // 0xB2 ²
{ 0x11, 0x15, 0x15, 0x0A, 0x00 },// 0xB3 ³ {0x11, 0x15, 0x15, 0x0A, 0x00}, // 0xB3 ³
{ 0x00, 0x08, 0x04, 0x02, 0x00 },// 0xB4 ´ {0x00, 0x08, 0x04, 0x02, 0x00}, // 0xB4 ´
{ 0xFE, 0x20, 0x20, 0x10, 0x3E },// 0xB5 µ {0xFE, 0x20, 0x20, 0x10, 0x3E}, // 0xB5 µ
{ 0x0C, 0x12, 0x12, 0xFE, 0xFE },// 0xB6 ¶ {0x0C, 0x12, 0x12, 0xFE, 0xFE}, // 0xB6 ¶
{ 0x00, 0x30, 0x30, 0x00, 0x00 },// 0xB7 · {0x00, 0x30, 0x30, 0x00, 0x00}, // 0xB7 ·
{ 0x00, 0x80, 0xB0, 0x40, 0x00 },// 0xB8 ¸ {0x00, 0x80, 0xB0, 0x40, 0x00}, // 0xB8 ¸
{ 0x00, 0x02, 0x0F, 0x00, 0x00 },// 0xB9 ¹ {0x00, 0x02, 0x0F, 0x00, 0x00}, // 0xB9 ¹
{ 0x00, 0x02, 0x05, 0x02, 0x00 },// 0xBA º {0x00, 0x02, 0x05, 0x02, 0x00}, // 0xBA º
{ 0x44, 0x28, 0x54, 0x28, 0x10 },// 0xBB » {0x44, 0x28, 0x54, 0x28, 0x10}, // 0xBB »
{ 0x22, 0x1F, 0x68, 0x54, 0xFA },// 0xBC ¼ {0x22, 0x1F, 0x68, 0x54, 0xFA}, // 0xBC ¼
{ 0x02, 0x1F, 0x90, 0xC8, 0xB0 },// 0xBD ½ {0x02, 0x1F, 0x90, 0xC8, 0xB0}, // 0xBD ½
{ 0x15, 0x1F, 0x60, 0x50, 0xF8 },// 0xBE ¾ {0x15, 0x1F, 0x60, 0x50, 0xF8}, // 0xBE ¾
{ 0x60, 0x90, 0x8A, 0x80, 0x40 },// 0xBF ¿ {0x60, 0x90, 0x8A, 0x80, 0x40}, // 0xBF ¿
{ 0xF0, 0x29, 0x26, 0x28, 0xF0 },// 0xC0 À {0xF0, 0x29, 0x26, 0x28, 0xF0}, // 0xC0 À
{ 0xF0, 0x28, 0x26, 0x29, 0xF0 },// 0xC1 Á {0xF0, 0x28, 0x26, 0x29, 0xF0}, // 0xC1 Á
{ 0xF0, 0x2A, 0x29, 0x2A, 0xF0 },// 0xC2 Â {0xF0, 0x2A, 0x29, 0x2A, 0xF0}, // 0xC2 Â
{ 0xF2, 0x29, 0x29, 0x2A, 0xF1 },// 0xC3 Ã {0xF2, 0x29, 0x29, 0x2A, 0xF1}, // 0xC3 Ã
{ 0xF0, 0x29, 0x24, 0x29, 0xF0 },// 0xC4 Ä {0xF0, 0x29, 0x24, 0x29, 0xF0}, // 0xC4 Ä
{ 0xF0, 0x2A, 0x2D, 0x2A, 0xF0 },// 0xC5 Å {0xF0, 0x2A, 0x2D, 0x2A, 0xF0}, // 0xC5 Å
{ 0xF8, 0x24, 0xFE, 0x92, 0x92 },// 0xC6 Æ {0xF8, 0x24, 0xFE, 0x92, 0x92}, // 0xC6 Æ
{ 0x1E, 0x21, 0xA1, 0xE1, 0x12 },// 0xC7 Ç {0x1E, 0x21, 0xA1, 0xE1, 0x12}, // 0xC7 Ç
{ 0xF8, 0xA9, 0xAA, 0xA8, 0x88 },// 0xC8 È {0xF8, 0xA9, 0xAA, 0xA8, 0x88}, // 0xC8 È
{ 0xF8, 0xA8, 0xAA, 0xA9, 0x88 },// 0xC9 É {0xF8, 0xA8, 0xAA, 0xA9, 0x88}, // 0xC9 É
{ 0xF8, 0xAA, 0xA9, 0xAA, 0x88 },// 0xCA Ê {0xF8, 0xAA, 0xA9, 0xAA, 0x88}, // 0xCA Ê
{ 0xF8, 0xAA, 0xA8, 0xAA, 0x88 },// 0xCB Ë {0xF8, 0xAA, 0xA8, 0xAA, 0x88}, // 0xCB Ë
{ 0x00, 0x89, 0xFA, 0x88, 0x00 },// 0xCC Ì {0x00, 0x89, 0xFA, 0x88, 0x00}, // 0xCC Ì
{ 0x00, 0x88, 0xFA, 0x89, 0x00 },// 0xCD Í {0x00, 0x88, 0xFA, 0x89, 0x00}, // 0xCD Í
{ 0x00, 0x8A, 0xF9, 0x8A, 0x00 },// 0xCE Î {0x00, 0x8A, 0xF9, 0x8A, 0x00}, // 0xCE Î
{ 0x00, 0x8A, 0xF8, 0x8A, 0x00 },// 0xCF Ï {0x00, 0x8A, 0xF8, 0x8A, 0x00}, // 0xCF Ï
{ 0x10, 0xFE, 0x92, 0x82, 0x7C },// 0xD0 Ð {0x10, 0xFE, 0x92, 0x82, 0x7C}, // 0xD0 Ð
{ 0xFA, 0x11, 0x21, 0x42, 0xF9 },// 0xD1 Ñ {0xFA, 0x11, 0x21, 0x42, 0xF9}, // 0xD1 Ñ
{ 0x78, 0x85, 0x86, 0x84, 0x78 },// 0xD2 Ò {0x78, 0x85, 0x86, 0x84, 0x78}, // 0xD2 Ò
{ 0x78, 0x84, 0x86, 0x85, 0x78 },// 0xD3 Ó {0x78, 0x84, 0x86, 0x85, 0x78}, // 0xD3 Ó
{ 0x70, 0x8A, 0x89, 0x8A, 0x70 },// 0xD4 Ô {0x70, 0x8A, 0x89, 0x8A, 0x70}, // 0xD4 Ô
{ 0x72, 0x89, 0x89, 0x8A, 0x71 },// 0xD5 Õ {0x72, 0x89, 0x89, 0x8A, 0x71}, // 0xD5 Õ
{ 0x78, 0x85, 0x84, 0x85, 0x78 },// 0xD6 Ö {0x78, 0x85, 0x84, 0x85, 0x78}, // 0xD6 Ö
{ 0x44, 0x28, 0x10, 0x28, 0x44 },// 0xD7 × {0x44, 0x28, 0x10, 0x28, 0x44}, // 0xD7 ×
{ 0x10, 0xAA, 0xFE, 0xAA, 0x10 },// 0xD8 Ø {0x10, 0xAA, 0xFE, 0xAA, 0x10}, // 0xD8 Ø
{ 0x7C, 0x81, 0x82, 0x80, 0x7C },// 0xD9 Ù {0x7C, 0x81, 0x82, 0x80, 0x7C}, // 0xD9 Ù
{ 0x7C, 0x80, 0x82, 0x81, 0x7C },// 0xDA Ú {0x7C, 0x80, 0x82, 0x81, 0x7C}, // 0xDA Ú
{ 0x78, 0x82, 0x81, 0x82, 0x78 },// 0xDB Û {0x78, 0x82, 0x81, 0x82, 0x78}, // 0xDB Û
{ 0x7C, 0x81, 0x80, 0x81, 0x7C },// 0xDC Ü {0x7C, 0x81, 0x80, 0x81, 0x7C}, // 0xDC Ü
{ 0x04, 0x08, 0xF2, 0x09, 0x04 },// 0xDD Ý {0x04, 0x08, 0xF2, 0x09, 0x04}, // 0xDD Ý
{ 0x81, 0xFF, 0x24, 0x24, 0x18 },// 0xDE Þ {0x81, 0xFF, 0x24, 0x24, 0x18}, // 0xDE Þ
{ 0x80, 0x7C, 0x92, 0x92, 0x6C },// 0xDF ß {0x80, 0x7C, 0x92, 0x92, 0x6C}, // 0xDF ß
{ 0x40, 0xA9, 0xAA, 0xA8, 0xF0 },// 0xE0 à {0x40, 0xA9, 0xAA, 0xA8, 0xF0}, // 0xE0 à
{ 0x40, 0xA8, 0xAA, 0xA9, 0xF0 },// 0xE1 á {0x40, 0xA8, 0xAA, 0xA9, 0xF0}, // 0xE1 á
{ 0x40, 0xAA, 0xA9, 0xAA, 0xF0 },// 0xE2 â {0x40, 0xAA, 0xA9, 0xAA, 0xF0}, // 0xE2 â
{ 0x42, 0xA9, 0xA9, 0xAA, 0xF1 },// 0xE3 ã {0x42, 0xA9, 0xA9, 0xAA, 0xF1}, // 0xE3 ã
{ 0x40, 0xAA, 0xA8, 0xAA, 0xF0 },// 0xE4 ä {0x40, 0xAA, 0xA8, 0xAA, 0xF0}, // 0xE4 ä
{ 0x40, 0xAA, 0xAD, 0xAA, 0xF0 },// 0xE5 å {0x40, 0xAA, 0xAD, 0xAA, 0xF0}, // 0xE5 å
{ 0x64, 0x94, 0x78, 0x94, 0x58 },// 0xE6 æ {0x64, 0x94, 0x78, 0x94, 0x58}, // 0xE6 æ
{ 0x18, 0x24, 0xA4, 0xE4, 0x10 },// 0xE7 ç {0x18, 0x24, 0xA4, 0xE4, 0x10}, // 0xE7 ç
{ 0x70, 0xA9, 0xAA, 0xA8, 0x30 },// 0xE8 è {0x70, 0xA9, 0xAA, 0xA8, 0x30}, // 0xE8 è
{ 0x70, 0xA8, 0xAA, 0xA9, 0x30 },// 0xE9 é {0x70, 0xA8, 0xAA, 0xA9, 0x30}, // 0xE9 é
{ 0x70, 0xAA, 0xA9, 0xAA, 0x30 },// 0xEA ê {0x70, 0xAA, 0xA9, 0xAA, 0x30}, // 0xEA ê
{ 0x70, 0xAA, 0xA8, 0xAA, 0x30 },// 0xEB ë {0x70, 0xAA, 0xA8, 0xAA, 0x30}, // 0xEB ë
{ 0x00, 0x91, 0xFA, 0x80, 0x00 },// 0xEC ì {0x00, 0x91, 0xFA, 0x80, 0x00}, // 0xEC ì
{ 0x00, 0x90, 0xFA, 0x81, 0x00 },// 0xED í {0x00, 0x90, 0xFA, 0x81, 0x00}, // 0xED í
{ 0x00, 0x92, 0xF9, 0x82, 0x00 },// 0xEE î {0x00, 0x92, 0xF9, 0x82, 0x00}, // 0xEE î
{ 0x00, 0x92, 0xF8, 0x82, 0x00 },// 0xEF ï {0x00, 0x92, 0xF8, 0x82, 0x00}, // 0xEF ï
{ 0x4A, 0xA4, 0xAA, 0xB0, 0x60 },// 0xF0 ð {0x4A, 0xA4, 0xAA, 0xB0, 0x60}, // 0xF0 ð
{ 0xFA, 0x11, 0x09, 0x0A, 0xF1 },// 0xF1 ñ {0xFA, 0x11, 0x09, 0x0A, 0xF1}, // 0xF1 ñ
{ 0x70, 0x89, 0x8A, 0x88, 0x70 },// 0xF2 ò {0x70, 0x89, 0x8A, 0x88, 0x70}, // 0xF2 ò
{ 0x70, 0x88, 0x8A, 0x89, 0x70 },// 0xF3 ó {0x70, 0x88, 0x8A, 0x89, 0x70}, // 0xF3 ó
{ 0x60, 0x94, 0x92, 0x94, 0x60 },// 0xF4 ô {0x60, 0x94, 0x92, 0x94, 0x60}, // 0xF4 ô
{ 0x64, 0x92, 0x92, 0x94, 0x62 },// 0xF5 õ {0x64, 0x92, 0x92, 0x94, 0x62}, // 0xF5 õ
{ 0x70, 0x8A, 0x88, 0x8A, 0x70 },// 0xF6 ö {0x70, 0x8A, 0x88, 0x8A, 0x70}, // 0xF6 ö
{ 0x10, 0x10, 0x54, 0x10, 0x10 },// 0xF7 ÷ {0x10, 0x10, 0x54, 0x10, 0x10}, // 0xF7 ÷
{ 0x10, 0xA8, 0x7C, 0x2A, 0x10 },// 0xF8 ø {0x10, 0xA8, 0x7C, 0x2A, 0x10}, // 0xF8 ø
{ 0x78, 0x81, 0x82, 0x40, 0xF8 },// 0xF9 ù {0x78, 0x81, 0x82, 0x40, 0xF8}, // 0xF9 ù
{ 0x78, 0x80, 0x82, 0x41, 0xF8 },// 0xFA ú {0x78, 0x80, 0x82, 0x41, 0xF8}, // 0xFA ú
{ 0x78, 0x82, 0x81, 0x42, 0xF8 },// 0xFB û {0x78, 0x82, 0x81, 0x42, 0xF8}, // 0xFB û
{ 0x78, 0x82, 0x80, 0x42, 0xF8 },// 0xFC ü {0x78, 0x82, 0x80, 0x42, 0xF8}, // 0xFC ü
{ 0x18, 0xA0, 0xA4, 0xA2, 0x78 },// 0xFD v {0x18, 0xA0, 0xA4, 0xA2, 0x78}, // 0xFD v
{ 0x00, 0x82, 0xFE, 0xA8, 0x10 },// 0xFE þ {0x00, 0x82, 0xFE, 0xA8, 0x10}, // 0xFE þ
{ 0x18, 0xA2, 0xA0, 0xA2, 0x78 } // 0xFF ÿ {0x18, 0xA2, 0xA0, 0xA2, 0x78} // 0xFF ÿ
}; };
G13_Font::G13_Font() : _name("default"), _width(8) {}
G13_Font::G13_Font() : _name("default"), _width(8) G13_Font::G13_Font(const std::string &name, unsigned int width)
{} : _name(name), _width(width) {}
G13_Font::G13_Font( const std::string &name, unsigned int width ) :_name(name), _width(width) void G13_FontChar::set_character(unsigned char *data, int width,
{ unsigned flags) {
unsigned char *dest = bits_regular;
memset(dest, 0, CHAR_BUF_SIZE);
if (flags && FF_ROTATE) {
for (int x = 0; x < width; x++) {
unsigned char x_mask = 1 << x;
for (int y = 0; y < 8; y++) {
unsigned char y_mask = 1 << y;
if (data[y] & x_mask) {
dest[x] |= 1 << y;
}
}
}
} else {
memcpy(dest, data, width);
}
for (int x = 0; x < width; x++) {
bits_inverted[x] = ~dest[x];
}
} }
template <typename T, int size> int GetFontCharacterCount(T (&)[size]) {
void G13_FontChar::set_character( unsigned char *data, int width, unsigned flags ) { return size;
unsigned char *dest = bits_regular;
memset( dest, 0, CHAR_BUF_SIZE );
if( flags && FF_ROTATE ) {
for( int x = 0; x < width; x++ ) {
unsigned char x_mask = 1 << x;
for( int y = 0; y < 8; y++ ) {
unsigned char y_mask = 1 << y;
if( data[y] & x_mask ) {
dest[x] |= 1 << y;
}
}
}
} else {
memcpy( dest, data, width );
}
for( int x = 0; x < width; x++ ) {
bits_inverted[x] = ~dest[x];
}
} }
template <class ARRAY_T, class FLAGST>
template <typename T, int size> void G13_Font::install_font(ARRAY_T &data, FLAGST flags, int first) {
int GetFontCharacterCount( T(&)[size] ) { return size; } for (size_t i = 0; i < GetFontCharacterCount(data); i++) {
_chars[i + first].set_character(&data[i][0], _width, flags);
template < class ARRAY_T, class FLAGST > }
void G13_Font::install_font( ARRAY_T &data, FLAGST flags, int first ) {
for( size_t i = 0; i < GetFontCharacterCount(data); i++ ) {
_chars[i+first].set_character( &data[i][0], _width, flags );
}
} }
void G13_Device::_init_fonts() { void G13_Device::_init_fonts() {
_current_font = FontPtr( new G13_Font("8x8",8) ); _current_font = FontPtr(new G13_Font("8x8", 8));
_fonts[_current_font->name()] = _current_font; _fonts[_current_font->name()] = _current_font;
_current_font->install_font( font8x8_basic, G13_FontChar::FF_ROTATE, 0 ); _current_font->install_font(font8x8_basic, G13_FontChar::FF_ROTATE, 0);
FontPtr fiveXeight( new G13_Font("5x8",5) ); FontPtr fiveXeight(new G13_Font("5x8", 5));
fiveXeight->install_font( font5x8, 0, 32 ); fiveXeight->install_font(font5x8, 0, 32);
_fonts[fiveXeight->name()] = fiveXeight; _fonts[fiveXeight->name()] = fiveXeight;
} }
} // namespace G13 } // namespace G13

260
g13d/g13_keys.cc
View File

@ -13,20 +13,19 @@ namespace G13 {
* format. Do NOT remove or insert items in this list. * format. Do NOT remove or insert items in this list.
*/ */
#define G13_KEY_SEQ \ #define G13_KEY_SEQ \
/* byte 3 */ (G1)(G2)(G3)(G4)(G5)(G6)(G7)(G8) \ /* byte 3 */ (G1)(G2)(G3)(G4)(G5)(G6)(G7)(G8) /* byte 4 */ \
/* byte 4 */ (G9)(G10)(G11)(G12)(G13)(G14)(G15)(G16) \ (G9)(G10)(G11)(G12)(G13)(G14)(G15)(G16) /* byte 5 */ (G17)(G18)(G19)( \
/* byte 5 */ (G17)(G18)(G19)(G20)(G21)(G22)(UNDEF1)(LIGHT_STATE) \ G20)(G21)(G22)(UNDEF1)(LIGHT_STATE) /* byte 6 */ \
/* byte 6 */ (BD)(L1)(L2)(L3)(L4)(M1)(M2)(M3) \ (BD)(L1)(L2)(L3)(L4)(M1)(M2)(M3) /* byte 7 */ (MR)(LEFT)(DOWN)(TOP)( \
/* byte 7 */ (MR)(LEFT)(DOWN)(TOP)(UNDEF3)(LIGHT)(LIGHT2)(MISC_TOGGLE) \ UNDEF3)(LIGHT)(LIGHT2)(MISC_TOGGLE)
/*! G13_NONPARSED_KEY_SEQ is a Boost Preprocessor sequence containing the /*! G13_NONPARSED_KEY_SEQ is a Boost Preprocessor sequence containing the
* G13 keys that shouldn't be tested input. These aren't actually keys, * G13 keys that shouldn't be tested input. These aren't actually keys,
* but they are in the bitmap defined by G13_KEY_SEQ. * but they are in the bitmap defined by G13_KEY_SEQ.
*/ */
#define G13_NONPARSED_KEY_SEQ \ #define G13_NONPARSED_KEY_SEQ \
(UNDEF1)(LIGHT_STATE)(UNDEF3)(LIGHT)(LIGHT2)(UNDEF3)(MISC_TOGGLE) \ (UNDEF1)(LIGHT_STATE)(UNDEF3)(LIGHT)(LIGHT2)(UNDEF3)(MISC_TOGGLE)
/*! KB_INPUT_KEY_SEQ is a Boost Preprocessor sequence containing the /*! KB_INPUT_KEY_SEQ is a Boost Preprocessor sequence containing the
* names of keyboard keys we can send through binding actions. * names of keyboard keys we can send through binding actions.
@ -34,186 +33,169 @@ namespace G13 {
* i.e. ESC is KEY_ESC, 1 is KEY_1, etc. * i.e. ESC is KEY_ESC, 1 is KEY_1, etc.
*/ */
#define KB_INPUT_KEY_SEQ \ #define KB_INPUT_KEY_SEQ \
(ESC)(1)(2)(3)(4)(5)(6)(7)(8)(9)(0) \ (ESC)(1)(2)(3)(4)(5)(6)(7)(8)(9)(0)(MINUS)(EQUAL)(BACKSPACE)(TAB)(Q)(W)(E)( \
(MINUS)(EQUAL)(BACKSPACE)(TAB) \ R)(T)(Y)(U)(I)(O)(P)(LEFTBRACE)(RIGHTBRACE)(ENTER)(LEFTCTRL)(RIGHTCTRL)( \
(Q)(W)(E)(R)(T)(Y)(U)(I)(O)(P) \ A)(S)(D)(F)(G)(H)(J)(K)(L)(SEMICOLON)(APOSTROPHE)(GRAVE)(LEFTSHIFT)( \
(LEFTBRACE)(RIGHTBRACE)(ENTER)(LEFTCTRL)(RIGHTCTRL) \ BACKSLASH)(Z)(X)(C)(V)(B)(N)(M)(COMMA)(DOT)(SLASH)(RIGHTSHIFT)( \
(A)(S)(D)(F)(G)(H)(J)(K)(L) \ KPASTERISK)(LEFTALT)(RIGHTALT)(SPACE)(CAPSLOCK)(F1)(F2)(F3)(F4)(F5)(F6)( \
(SEMICOLON)(APOSTROPHE)(GRAVE)(LEFTSHIFT)(BACKSLASH) \ F7)(F8)(F9)(F10)(F11)(F12)(NUMLOCK)(SCROLLLOCK)(KP7)(KP8)(KP9)(KPMINUS)( \
(Z)(X)(C)(V)(B)(N)(M) \ KP4)(KP5)(KP6)(KPPLUS)(KP1)(KP2)(KP3)(KP0)(KPDOT)(LEFT)(RIGHT)(UP)( \
(COMMA)(DOT)(SLASH)(RIGHTSHIFT)(KPASTERISK) \ DOWN)(PAGEUP)(PAGEDOWN)(HOME)(END)(INSERT)(DELETE)
(LEFTALT)(RIGHTALT)(SPACE)(CAPSLOCK) \
(F1)(F2)(F3)(F4)(F5)(F6)(F7)(F8)(F9)(F10)(F11)(F12) \
(NUMLOCK)(SCROLLLOCK) \
(KP7)(KP8)(KP9)(KPMINUS)(KP4)(KP5)(KP6)(KPPLUS) \
(KP1)(KP2)(KP3)(KP0)(KPDOT) \
(LEFT)(RIGHT)(UP)(DOWN) \
(PAGEUP)(PAGEDOWN)(HOME)(END)(INSERT)(DELETE) \
// ************************************************************************* // *************************************************************************
void G13_Profile::_init_keys() { void G13_Profile::_init_keys() {
int key_index = 0; int key_index = 0;
// create a G13_Key entry for every key in G13_KEY_SEQ // create a G13_Key entry for every key in G13_KEY_SEQ
#define INIT_KEY( r, data, elem ) \ #define INIT_KEY(r, data, elem) \
{ \ { \
G13_Key key( *this, BOOST_PP_STRINGIZE(elem), key_index++ ); \ G13_Key key(*this, BOOST_PP_STRINGIZE(elem), key_index++); \
_keys.push_back( key ); \ _keys.push_back(key); \
} \ }
BOOST_PP_SEQ_FOR_EACH(INIT_KEY, _, G13_KEY_SEQ) BOOST_PP_SEQ_FOR_EACH(INIT_KEY, _, G13_KEY_SEQ)
assert(_keys.size() == G13_NUM_KEYS); assert(_keys.size() == G13_NUM_KEYS);
// now disable testing for keys in G13_NONPARSED_KEY_SEQ // now disable testing for keys in G13_NONPARSED_KEY_SEQ
#define MARK_NON_PARSED_KEY( r, data, elem ) \ #define MARK_NON_PARSED_KEY(r, data, elem) \
{ \ { \
G13_Key *key = find_key( BOOST_PP_STRINGIZE(elem) ); \ G13_Key *key = find_key(BOOST_PP_STRINGIZE(elem)); \
assert(key); \ assert(key); \
key->_should_parse = false; \ key->_should_parse = false; \
} \ }
BOOST_PP_SEQ_FOR_EACH(MARK_NON_PARSED_KEY, _, G13_NONPARSED_KEY_SEQ) BOOST_PP_SEQ_FOR_EACH(MARK_NON_PARSED_KEY, _, G13_NONPARSED_KEY_SEQ)
} }
// ************************************************************************* // *************************************************************************
void G13_Key::dump( std::ostream &o ) const { void G13_Key::dump(std::ostream &o) const {
o << manager().find_g13_key_name(index()) << "(" << index() << ") : "; o << manager().find_g13_key_name(index()) << "(" << index() << ") : ";
if( action() ) { if (action()) {
action()->dump(o); action()->dump(o);
} else { } else {
o << "(no action)"; o << "(no action)";
} }
} }
void G13_Profile::dump( std::ostream &o ) const { void G13_Profile::dump(std::ostream &o) const {
o << "Profile " << repr( name() ) << std::endl; o << "Profile " << repr(name()) << std::endl;
BOOST_FOREACH( const G13_Key &key, _keys ) { BOOST_FOREACH (const G13_Key &key, _keys) {
if( key.action() ) { if (key.action()) {
o << " "; o << " ";
key.dump(o); key.dump(o);
o << std::endl; o << std::endl;
} }
} }
} }
void G13_Profile::parse_keys(unsigned char *buf) { void G13_Profile::parse_keys(unsigned char *buf) {
buf += 3; buf += 3;
for (size_t i = 0; i < _keys.size(); i++) { for (size_t i = 0; i < _keys.size(); i++) {
if ( _keys[i]._should_parse ) { if (_keys[i]._should_parse) {
_keys[i].parse_key(buf, &_keypad); _keys[i].parse_key(buf, &_keypad);
} }
} }
} }
G13_Key * G13_Profile::find_key(const std::string &keyname) { G13_Key *G13_Profile::find_key(const std::string &keyname) {
auto key = _keypad.manager().find_g13_key_value(keyname); auto key = _keypad.manager().find_g13_key_value(keyname);
if (key >= 0 && key < _keys.size()) { if (key >= 0 && key < _keys.size()) {
return &_keys[key]; return &_keys[key];
} }
return 0; return 0;
} }
// ************************************************************************* // *************************************************************************
void G13_Key::parse_key(unsigned char *byte, G13_Device *g13) { void G13_Key::parse_key(unsigned char *byte, G13_Device *g13) {
bool key_is_down = byte[_index.offset] & _index.mask; bool key_is_down = byte[_index.offset] & _index.mask;
bool key_state_changed = g13->update(_index.index, key_is_down); bool key_state_changed = g13->update(_index.index, key_is_down);
if (key_state_changed && _action) { if (key_state_changed && _action) {
_action->act(*g13, key_is_down); _action->act(*g13, key_is_down);
} }
} }
// ************************************************************************* // *************************************************************************
void G13_Manager::init_keynames() { void G13_Manager::init_keynames() {
int key_index = 0; int key_index = 0;
// setup maps to let us convert between strings and G13 key names // setup maps to let us convert between strings and G13 key names
#define ADD_G13_KEY_MAPPING( r, data, elem ) \ #define ADD_G13_KEY_MAPPING(r, data, elem) \
{ \ { \
std::string name = BOOST_PP_STRINGIZE(elem); \ std::string name = BOOST_PP_STRINGIZE(elem); \
g13_key_to_name[key_index] = name; \ g13_key_to_name[key_index] = name; \
g13_name_to_key[name] = key_index; \ g13_name_to_key[name] = key_index; \
key_index++; \ key_index++; \
} \ }
BOOST_PP_SEQ_FOR_EACH(ADD_G13_KEY_MAPPING, _, G13_KEY_SEQ) BOOST_PP_SEQ_FOR_EACH(ADD_G13_KEY_MAPPING, _, G13_KEY_SEQ)
// setup maps to let us convert between strings and linux key names // setup maps to let us convert between strings and linux key names
#define ADD_KB_KEY_MAPPING( r, data, elem ) \ #define ADD_KB_KEY_MAPPING(r, data, elem) \
{ \ { \
std::string name = BOOST_PP_STRINGIZE(elem); \ std::string name = BOOST_PP_STRINGIZE(elem); \
int keyval = BOOST_PP_CAT( KEY_, elem ); \ int keyval = BOOST_PP_CAT(KEY_, elem); \
input_key_to_name[keyval] = name; \ input_key_to_name[keyval] = name; \
input_name_to_key[name] = keyval; \ input_name_to_key[name] = keyval; \
} \ }
BOOST_PP_SEQ_FOR_EACH(ADD_KB_KEY_MAPPING, _, KB_INPUT_KEY_SEQ)
BOOST_PP_SEQ_FOR_EACH(ADD_KB_KEY_MAPPING, _, KB_INPUT_KEY_SEQ)
} }
LINUX_KEY_VALUE G13_Manager::find_g13_key_value( const std::string &keyname ) const { LINUX_KEY_VALUE
auto i = g13_name_to_key.find(keyname); G13_Manager::find_g13_key_value(const std::string &keyname) const {
if( i == g13_name_to_key.end() ) { auto i = g13_name_to_key.find(keyname);
return BAD_KEY_VALUE; if (i == g13_name_to_key.end()) {
} return BAD_KEY_VALUE;
return i->second; }
return i->second;
} }
LINUX_KEY_VALUE
G13_Manager::find_input_key_value(const std::string &keyname) const {
LINUX_KEY_VALUE G13_Manager::find_input_key_value( const std::string &keyname ) const { // if there is a KEY_ prefix, strip it off
if (!strncmp(keyname.c_str(), "KEY_", 4)) {
return find_input_key_value(keyname.c_str() + 4);
}
// if there is a KEY_ prefix, strip it off auto i = input_name_to_key.find(keyname);
if(!strncmp( keyname.c_str(), "KEY_", 4) ) { if (i == input_name_to_key.end()) {
return find_input_key_value( keyname.c_str() + 4 ); return BAD_KEY_VALUE;
} }
return i->second;
auto i = input_name_to_key.find(keyname);
if( i == input_name_to_key.end() ) {
return BAD_KEY_VALUE;
}
return i->second;
} }
std::string G13_Manager::find_input_key_name( LINUX_KEY_VALUE v ) const { std::string G13_Manager::find_input_key_name(LINUX_KEY_VALUE v) const {
try { try {
return find_or_throw( input_key_to_name, v ); return find_or_throw(input_key_to_name, v);
} } catch (...) {
catch(...) { return "(unknown linux key)";
return "(unknown linux key)"; }
}
} }
std::string G13_Manager::find_g13_key_name( G13_KEY_INDEX v ) const { std::string G13_Manager::find_g13_key_name(G13_KEY_INDEX v) const {
try { try {
return find_or_throw( g13_key_to_name, v ); return find_or_throw(g13_key_to_name, v);
} } catch (...) {
catch(...) { return "(unknown G13 key)";
return "(unknown G13 key)"; }
}
} }
void G13_Manager::display_keys() { void G13_Manager::display_keys() {
typedef std::map<std::string, int> mapType; typedef std::map<std::string, int> mapType;
G13_OUT( "Known keys on G13:" ); G13_OUT("Known keys on G13:");
G13_OUT( Helper::map_keys_out( g13_name_to_key ) ); G13_OUT(Helper::map_keys_out(g13_name_to_key));
G13_OUT( "Known keys to map to:" );
G13_OUT( Helper::map_keys_out( input_name_to_key) );
G13_OUT("Known keys to map to:");
G13_OUT(Helper::map_keys_out(input_name_to_key));
} }
} // namespace G13 } // namespace G13

256
g13d/g13_lcd.cc
View File

@ -1,20 +1,21 @@
/* /*
pixels are mapped rather strangely for G13 buffer... pixels are mapped rather strangely for G13 buffer...
byte 0 contains column 0 / row 0 - 7 byte 0 contains column 0 / row 0 - 7
byte 1 contains column 1 / row 0 - 7 byte 1 contains column 1 / row 0 - 7
so the masks for each pixel are laid out as below (ByteOffset.PixelMask) so the masks for each pixel are laid out as below
(ByteOffset.PixelMask)
00.01 01.01 02.01 ... 00.01 01.01 02.01 ...
00.02 01.02 02.02 ... 00.02 01.02 02.02 ...
00.04 01.04 02.04 ... 00.04 01.04 02.04 ...
00.08 01.08 02.08 ... 00.08 01.08 02.08 ...
00.10 01.10 02.10 ... 00.10 01.10 02.10 ...
00.20 01.20 02.20 ... 00.20 01.20 02.20 ...
00.40 01.40 02.40 ... 00.40 01.40 02.40 ...
00.80 01.80 02.80 ... 00.80 01.80 02.80 ...
A0.01 A1.01 A2.01 ... A0.01 A1.01 A2.01 ...
*/ */
#include "g13.h" #include "g13.h"
@ -26,15 +27,16 @@ namespace G13 {
void G13_Device::init_lcd() { void G13_Device::init_lcd() {
int error = libusb_control_transfer(handle, 0, 9, 1, 0, 0, 0, 1000); int error = libusb_control_transfer(handle, 0, 9, 1, 0, 0, 0, 1000);
if(error) { if (error) {
G13_LOG( error, "Error when initializing lcd endpoint" ); G13_LOG(error, "Error when initializing lcd endpoint");
} }
} }
void G13_Device::write_lcd( unsigned char *data, size_t size ) { void G13_Device::write_lcd(unsigned char *data, size_t size) {
init_lcd(); init_lcd();
if(size != G13_LCD_BUFFER_SIZE) { if (size != G13_LCD_BUFFER_SIZE) {
G13_LOG( error, "Invalid LCD data size " << size << ", should be " << G13_LCD_BUFFER_SIZE ); G13_LOG(error, "Invalid LCD data size " << size << ", should be "
<< G13_LCD_BUFFER_SIZE);
return; return;
} }
unsigned char buffer[G13_LCD_BUFFER_SIZE + 32]; unsigned char buffer[G13_LCD_BUFFER_SIZE + 32];
@ -42,12 +44,15 @@ void G13_Device::write_lcd( unsigned char *data, size_t size ) {
buffer[0] = 0x03; buffer[0] = 0x03;
memcpy(buffer + 32, data, G13_LCD_BUFFER_SIZE); memcpy(buffer + 32, data, G13_LCD_BUFFER_SIZE);
int bytes_written; int bytes_written;
int error = libusb_interrupt_transfer(handle, LIBUSB_ENDPOINT_OUT | G13_LCD_ENDPOINT, buffer, G13_LCD_BUFFER_SIZE + 32, &bytes_written, 1000); int error = libusb_interrupt_transfer(
if(error) handle, LIBUSB_ENDPOINT_OUT | G13_LCD_ENDPOINT, buffer,
G13_LOG( error, "Error when transferring image: " << error << ", " << bytes_written << " bytes written" ); G13_LCD_BUFFER_SIZE + 32, &bytes_written, 1000);
if (error)
G13_LOG(error, "Error when transferring image: "
<< error << ", " << bytes_written << " bytes written");
} }
void G13_Device::write_lcd_file( const string &filename ) { void G13_Device::write_lcd_file(const string &filename) {
filebuf *pbuf; filebuf *pbuf;
ifstream filestr; ifstream filestr;
size_t size; size_t size;
@ -63,132 +68,137 @@ void G13_Device::write_lcd_file( const string &filename ) {
pbuf->sgetn(buffer, size); pbuf->sgetn(buffer, size);
filestr.close(); filestr.close();
write_lcd( (unsigned char *)buffer, size ); write_lcd((unsigned char *)buffer, size);
} }
void G13_LCD::image(unsigned char *data, int size) { void G13_LCD::image(unsigned char *data, int size) {
_keypad.write_lcd( data, size ); _keypad.write_lcd(data, size);
} }
G13_LCD::G13_LCD( G13_Device &keypad ) : _keypad(keypad) { G13_LCD::G13_LCD(G13_Device &keypad) : _keypad(keypad) {
cursor_col = 0; cursor_col = 0;
cursor_row = 0; cursor_row = 0;
text_mode = 0; text_mode = 0;
} }
void G13_LCD::image_setpixel(unsigned row, unsigned col) { void G13_LCD::image_setpixel(unsigned row, unsigned col) {
unsigned offset = image_byte_offset(row, col); // col + (row /8 ) * BYTES_PER_ROW * 8; unsigned offset =
unsigned char mask = 1 << ((row) & 7); image_byte_offset(row, col); // col + (row /8 ) * BYTES_PER_ROW * 8;
unsigned char mask = 1 << ((row)&7);
if (offset >= G13_LCD_BUF_SIZE) { if (offset >= G13_LCD_BUF_SIZE) {
G13_LOG( error, "bad offset " << offset << " for " << (row) << " x " << (col) ); G13_LOG(error,
return; "bad offset " << offset << " for " << (row) << " x " << (col));
} return;
}
image_buf[offset] |= mask; image_buf[offset] |= mask;
} }
void G13_LCD::image_clearpixel(unsigned row, unsigned col) { void G13_LCD::image_clearpixel(unsigned row, unsigned col) {
unsigned offset = image_byte_offset(row, col); // col + (row /8 ) * BYTES_PER_ROW * 8; unsigned offset =
unsigned char mask = 1 << ((row) & 7); image_byte_offset(row, col); // col + (row /8 ) * BYTES_PER_ROW * 8;
unsigned char mask = 1 << ((row)&7);
if (offset >= G13_LCD_BUF_SIZE) { if (offset >= G13_LCD_BUF_SIZE) {
G13_LOG( error, "bad offset " << offset << " for " << (row) << " x " << (col) ); G13_LOG(error,
return; "bad offset " << offset << " for " << (row) << " x " << (col));
} return;
image_buf[offset] &= ~mask; }
image_buf[offset] &= ~mask;
} }
void G13_LCD::write_pos(int row, int col) {
void G13_LCD::write_pos(int row, int col ) { cursor_row = row;
cursor_row = row; cursor_col = col;
cursor_col = col; if (cursor_col >= G13_LCD_COLUMNS) {
if( cursor_col >= G13_LCD_COLUMNS ) { cursor_col = 0;
cursor_col = 0; }
} if (cursor_row >= G13_LCD_TEXT_ROWS) {
if( cursor_row >= G13_LCD_TEXT_ROWS ) { cursor_row = 0;
cursor_row = 0; }
}
} }
void G13_LCD::write_char( char c, int row, int col ) { void G13_LCD::write_char(char c, int row, int col) {
if( row == -1 ) { if (row == -1) {
row = cursor_row; row = cursor_row;
col = cursor_col; col = cursor_col;
cursor_col += _keypad.current_font().width(); cursor_col += _keypad.current_font().width();
if( cursor_col >= G13_LCD_COLUMNS ) { if (cursor_col >= G13_LCD_COLUMNS) {
cursor_col = 0; cursor_col = 0;
if( ++cursor_row >= G13_LCD_TEXT_ROWS ) { if (++cursor_row >= G13_LCD_TEXT_ROWS) {
cursor_row = 0; cursor_row = 0;
} }
} }
} }
unsigned offset = image_byte_offset( row*G13_LCD_TEXT_CHEIGHT, col ); //*_keypad._current_font->_width ); unsigned offset = image_byte_offset(row * G13_LCD_TEXT_CHEIGHT,
if( text_mode ) { col); //*_keypad._current_font->_width );
memcpy( & image_buf[offset], &_keypad.current_font().char_data(c).bits_inverted, _keypad.current_font().width() ); if (text_mode) {
} else { memcpy(&image_buf[offset],
memcpy( & image_buf[offset], &_keypad.current_font().char_data(c).bits_regular, _keypad.current_font().width() ); &_keypad.current_font().char_data(c).bits_inverted,
} _keypad.current_font().width());
} else {
memcpy(&image_buf[offset],
&_keypad.current_font().char_data(c).bits_regular,
_keypad.current_font().width());
}
} }
void G13_LCD::write_string( const char *str ) { void G13_LCD::write_string(const char *str) {
G13_LOG( info, "writing \"" << str << "\"" ); G13_LOG(info, "writing \"" << str << "\"");
while( *str ) { while (*str) {
if( *str == '\n' ) { if (*str == '\n') {
cursor_col = 0; cursor_col = 0;
if( ++cursor_row >= G13_LCD_TEXT_ROWS ) { if (++cursor_row >= G13_LCD_TEXT_ROWS) {
cursor_row = 0; cursor_row = 0;
} }
} else if( *str == '\t' ) { } else if (*str == '\t') {
cursor_col += 4 - (cursor_col % 4) ; cursor_col += 4 - (cursor_col % 4);
if( ++cursor_col >= G13_LCD_COLUMNS ) { if (++cursor_col >= G13_LCD_COLUMNS) {
cursor_col = 0; cursor_col = 0;
if( ++cursor_row >= G13_LCD_TEXT_ROWS ) { if (++cursor_row >= G13_LCD_TEXT_ROWS) {
cursor_row = 0; cursor_row = 0;
} }
} }
} else { } else {
write_char(*str); write_char(*str);
} }
++str; ++str;
} }
image_send(); image_send();
} }
void G13_LCD::image_test( int x, int y ) { void G13_LCD::image_test(int x, int y) {
int row = 0, col = 0; int row = 0, col = 0;
if( y >= 0 ) { if (y >= 0) {
image_setpixel( x, y ); image_setpixel(x, y);
} else { } else {
image_clear(); image_clear();
switch( x ) { switch (x) {
case 1: case 1:
for( row = 0; row < G13_LCD_ROWS; ++row ) { for (row = 0; row < G13_LCD_ROWS; ++row) {
col = row; col = row;
image_setpixel( row, col ); image_setpixel(row, col);
image_setpixel( row, G13_LCD_COLUMNS-col ); image_setpixel(row, G13_LCD_COLUMNS - col);
} }
break; break;
case 2: case 2:
default: default:
for( row = 0; row < G13_LCD_ROWS; ++row ) { for (row = 0; row < G13_LCD_ROWS; ++row) {
col = row; col = row;
image_setpixel( row, 8 ); image_setpixel(row, 8);
image_setpixel( row, G13_LCD_COLUMNS - 8 ); image_setpixel(row, G13_LCD_COLUMNS - 8);
image_setpixel( row, G13_LCD_COLUMNS / 2 ); image_setpixel(row, G13_LCD_COLUMNS / 2);
image_setpixel( row, col ); image_setpixel(row, col);
image_setpixel( row, G13_LCD_COLUMNS-col ); image_setpixel(row, G13_LCD_COLUMNS - col);
} }
break; break;
}
} }
} image_send();
image_send();
} }
} // namespace G13 } // namespace G13

48
g13d/g13_log.cc
View File

@ -1,48 +1,42 @@
#include "g13.h" #include "g13.h"
#include <fstream> #include <fstream>
#include <boost/log/attributes.hpp>
#include <boost/log/core/core.hpp>
#include <boost/log/expressions.hpp>
#include <boost/log/expressions/formatters/stream.hpp>
#include <boost/log/sources/severity_feature.hpp> #include <boost/log/sources/severity_feature.hpp>
#include <boost/log/sources/severity_logger.hpp> #include <boost/log/sources/severity_logger.hpp>
#include <boost/log/core/core.hpp> #include <boost/log/support/date_time.hpp>
#include <boost/log/attributes.hpp>
#include <boost/log/trivial.hpp> #include <boost/log/trivial.hpp>
#include <boost/log/expressions.hpp>
#include <boost/log/utility/setup.hpp> #include <boost/log/utility/setup.hpp>
#include <boost/log/utility/setup/console.hpp> #include <boost/log/utility/setup/console.hpp>
#include <boost/log/expressions/formatters/stream.hpp>
#include <boost/log/support/date_time.hpp>
using namespace std; using namespace std;
namespace G13 { namespace G13 {
void G13_Manager::set_log_level(::boost::log::trivial::severity_level lvl) {
void G13_Manager::set_log_level( ::boost::log::trivial::severity_level lvl ) { boost::log::core::get()->set_filter(::boost::log::trivial::severity >= lvl);
boost::log::core::get()->set_filter G13_OUT("set log level to " << lvl);
(
::boost::log::trivial::severity >= lvl
);
G13_OUT( "set log level to " << lvl );
} }
void G13_Manager::set_log_level( const std::string &level ) { void G13_Manager::set_log_level(const std::string &level) {
#define CHECK_LEVEL( L ) \ #define CHECK_LEVEL(L) \
if( level == BOOST_PP_STRINGIZE(L) ) { \ if (level == BOOST_PP_STRINGIZE(L)) { \
set_log_level( ::boost::log::trivial::L ); \ set_log_level(::boost::log::trivial::L); \
return; \ return; \
} \ }
CHECK_LEVEL( trace ); CHECK_LEVEL(trace);
CHECK_LEVEL( debug ); CHECK_LEVEL(debug);
CHECK_LEVEL( info ); CHECK_LEVEL(info);
CHECK_LEVEL( warning ); CHECK_LEVEL(warning);
CHECK_LEVEL( error ); CHECK_LEVEL(error);
CHECK_LEVEL( fatal ); CHECK_LEVEL(fatal);
G13_LOG( error, "unknown log level" << level ); G13_LOG(error, "unknown log level" << level);
} }
} // namespace G13 } // namespace G13

91
g13d/g13_main.cc
View File

@ -2,14 +2,14 @@
#include <boost/program_options.hpp> #include <boost/program_options.hpp>
#if 0 #if 0
#include <boost/log/core/core.hpp>
#include <boost/log/attributes.hpp> #include <boost/log/attributes.hpp>
#include <boost/log/trivial.hpp> #include <boost/log/core/core.hpp>
#include <boost/log/expressions.hpp> #include <boost/log/expressions.hpp>
#include <boost/log/utility/setup.hpp>
#include <boost/log/utility/setup/console.hpp>
#include <boost/log/expressions/formatters/stream.hpp> #include <boost/log/expressions/formatters/stream.hpp>
#include <boost/log/support/date_time.hpp> #include <boost/log/support/date_time.hpp>
#include <boost/log/trivial.hpp>
#include <boost/log/utility/setup.hpp>
#include <boost/log/utility/setup/console.hpp>
#endif #endif
using namespace std; using namespace std;
@ -18,53 +18,52 @@ namespace po = boost::program_options;
int main(int argc, char *argv[]) { int main(int argc, char *argv[]) {
G13_Manager manager; G13_Manager manager;
manager.set_log_level("info"); manager.set_log_level("info");
// Declare the supported options. // Declare the supported options.
po::options_description desc("Allowed options"); po::options_description desc("Allowed options");
desc.add_options() desc.add_options()("help", "produce help message");
("help", "produce help message") std::vector<std::string> sopt_names;
; auto add_string_option = [&sopt_names, &desc](const char *name,
std::vector<std::string> sopt_names; const char *description) {
auto add_string_option = [ &sopt_names, &desc ]( const char *name, const char *description ) { desc.add_options()(name, po::value<std::string>(), description);
desc.add_options()( name, po::value<std::string>(), description ); sopt_names.push_back(name);
sopt_names.push_back(name); };
}; add_string_option("logo", "set logo from file");
add_string_option( "logo", "set logo from file" ); add_string_option("config", "load config commands from file");
add_string_option( "config", "load config commands from file" ); add_string_option("pipe_in", "specify name for input pipe");
add_string_option( "pipe_in", "specify name for input pipe" ); add_string_option("pipe_out", "specify name for output pipe");
add_string_option( "pipe_out", "specify name for output pipe" ); add_string_option("log_level", "logging level");
add_string_option( "log_level", "logging level" ); // add_string_option( "logfile", "write log to logfile" );
// add_string_option( "logfile", "write log to logfile" );
po::positional_options_description p; po::positional_options_description p;
p.add("logo", -1); p.add("logo", -1);
po::variables_map vm; po::variables_map vm;
po::store(po::command_line_parser(argc, argv). po::store(
options(desc).positional(p).run(), vm); po::command_line_parser(argc, argv).options(desc).positional(p).run(),
po::notify(vm); vm);
po::notify(vm);
if (vm.count("help")) { if (vm.count("help")) {
cout << argv[0] << " : user space G13 driver" << endl; cout << argv[0] << " : user space G13 driver" << endl;
cout << desc << "\n"; cout << desc << "\n";
return 1; return 1;
} }
BOOST_FOREACH( const std::string &tag, sopt_names ) { BOOST_FOREACH (const std::string &tag, sopt_names) {
if (vm.count(tag) ) { if (vm.count(tag)) {
manager.set_string_config_value(tag,vm[tag].as<std::string>()); manager.set_string_config_value(tag, vm[tag].as<std::string>());
} }
} }
if (vm.count("logo")) { if (vm.count("logo")) {
manager.set_logo(vm["logo"].as<std::string>()); manager.set_logo(vm["logo"].as<std::string>());
} }
if (vm.count("log_level")) { if (vm.count("log_level")) {
manager.set_log_level( manager.string_config_value( "log_level") ); manager.set_log_level(manager.string_config_value("log_level"));
} }
manager.run(); manager.run();
} }

262
g13d/g13_stick.cc
View File

@ -3,178 +3,168 @@
*/ */
#include "g13.h" #include "g13.h"
using namespace std; using namespace std;
namespace G13 { namespace G13 {
// ************************************************************************* // *************************************************************************
void G13_Device::parse_joystick(unsigned char *buf ) { void G13_Device::parse_joystick(unsigned char *buf) {
_stick.parse_joystick(buf); _stick.parse_joystick(buf);
} }
G13_Stick::G13_Stick( G13_Device &keypad ) : G13_Stick::G13_Stick(G13_Device &keypad)
_keypad(keypad), : _keypad(keypad), _bounds(0, 0, 255, 255), _center_pos(127, 127),
_bounds(0,0,255,255), _north_pos(127, 0) {
_center_pos(127,127), _stick_mode = STICK_KEYS;
_north_pos( 127, 0 )
{
_stick_mode = STICK_KEYS;
auto add_zone = [this, &keypad]( const std::string &name, double x1, double y1, double x2, double y2 ) { auto add_zone = [this, &keypad](const std::string &name, double x1, double y1,
_zones.push_back( G13_StickZone( *this, "STICK_"+name, double x2, double y2) {
G13_ZoneBounds( x1, y1, x2, y2 ), _zones.push_back(G13_StickZone(
G13_ActionPtr( *this, "STICK_" + name, G13_ZoneBounds(x1, y1, x2, y2),
new G13_Action_Keys( keypad, "KEY_" + name ) ) G13_ActionPtr(new G13_Action_Keys(keypad, "KEY_" + name))));
) };
);
};
add_zone( "UP", 0.0, 0.1, 1.0, 0.3 );
add_zone( "DOWN", 0.0, 0.7, 1.0, 0.9 );
add_zone( "LEFT", 0.0, 0.0, 0.2, 1.0 );
add_zone( "RIGHT", 0.8, 0.0, 1.0, 1.0 );
add_zone( "PAGEUP", 0.0, 0.0, 1.0, 0.1 );
add_zone( "PAGEDOWN", 0.0, 0.9, 1.0, 1.0 );
add_zone("UP", 0.0, 0.1, 1.0, 0.3);
add_zone("DOWN", 0.0, 0.7, 1.0, 0.9);
add_zone("LEFT", 0.0, 0.0, 0.2, 1.0);
add_zone("RIGHT", 0.8, 0.0, 1.0, 1.0);
add_zone("PAGEUP", 0.0, 0.0, 1.0, 0.1);
add_zone("PAGEDOWN", 0.0, 0.9, 1.0, 1.0);
} }
G13_StickZone *G13_Stick::zone( const std::string &name, bool create ) { G13_StickZone *G13_Stick::zone(const std::string &name, bool create) {
BOOST_FOREACH( G13_StickZone &zone, _zones ) { BOOST_FOREACH (G13_StickZone &zone, _zones) {
if( zone.name() == name ) { if (zone.name() == name) {
return &zone; return &zone;
} }
} }
if( create ) { if (create) {
_zones.push_back( G13_StickZone( *this, name, G13_ZoneBounds( 0.0, 0.0, 0.0, 0.0 ) ) ); _zones.push_back(
return zone(name); G13_StickZone(*this, name, G13_ZoneBounds(0.0, 0.0, 0.0, 0.0)));
} return zone(name);
return 0; }
return 0;
} }
void G13_Stick::set_mode( stick_mode_t m ) { void G13_Stick::set_mode(stick_mode_t m) {
if( m == _stick_mode ) if (m == _stick_mode)
return; return;
if( _stick_mode == STICK_CALCENTER || _stick_mode == STICK_CALBOUNDS || _stick_mode == STICK_CALNORTH ) { if (_stick_mode == STICK_CALCENTER || _stick_mode == STICK_CALBOUNDS ||
_recalc_calibrated(); _stick_mode == STICK_CALNORTH) {
} _recalc_calibrated();
_stick_mode = m; }
switch( _stick_mode ) { _stick_mode = m;
case STICK_CALBOUNDS: switch (_stick_mode) {
_bounds.tl = G13_StickCoord( 255, 255 ); case STICK_CALBOUNDS:
_bounds.br = G13_StickCoord( 0, 0 ); _bounds.tl = G13_StickCoord(255, 255);
break; _bounds.br = G13_StickCoord(0, 0);
} break;
}
} }
void G13_Stick::_recalc_calibrated() { void G13_Stick::_recalc_calibrated() {}
void G13_Stick::remove_zone(const G13_StickZone &zone) {
G13_StickZone target(zone);
_zones.erase(std::remove(_zones.begin(), _zones.end(), target), _zones.end());
}
void G13_Stick::dump(std::ostream &out) const {
BOOST_FOREACH (const G13_StickZone &zone, _zones) {
zone.dump(out);
out << endl;
}
} }
void G13_Stick::remove_zone( const G13_StickZone &zone ) { void G13_StickZone::dump(std::ostream &out) const {
G13_StickZone target(zone); out << " " << setw(20) << name() << " " << _bounds << " ";
_zones.erase(std::remove(_zones.begin(), _zones.end(), target), _zones.end()); if (action()) {
action()->dump(out);
} } else {
void G13_Stick::dump( std::ostream &out ) const { out << " (no action)";
BOOST_FOREACH( const G13_StickZone &zone, _zones ) { }
zone.dump( out );
out << endl;
}
} }
void G13_StickZone::dump( std::ostream & out ) const { void G13_StickZone::test(const G13_ZoneCoord &loc) {
out << " " << setw(20) << name() << " " << _bounds << " "; if (!_action)
if( action() ) { return;
action()->dump( out ); bool prior_active = _active;
} else { _active = _bounds.contains(loc);
out << " (no action)"; if (!_active) {
} if (prior_active) {
// cout << "exit stick zone " << _name << std::endl;
_action->act(false);
}
} else {
// cout << "in stick zone " << _name << std::endl;
_action->act(true);
}
} }
void G13_StickZone::test( const G13_ZoneCoord &loc ) { G13_StickZone::G13_StickZone(G13_Stick &stick, const std::string &name,
if( !_action ) return; const G13_ZoneBounds &b, G13_ActionPtr action)
bool prior_active = _active; : G13_Actionable<G13_Stick>(stick, name), _bounds(b), _active(false) {
_active = _bounds.contains( loc ); set_action(action);
if( !_active ) {
if( prior_active ) {
// cout << "exit stick zone " << _name << std::endl;
_action->act( false );
}
} else {
// cout << "in stick zone " << _name << std::endl;
_action->act( true );
}
}
G13_StickZone::G13_StickZone( G13_Stick &stick, const std::string &name, const G13_ZoneBounds &b, G13_ActionPtr action) :
G13_Actionable<G13_Stick>( stick, name ), _bounds(b), _active(false)
{
set_action( action );
} }
void G13_Stick::parse_joystick(unsigned char *buf) { void G13_Stick::parse_joystick(unsigned char *buf) {
_current_pos.x = buf[1]; _current_pos.x = buf[1];
_current_pos.y = buf[2]; _current_pos.y = buf[2];
// update targets if we're in calibration mode // update targets if we're in calibration mode
switch (_stick_mode) { switch (_stick_mode) {
case STICK_CALCENTER: case STICK_CALCENTER:
_center_pos = _current_pos; _center_pos = _current_pos;
return; return;
case STICK_CALNORTH: case STICK_CALNORTH:
_north_pos = _current_pos; _north_pos = _current_pos;
return; return;
case STICK_CALBOUNDS: case STICK_CALBOUNDS:
_bounds.expand( _current_pos ); _bounds.expand(_current_pos);
return; return;
}; };
// determine our normalized position // determine our normalized position
double dx = 0.5; double dx = 0.5;
if (_current_pos.x <= _center_pos.x) { if (_current_pos.x <= _center_pos.x) {
dx = _current_pos.x - _bounds.tl.x; dx = _current_pos.x - _bounds.tl.x;
dx /= (_center_pos.x - _bounds.tl.x) * 2; dx /= (_center_pos.x - _bounds.tl.x) * 2;
} else { } else {
dx = _bounds.br.x - _current_pos.x; dx = _bounds.br.x - _current_pos.x;
dx /= (_bounds.br.x - _center_pos.x ) * 2; dx /= (_bounds.br.x - _center_pos.x) * 2;
dx = 1.0 - dx; dx = 1.0 - dx;
} }
double dy = 0.5; double dy = 0.5;
if (_current_pos.y <= _center_pos.y) { if (_current_pos.y <= _center_pos.y) {
dy = _current_pos.y - _bounds.tl.y; dy = _current_pos.y - _bounds.tl.y;
dy /= (_center_pos.y - _bounds.tl.y) * 2; dy /= (_center_pos.y - _bounds.tl.y) * 2;
} else { } else {
dy = _bounds.br.y - _current_pos.y; dy = _bounds.br.y - _current_pos.y;
dy /= (_bounds.br.y -_center_pos.y ) * 2; dy /= (_bounds.br.y - _center_pos.y) * 2;
dy = 1.0 - dy; dy = 1.0 - dy;
} }
G13_LOG( trace, "x=" << _current_pos.x << " y=" << _current_pos.y << " dx=" << dx << " dy=" << dy ); G13_LOG(trace, "x=" << _current_pos.x << " y=" << _current_pos.y
G13_ZoneCoord jpos(dx, dy); << " dx=" << dx << " dy=" << dy);
if (_stick_mode == STICK_ABSOLUTE) { G13_ZoneCoord jpos(dx, dy);
_keypad.send_event( EV_ABS, ABS_X, _current_pos.x ); if (_stick_mode == STICK_ABSOLUTE) {
_keypad.send_event( EV_ABS, ABS_Y, _current_pos.y ); _keypad.send_event(EV_ABS, ABS_X, _current_pos.x);
_keypad.send_event(EV_ABS, ABS_Y, _current_pos.y);
} else if (_stick_mode == STICK_KEYS) { } else if (_stick_mode == STICK_KEYS) {
BOOST_FOREACH( G13_StickZone &zone, _zones ) { BOOST_FOREACH (G13_StickZone &zone, _zones) { zone.test(jpos); }
zone.test(jpos); return;
}
return;
} else { } else {
/* send_event(g13->uinput_file, EV_REL, REL_X, stick_x/16 - 8); /* send_event(g13->uinput_file, EV_REL, REL_X, stick_x/16 - 8);
send_event(g13->uinput_file, EV_REL, REL_Y, stick_y/16 - 8);*/ send_event(g13->uinput_file, EV_REL, REL_Y, stick_y/16 - 8);*/
} }
} }
} // namespace G13 } // namespace G13

70
g13d/helper.cc
View File

@ -32,45 +32,49 @@
namespace Helper { namespace Helper {
void string_repr_out::write_on( std::ostream &o ) const { void string_repr_out::write_on(std::ostream &o) const {
o << "\""; o << "\"";
const char *cp = s.c_str(); const char *cp = s.c_str();
const char *end = cp + s.size(); const char *end = cp + s.size();
while( cp < end ) { while (cp < end) {
switch( *cp ) { switch (*cp) {
case '\n': o << "\\n"; break; case '\n':
case '\r': o << "\\r"; break; o << "\\n";
case '\0': o << "\\0"; break; break;
case '\t': o << "\\t"; break; case '\r':
case '\\': o << "\\r";
case '\'': break;
case '\"': case '\0':
o << "\\" << *cp; o << "\\0";
break; break;
default: { case '\t':
char c = *cp; o << "\\t";
if( c < 32 ) { break;
char hi = '0' + (c & 0x0f); case '\\':
char lo = '0' + ((c >> 4) & 0x0f); case '\'':
o << "\\x" << hi << lo; case '\"':
} else { o << "\\" << *cp;
o << c; break;
} default: {
} char c = *cp;
} if (c < 32) {
cp++; char hi = '0' + (c & 0x0f);
} char lo = '0' + ((c >> 4) & 0x0f);
o << "\\x" << hi << lo;
} else {
o << c;
}
}
}
cp++;
}
o << "\""; o << "\"";
}; };
}; // namespace Helper }; // namespace Helper
// ************************************************************************* // *************************************************************************

210
g13d/helper.h
View File

@ -31,167 +31,163 @@
#ifndef __HELPER_HPP__ #ifndef __HELPER_HPP__
#define __HELPER_HPP__ #define __HELPER_HPP__
#include <boost/lexical_cast.hpp>
#include <boost/foreach.hpp>
#include <boost/algorithm/string.hpp> #include <boost/algorithm/string.hpp>
#include <boost/preprocessor/seq.hpp> #include <boost/foreach.hpp>
#include <boost/lexical_cast.hpp>
#include <boost/preprocessor/cat.hpp> #include <boost/preprocessor/cat.hpp>
#include <boost/preprocessor/seq.hpp>
#include <boost/shared_ptr.hpp> #include <boost/shared_ptr.hpp>
#include <iostream>
#include <iomanip> #include <iomanip>
#include <iostream>
#include <exception> #include <exception>
#include <map>
#include <string> #include <string>
#include <vector> #include <vector>
#include <map>
// ************************************************************************* // *************************************************************************
namespace Helper { namespace Helper {
struct string_repr_out { struct string_repr_out {
string_repr_out( const std::string &str ) : s(str) {} string_repr_out(const std::string &str) : s(str) {}
void write_on( std::ostream & ) const; void write_on(std::ostream &) const;
std::string s; std::string s;
}; };
inline std::ostream &operator <<( std::ostream & o, const string_repr_out & sro ) { inline std::ostream &operator<<(std::ostream &o, const string_repr_out &sro) {
sro.write_on( o ); sro.write_on(o);
return o; return o;
} }
template <class T> template <class T> inline const T &repr(const T &v) { return v; }
inline const T &repr( const T &v ) { return v; }
inline string_repr_out repr( const char *s ) { return string_repr_out(s); } inline string_repr_out repr(const char *s) { return string_repr_out(s); }
inline string_repr_out repr( const std::string & s ) { return string_repr_out(s); } inline string_repr_out repr(const std::string &s) { return string_repr_out(s); }
// ************************************************************************* // *************************************************************************
class NotFoundException : public std::exception { class NotFoundException : public std::exception {
public: public:
const char *what() throw();
const char *what() throw ();
}; };
template <class KEY_T, class VAL_T> template <class KEY_T, class VAL_T>
inline const VAL_T &find_or_throw( const std::map<KEY_T,VAL_T> &m, const KEY_T &target ) { inline const VAL_T &find_or_throw(const std::map<KEY_T, VAL_T> &m,
auto i = m.find( target ); const KEY_T &target) {
if( i == m.end() ) { auto i = m.find(target);
throw NotFoundException(); if (i == m.end()) {
} throw NotFoundException();
return i->second; }
return i->second;
}; };
template <class KEY_T, class VAL_T> template <class KEY_T, class VAL_T>
inline VAL_T &find_or_throw( std::map<KEY_T,VAL_T> &m, const KEY_T &target ) { inline VAL_T &find_or_throw(std::map<KEY_T, VAL_T> &m, const KEY_T &target) {
auto i = m.find( target ); auto i = m.find(target);
if( i == m.end() ) { if (i == m.end()) {
throw NotFoundException(); throw NotFoundException();
} }
return i->second; return i->second;
};
// *************************************************************************
template <class T>
class Coord {
public:
Coord() : x(), y() {}
Coord( T _x, T _y ) : x(_x), y(_y) {}
T x;
T y;
};
template <class T>
std::ostream &operator<<( std::ostream &o, const Coord<T> &c ) {
o << "{ " << c.x << " x " << c.y << " }";
return o;
};
template <class T>
class Bounds {
public:
typedef Coord<T> CT;
Bounds( const CT &_tl, const CT &_br) : tl(_tl), br(_br) {}
Bounds( T x1, T y1, T x2, T y2 ) : tl(x1,y1), br(x2,y2) {}
bool contains( const CT &pos ) const {
return tl.x <= pos.x && tl.y <= pos.y && pos.x <= br.x && pos.y <= br.y;
}
void expand( const CT &pos ) {
if( pos.x < tl.x ) tl.x = pos.x;
if( pos.y < tl.y ) tl.y = pos.y;
if( pos.x > br.x ) br.x = pos.x;
if( pos.y > br.y ) br.y = pos.y;
}
CT tl;
CT br;
};
template <class T>
std::ostream &operator<<( std::ostream &o, const Bounds<T> &b ) {
o << "{ " << b.tl.x << " x " << b.tl.y << " / " << b.br.x << " x " << b.br.y << " }";
return o;
}; };
// ************************************************************************* // *************************************************************************
typedef const char * CCP; template <class T> class Coord {
public:
Coord() : x(), y() {}
Coord(T _x, T _y) : x(_x), y(_y) {}
T x;
T y;
};
template <class T>
std::ostream &operator<<(std::ostream &o, const Coord<T> &c) {
o << "{ " << c.x << " x " << c.y << " }";
return o;
};
template <class T> class Bounds {
public:
typedef Coord<T> CT;
Bounds(const CT &_tl, const CT &_br) : tl(_tl), br(_br) {}
Bounds(T x1, T y1, T x2, T y2) : tl(x1, y1), br(x2, y2) {}
bool contains(const CT &pos) const {
return tl.x <= pos.x && tl.y <= pos.y && pos.x <= br.x && pos.y <= br.y;
}
void expand(const CT &pos) {
if (pos.x < tl.x)
tl.x = pos.x;
if (pos.y < tl.y)
tl.y = pos.y;
if (pos.x > br.x)
br.x = pos.x;
if (pos.y > br.y)
br.y = pos.y;
}
CT tl;
CT br;
};
template <class T>
std::ostream &operator<<(std::ostream &o, const Bounds<T> &b) {
o << "{ " << b.tl.x << " x " << b.tl.y << " / " << b.br.x << " x " << b.br.y
<< " }";
return o;
};
// *************************************************************************
typedef const char *CCP;
inline const char *advance_ws(CCP &source, std::string &dest) { inline const char *advance_ws(CCP &source, std::string &dest) {
const char *space = source ? strchr(source, ' ') : 0; const char *space = source ? strchr(source, ' ') : 0;
if (space) { if (space) {
dest = std::string(source, space - source); dest = std::string(source, space - source);
source = space + 1; source = space + 1;
} else { } else {
dest = source; dest = source;
source = 0; source = 0;
} }
return source; return source;
}; };
// ************************************************************************* // *************************************************************************
template <class MAP_T> template <class MAP_T> struct _map_keys_out {
struct _map_keys_out { _map_keys_out(const MAP_T &c, const std::string &s) : container(c), sep(s) {}
_map_keys_out( const MAP_T&c, const std::string &s ) : container(c), sep(s) {} const MAP_T &container;
const MAP_T&container; std::string sep;
std::string sep;
}; };
template <class STREAM_T, class MAP_T> template <class STREAM_T, class MAP_T>
STREAM_T &operator <<( STREAM_T &o, const _map_keys_out<MAP_T> &_mko ) { STREAM_T &operator<<(STREAM_T &o, const _map_keys_out<MAP_T> &_mko) {
bool first = true; bool first = true;
for( auto i = _mko.container.begin(); i != _mko.container.end(); i++ ) { for (auto i = _mko.container.begin(); i != _mko.container.end(); i++) {
if( first ) { if (first) {
first = false; first = false;
o << i->first; o << i->first;
} else { } else {
o << _mko.sep << i->first; o << _mko.sep << i->first;
} }
} }
return o; return o;
}; };
template <class MAP_T> template <class MAP_T>
_map_keys_out<MAP_T> map_keys_out( const MAP_T &c, const std::string &sep = " " ) { _map_keys_out<MAP_T> map_keys_out(const MAP_T &c,
return _map_keys_out<MAP_T>( c, sep ); const std::string &sep = " ") {
return _map_keys_out<MAP_T>(c, sep);
}; };
// ************************************************************************* // *************************************************************************
}; // namespace Helper }; // namespace Helper
// ************************************************************************* // *************************************************************************
#endif // __HELPER_HPP__ #endif // __HELPER_HPP__

143
g13d/logo.h
View File

@ -1,66 +1,85 @@
#ifndef G13_LOGO_H #ifndef G13_LOGO_H
#define G13_LOGO_H #define G13_LOGO_H
static unsigned char g13_logo[160*48/8] = { static unsigned char g13_logo[160 * 48 / 8] = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x80, 0xc0, 0xe0, 0xe0, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x80,
0xf0, 0xf8, 0x78, 0x78, 0x7c, 0x3c, 0x3c, 0x3e, 0x3e, 0x1e, 0x1e, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0xc0, 0xe0, 0xe0, 0xf0, 0xf0, 0xf8, 0x78, 0x78, 0x7c, 0x3c, 0x3c, 0x3e,
0xdf, 0xdf, 0x9f, 0x9f, 0x9f, 0xbe, 0x3e, 0x7e, 0x1e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x1e, 0x1e, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0xdf, 0xdf, 0x9f, 0x9f,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x9f, 0xbe, 0x3e, 0x7e, 0x1e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x20, 0x90, 0xe8, 0x70, 0x94, 0x28, 0x0a, 0x0c, 0x12, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x06, 0x10, 0x14, 0x10, 0x10, 0x48, 0x40, 0x00, 0x40, 0x00, 0x00, 0x00, 0x80, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x48, 0x10, 0x0c, 0x10, 0x18, 0x04, 0x18, 0x08, 0x28, 0x5c, 0x30, 0xe8, 0x90, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x20, 0x90,
0x00, 0x00, 0x80, 0xc0, 0xf0, 0xf8, 0x7c, 0x3e, 0x1e, 0x0f, 0x0f, 0x07, 0x03, 0x83, 0x81, 0x81, 0xe8, 0x70, 0x94, 0x28, 0x0a, 0x0c, 0x12, 0x04, 0x06, 0x10, 0x14, 0x10,
0x00, 0x00, 0x00, 0x00, 0xe0, 0xe0, 0x80, 0x00, 0xe0, 0xe0, 0x00, 0x18, 0x38, 0xf0, 0xf0, 0xf8, 0x10, 0x48, 0x40, 0x00, 0x40, 0x00, 0x00, 0x00, 0x80, 0x00, 0x40, 0x00,
0x8b, 0x07, 0x04, 0x04, 0x07, 0x0f, 0x0f, 0x1f, 0x1e, 0x3e, 0x7c, 0xf8, 0xf0, 0xc0, 0x00, 0x00, 0x48, 0x10, 0x0c, 0x10, 0x18, 0x04, 0x18, 0x08, 0x28, 0x5c, 0x30, 0xe8,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0xc0, 0xf0, 0xf0, 0xf8, 0xf8, 0xfc, 0xfc, 0x7c, 0x7c, 0x90, 0x20, 0x00, 0x00, 0x00, 0x00, 0x80, 0xc0, 0xf0, 0xf8, 0x7c, 0x3e,
0x3c, 0x3c, 0x3c, 0x3c, 0x7c, 0x7c, 0x78, 0xf8, 0xfc, 0xfc, 0xfc, 0x80, 0x00, 0x00, 0x00, 0x00, 0x1e, 0x0f, 0x0f, 0x07, 0x03, 0x83, 0x81, 0x81, 0x00, 0x00, 0x00, 0x00,
0x00, 0x60, 0x70, 0xf0, 0xf0, 0xf0, 0xf0, 0xf8, 0xf0, 0xf8, 0xf8, 0x38, 0x10, 0x00, 0x00, 0x00, 0xe0, 0xe0, 0x80, 0x00, 0xe0, 0xe0, 0x00, 0x18, 0x38, 0xf0, 0xf0, 0xf8,
0x00, 0x00, 0x00, 0x00, 0xe0, 0xf8, 0xf8, 0x78, 0x3c, 0x3c, 0x7c, 0xfc, 0xfc, 0xf8, 0xf8, 0xf0, 0x8b, 0x07, 0x04, 0x04, 0x07, 0x0f, 0x0f, 0x1f, 0x1e, 0x3e, 0x7c, 0xf8,
0xe0, 0x00, 0x00, 0x00, 0x00, 0xb0, 0x00, 0x1f, 0xff, 0xe4, 0x80, 0x80, 0x80, 0xe0, 0xd0, 0x28, 0xf0, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0xc0,
0x34, 0x18, 0x1d, 0x1e, 0xcf, 0x0f, 0x6f, 0x0f, 0x0f, 0x87, 0x2e, 0x01, 0x01, 0x65, 0x03, 0xcf, 0xf0, 0xf0, 0xf8, 0xf8, 0xfc, 0xfc, 0x7c, 0x7c, 0x3c, 0x3c, 0x3c, 0x3c,
0x4f, 0x0f, 0x1e, 0x1d, 0x38, 0x60, 0xd0, 0xe0, 0x80, 0xe0, 0xcb, 0xfd, 0x3f, 0x80, 0x35, 0x00, 0x7c, 0x7c, 0x78, 0xf8, 0xfc, 0xfc, 0xfc, 0x80, 0x00, 0x00, 0x00, 0x00,
0xf0, 0xfe, 0xff, 0x0f, 0x03, 0x01, 0x3e, 0xfe, 0xfe, 0x00, 0x08, 0xfb, 0xfb, 0x00, 0xff, 0xff, 0x00, 0x60, 0x70, 0xf0, 0xf0, 0xf0, 0xf0, 0xf8, 0xf0, 0xf8, 0xf8, 0x38,
0x03, 0x1f, 0xff, 0xfe, 0x0f, 0x1f, 0x1f, 0x1c, 0x1f, 0x3f, 0x98, 0x80, 0x4f, 0xe7, 0x61, 0x01, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0xf8, 0xf8, 0x78,
0x83, 0xc2, 0xfc, 0xfc, 0xfc, 0x80, 0xf0, 0xf0, 0xd0, 0xf0, 0x30, 0x00, 0x03, 0xff, 0xff, 0xfc, 0x3c, 0x3c, 0x7c, 0xfc, 0xfc, 0xf8, 0xf8, 0xf0, 0xe0, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x01, 0x00, 0x00, 0x00, 0xb0, 0x00, 0x1f, 0xff, 0xe4, 0x80, 0x80, 0x80, 0xe0, 0xd0, 0x28,
0x00, 0x40, 0x70, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf1, 0xf3, 0xf3, 0xf0, 0xf0, 0x00, 0x00, 0x00, 0x34, 0x18, 0x1d, 0x1e, 0xcf, 0x0f, 0x6f, 0x0f, 0x0f, 0x87, 0x2e, 0x01,
0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x65, 0x03, 0xcf, 0x4f, 0x0f, 0x1e, 0x1d, 0x38, 0x60, 0xd0, 0xe0,
0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x18, 0x18, 0x38, 0x3e, 0xff, 0xff, 0xff, 0xf7, 0xe7, 0x80, 0xe0, 0xcb, 0xfd, 0x3f, 0x80, 0x35, 0x00, 0xf0, 0xfe, 0xff, 0x0f,
0xc1, 0x80, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x04, 0x01, 0x09, 0xc3, 0x3f, 0x03, 0x00, 0x00, 0x03, 0x01, 0x3e, 0xfe, 0xfe, 0x00, 0x08, 0xfb, 0xfb, 0x00, 0xff, 0xff,
0x80, 0x80, 0x40, 0x10, 0x44, 0x00, 0x00, 0x02, 0x02, 0x03, 0x00, 0xc0, 0x01, 0x00, 0x40, 0x03, 0x03, 0x1f, 0xff, 0xfe, 0x0f, 0x1f, 0x1f, 0x1c, 0x1f, 0x3f, 0x98, 0x80,
0x06, 0x17, 0x30, 0x40, 0x20, 0x80, 0x21, 0x03, 0x4b, 0x23, 0x01, 0x04, 0x02, 0x00, 0x00, 0x00, 0x4f, 0xe7, 0x61, 0x01, 0x83, 0xc2, 0xfc, 0xfc, 0xfc, 0x80, 0xf0, 0xf0,
0x07, 0x7f, 0xfe, 0xe0, 0x80, 0x00, 0x00, 0x3f, 0x3f, 0x00, 0x00, 0x07, 0x03, 0x00, 0xf4, 0xfe, 0xd0, 0xf0, 0x30, 0x00, 0x03, 0xff, 0xff, 0xfc, 0x00, 0x00, 0x00, 0x00,
0xf4, 0x7c, 0xfc, 0xfc, 0x18, 0xfc, 0xfc, 0xf0, 0x1e, 0xbf, 0xf7, 0xe3, 0x1f, 0xff, 0xff, 0x3e, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x01, 0x00, 0x00,
0x7f, 0x77, 0x39, 0x7f, 0x7f, 0x03, 0x0f, 0x0f, 0x0c, 0x0e, 0x86, 0xe0, 0xf8, 0x7f, 0x1f, 0x03, 0x00, 0x40, 0x70, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf1, 0xf3, 0xf3, 0xf0,
0x00, 0x00, 0x00, 0x00, 0x03, 0x0f, 0x1f, 0x7f, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xf8, 0xf0, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff,
0xe0, 0xe0, 0xe0, 0xf0, 0xff, 0xff, 0xff, 0xff, 0x7f, 0x7f, 0x7f, 0x7f, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x80, 0xc0, 0xc0, 0xf0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe0, 0xc0, 0xc0, 0x80, 0x00, 0x00, 0x01, 0x01, 0x18, 0x18, 0x38, 0x3e, 0xff, 0xff, 0xff, 0xf7, 0xe7,
0x00, 0x00, 0x18, 0x78, 0xf8, 0xf0, 0xf0, 0xf0, 0xf0, 0xf8, 0xfc, 0xff, 0xff, 0xff, 0xff, 0x7f, 0xc1, 0x80, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x04, 0x01, 0x09, 0xc3,
0x3f, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x02, 0x02, 0x0d, 0xe1, 0x00, 0x3f, 0x03, 0x00, 0x00, 0x80, 0x80, 0x40, 0x10, 0x44, 0x00, 0x00, 0x02,
0x00, 0x07, 0x10, 0x20, 0x40, 0x00, 0x00, 0x00, 0x00, 0x08, 0x10, 0x21, 0x00, 0x41, 0x41, 0x00, 0x02, 0x03, 0x00, 0xc0, 0x01, 0x00, 0x40, 0x03, 0x06, 0x17, 0x30, 0x40,
0x40, 0x00, 0x40, 0x48, 0x30, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x80, 0x21, 0x03, 0x4b, 0x23, 0x01, 0x04, 0x02, 0x00, 0x00, 0x00,
0x00, 0x00, 0x01, 0x03, 0x0f, 0x1e, 0x3e, 0x7c, 0x78, 0xf0, 0xe0, 0xe0, 0xc0, 0xc0, 0xc7, 0x8f, 0x07, 0x7f, 0xfe, 0xe0, 0x80, 0x00, 0x00, 0x3f, 0x3f, 0x00, 0x00, 0x07,
0x8f, 0x80, 0x87, 0x07, 0x00, 0x00, 0x07, 0x07, 0x83, 0x83, 0x83, 0x81, 0x80, 0x80, 0xc0, 0xc0, 0x03, 0x00, 0xf4, 0xfe, 0xf4, 0x7c, 0xfc, 0xfc, 0x18, 0xfc, 0xfc, 0xf0,
0xc0, 0xe0, 0xe0, 0xf0, 0x70, 0x78, 0x3c, 0x1c, 0x0e, 0x0f, 0x07, 0x03, 0x00, 0x00, 0x00, 0x00, 0x1e, 0xbf, 0xf7, 0xe3, 0x1f, 0xff, 0xff, 0x3e, 0x7f, 0x77, 0x39, 0x7f,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x01, 0x01, 0x7f, 0x03, 0x0f, 0x0f, 0x0c, 0x0e, 0x86, 0xe0, 0xf8, 0x7f, 0x1f, 0x03,
0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x0f, 0x1f, 0x7f, 0x7f, 0xff, 0xff, 0xff,
0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0xff, 0xfe, 0xf8, 0xf0, 0xe0, 0xe0, 0xe0, 0xf0, 0xff, 0xff, 0xff, 0xff,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x7f, 0x7f, 0x7f, 0x7f, 0x00, 0x00, 0x00, 0x00, 0x80, 0xc0, 0xc0, 0xf0,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xe0, 0xc0, 0xc0, 0x80, 0x00,
0x04, 0x08, 0x00, 0x00, 0x01, 0x01, 0x0e, 0x58, 0x3c, 0x38, 0xe0, 0xc0, 0xc0, 0xe2, 0xe2, 0xa2, 0x00, 0x00, 0x18, 0x78, 0xf8, 0xf0, 0xf0, 0xf0, 0xf0, 0xf8, 0xfc, 0xff,
0x9a, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x7f, 0x3f, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x03, 0x03, 0x03, 0x00, 0x00, 0x03, 0x02, 0x02, 0x0d, 0xe1, 0x00, 0x00, 0x07, 0x10, 0x20,
0x03, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x03, 0x03, 0x03, 0x03, 0x03, 0x01, 0x40, 0x00, 0x00, 0x00, 0x00, 0x08, 0x10, 0x21, 0x00, 0x41, 0x41, 0x00,
0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x40, 0x48, 0x30, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x03, 0x0f, 0x1e, 0x3e, 0x7c,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x78, 0xf0, 0xe0, 0xe0, 0xc0, 0xc0, 0xc7, 0x8f, 0x8f, 0x80, 0x87, 0x07,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x83, 0x83, 0x83, 0x81, 0x80, 0x80, 0xc0, 0xc0,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0xe0, 0xe0, 0xf0, 0x70, 0x78, 0x3c, 0x1c, 0x0e, 0x0f, 0x07, 0x03,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x03, 0x01, 0x03, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
}; 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02,
0x04, 0x08, 0x00, 0x00, 0x01, 0x01, 0x0e, 0x58, 0x3c, 0x38, 0xe0, 0xc0,
0xc0, 0xe2, 0xe2, 0xa2, 0x9a, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x03, 0x03, 0x03,
0x03, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x03, 0x03,
0x03, 0x03, 0x03, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x01, 0x00, 0x01, 0x03, 0x01, 0x03, 0x01, 0x03, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
#endif #endif
/* G13_LOGO_H */ /* G13_LOGO_H */

58
g13d/pbm2lpbm.cc
View File

@ -1,7 +1,7 @@
#include <iostream>
#include <string>
#include <string.h>
#include <cstdio> #include <cstdio>
#include <iostream>
#include <string.h>
#include <string>
using namespace std; using namespace std;
// convert a .pbm raw file to our custom .lpbm format // convert a .pbm raw file to our custom .lpbm format
@ -9,46 +9,48 @@ int main(int argc, char *argv[]) {
unsigned char c; unsigned char c;
const int LEN = 256; const int LEN = 256;
char s[LEN]; char s[LEN];
cin.getline(s,LEN); cin.getline(s, LEN);
if(strncmp(s,"P4",2)) { if (strncmp(s, "P4", 2)) {
cerr << "input file is not .pbm (P4)" << endl; cerr << "input file is not .pbm (P4)" << endl;
return -1; return -1;
} }
cin.getline(s,LEN); cin.getline(s, LEN);
while(s[0] == '#' || s[0] == ' ') while (s[0] == '#' || s[0] == ' ')
cin.getline(s,LEN); cin.getline(s, LEN);
unsigned int w=0, h=0; unsigned int w = 0, h = 0;
if(std::sscanf(s,"%d %d", &w, &h) != 2) { if (std::sscanf(s, "%d %d", &w, &h) != 2) {
cerr << "height and width not found" << endl; cerr << "height and width not found" << endl;
return -1; return -1;
} }
if(w != 160 || h != 43) { if (w != 160 || h != 43) {
cerr << "incorrect width / height, mandated: 160x43, found: " << w << "x" << h << endl; cerr << "incorrect width / height, mandated: 160x43, found: " << w << "x"
<< h << endl;
return -1; return -1;
} }
cin >> noskipws; cin >> noskipws;
int i = 0, row = -1; int i = 0, row = -1;
unsigned char buf[160*48]; unsigned char buf[160 * 48];
memset(buf, 0, 160*43); memset(buf, 0, 160 * 43);
while(cin >> c) { while (cin >> c) {
if(i%20 == 0) if (i % 20 == 0)
row++; row++;
if(row == 8) if (row == 8)
row = 0; row = 0;
buf[7+(i%20)*8+i/160*160] |= ((c >> 0) & 0x01) << row; buf[7 + (i % 20) * 8 + i / 160 * 160] |= ((c >> 0) & 0x01) << row;
buf[6+(i%20)*8+i/160*160] |= ((c >> 1) & 0x01) << row; buf[6 + (i % 20) * 8 + i / 160 * 160] |= ((c >> 1) & 0x01) << row;
buf[5+(i%20)*8+i/160*160] |= ((c >> 2) & 0x01) << row; buf[5 + (i % 20) * 8 + i / 160 * 160] |= ((c >> 2) & 0x01) << row;
buf[4+(i%20)*8+i/160*160] |= ((c >> 3) & 0x01) << row; buf[4 + (i % 20) * 8 + i / 160 * 160] |= ((c >> 3) & 0x01) << row;
buf[3+(i%20)*8+i/160*160] |= ((c >> 4) & 0x01) << row; buf[3 + (i % 20) * 8 + i / 160 * 160] |= ((c >> 4) & 0x01) << row;
buf[2+(i%20)*8+i/160*160] |= ((c >> 5) & 0x01) << row; buf[2 + (i % 20) * 8 + i / 160 * 160] |= ((c >> 5) & 0x01) << row;
buf[1+(i%20)*8+i/160*160] |= ((c >> 6) & 0x01) << row; buf[1 + (i % 20) * 8 + i / 160 * 160] |= ((c >> 6) & 0x01) << row;
buf[0+(i%20)*8+i/160*160] |= ((c >> 7) & 0x01) << row; buf[0 + (i % 20) * 8 + i / 160 * 160] |= ((c >> 7) & 0x01) << row;
i++; i++;
} }
if(i != 160*43/8) { if (i != 160 * 43 / 8) {
cerr << "wrong number of bytes, expected " << 160*43/8 << ", got " << i << endl; cerr << "wrong number of bytes, expected " << 160 * 43 / 8 << ", got " << i
<< endl;
} }
for(int i = 0; i < 160*48/8;i++) { for (int i = 0; i < 160 * 48 / 8; i++) {
cout << hex << (char)buf[i]; cout << hex << (char)buf[i];
} }
} }