Initialize FreeType, link to it.
[ccbs] / bigscreen / ccbs_bigscreen.cpp
1 #include <cstdio>
2 #include <cstring>
3 #include <iconv.h>
4 #include <unistd.h>
5 #include <pqxx/pqxx>
6 #include <ft2build.h>
7 #include FT_FREETYPE_H
8
9 #include "glwindow.h"
10
11 iconv_t ucs4_iconv;
12
13 // UCS-4 string
14 class widestring : public std::basic_string<unsigned>
15 {
16 public:
17         void operator= (const char *from)
18         {
19                 unsigned bytes = std::strlen(from);
20                 char *from_buf = strdup(from);
21                 unsigned *to_buf = new unsigned[bytes + 1];
22
23                 char *inptr = from_buf, *outptr = reinterpret_cast<char *> (to_buf);
24
25                 size_t in_left = bytes;
26                 size_t out_left = bytes * sizeof(unsigned);
27
28                 size_t ret = iconv(ucs4_iconv, NULL, NULL, &outptr, &out_left);
29                 if (ret == (size_t)(-1)) {
30                         throw std::runtime_error("Error in iconv during initialization");
31                 }
32
33                 ret = iconv(ucs4_iconv, &inptr, &in_left, &outptr, &out_left);
34                 if (ret == (size_t)(-1)) {
35                         perror("iconv");
36                         throw std::runtime_error("Error in iconv during conversion");
37                 }
38
39                 erase(begin(), end());
40                 std::copy(to_buf, reinterpret_cast<unsigned *> (outptr), std::back_inserter(*this));
41
42                 free(from_buf);
43                 delete[] to_buf;
44         }
45 };
46
47 template<>
48 void std::char_traits<unsigned>::assign(unsigned &to, unsigned const &from)
49 {
50         to = from;
51 }
52
53 template<>
54 unsigned *std::char_traits<unsigned>::copy(unsigned *to, unsigned const *from, unsigned n)
55 {
56         return static_cast<unsigned *>(memcpy(to, from, n * sizeof(unsigned)));
57 }
58
59 template<>
60 unsigned *std::char_traits<unsigned>::move(unsigned *to, unsigned const *from, unsigned n)
61 {
62         return static_cast<unsigned *>(memmove(to, from, n * sizeof(unsigned)));
63 }
64
65 template<>
66 unsigned *std::char_traits<unsigned>::assign(unsigned *to, size_t n, unsigned a)
67 {
68         for (unsigned i = 0; i < n; ++i)
69                 *to++ = a;
70         return to;
71 }
72
73
74 template<>
75 void pqxx::from_string<widestring>(const char *from, widestring &to)
76 {
77         to = from;
78 }
79
80 class Tournament {
81 public:
82         int id;
83         widestring name;
84 };
85
86 Tournament active_tournament;
87 FT_Face font;
88
89 /* A trigger that sets a flag whenever it's trigged. */
90 class FlagTrigger : pqxx::trigger {
91 private:
92         bool flag;
93         
94 public:
95         FlagTrigger(pqxx::connection_base &conn, const PGSTD::string &name)
96                 : pqxx::trigger(conn, name), flag(false) {}
97         virtual ~FlagTrigger() throw () {}
98         
99         virtual void operator() (int pid)
100         {
101                 flag = true;
102                 std::fprintf(stderr, "Received a flag trigger from pid %u\n", pid);
103         }
104
105         bool get_flag() const
106         {
107                 return flag;
108         }
109
110         void reset_flag()
111         {
112                 flag = false;
113         }
114 };
115
116 /* A transactor that fetches the current tournament and some information about it. */
117 class FetchCurrentTournament : public pqxx::transactor<> {
118 private:
119         Tournament *tourn;
120
121 public:
122         FetchCurrentTournament(Tournament *tourn) : tourn(tourn) {}
123         void operator() (pqxx::transaction<> &t)
124         {
125                 pqxx::result res( t.exec("SELECT * FROM bigscreen.active_tournament NATURAL JOIN tournaments") );
126                 try {
127                         pqxx::result::tuple tournament = res.at(0);
128
129                         tourn->id = tournament["tournament"].as(tourn->id);
130                         tourn->name = tournament["tournamentname"].as(tourn->name);
131                 } catch (PGSTD::out_of_range &e) {
132                         tourn->id = -1;
133                         tourn->name = "";
134                 }
135         }
136 };
137
138 void init(pqxx::connection &conn)
139 {
140         conn.perform(FetchCurrentTournament(&active_tournament));
141
142         if (active_tournament.id == -1) {
143                 std::fprintf(stderr, "No active tournament\n");
144         } else {
145                 std::fprintf(stderr, "Current tournament is %d (name: '%s')\n",
146                         active_tournament.id, active_tournament.name.c_str());
147         }
148 }
149
150 void main_loop(pqxx::connection &conn)
151 {
152         if (active_tournament.id == -1) {
153                 // No active tournament, sleep a second or so and exit
154                 sleep(1);
155                 return;
156         }
157         
158         pqxx::work t(conn, "trx");
159
160         // fetch all songs
161         pqxx::result res( t.exec("SELECT * FROM songs") );
162         for (pqxx::result::const_iterator i = res.begin(); i != res.end(); ++i) {
163                 std::fprintf(stderr, "%s\n", i["title"].c_str());
164         }
165         t.commit();
166         
167         sleep(1);
168 }
169
170 void init_freetype()
171 {
172         FT_Library library;
173         if (FT_Init_FreeType(&library))
174                 throw std::logic_error("FreeType init failed.");
175         if (FT_New_Face(library, "/usr/share/fonts/truetype/msttcorefonts/Georgia.ttf", 0, &font))
176                 throw std::logic_error("Face opening failed.");
177         if (FT_Set_Char_Size(font, 0, 12, 96, 96))
178                 throw std::logic_error("Size set failed.");
179 }
180
181 int main(int argc, char **argv)
182 {
183         ucs4_iconv = iconv_open("ucs-4", "utf-8");
184         
185         GLWindow glw("CCBS bigscreen", 800, 600, 32, false, 16, -1);
186         
187         try {
188                 init_freetype();
189                 pqxx::connection conn("dbname=ccbs host=altersex.samfundet.no user=ccbs password=GeT|>>B_");
190                 FlagTrigger tournament_changed(conn, "active_tournament");
191                 
192                 // when active_tournament is changed, we destroy everything and start from scratch
193                 for ( ;; ) {
194                         tournament_changed.reset_flag();
195                         init(conn);
196                         do {
197                                 main_loop(conn);
198                                 conn.get_notifs();
199                         } while (!tournament_changed.get_flag());
200                         std::fprintf(stderr, "active_tournament changed, resetting...\n");
201                 }
202         } catch (const std::exception &e) {
203                 std::fprintf(stderr, "Exception: %s\n", e.what());
204                 exit(1);
205         }
206         
207         return 0;
208 }