Eliminated warnings in style.h
[rodin/chimara.git] / libchimara / style.c
1 #include "style.h"
2 #include <stdio.h>
3 #include <fcntl.h>
4
5 extern GPrivate *glk_data_key;
6 static gboolean chimara_style_initialized = FALSE;
7 static gboolean style_accept(GScanner *scanner, GTokenType token);
8 static gboolean style_accept_style_identifier(GScanner *scanner);
9 static gboolean style_accept_style_hint(GScanner *scanner, GtkTextTag *current_tag);
10 static void style_add_tag_to_textbuffer(gpointer key, gpointer tag, gpointer tag_table);
11
12 /**
13  * glk_set_style:
14  * @styl: The style to apply
15  *
16  * Changes the style of the current output stream. @styl should be one of the
17  * <code>style_</code> constants listed above. However, any value is actually
18  * legal; if the interpreter does not recognize the style value, it will treat
19  * it as %style_Normal.
20  * <note><para>
21  *  This policy allows for the future definition of styles without breaking old
22  *  Glk libraries.
23  * </para></note>
24  */
25 void
26 glk_set_style(glui32 styl)
27 {
28         ChimaraGlkPrivate *glk_data = g_private_get(glk_data_key);
29         g_return_if_fail(glk_data->current_stream != NULL);
30         glk_set_style_stream(glk_data->current_stream, styl);
31 }
32
33 /* Internal function: mapping from style enum to tag name */
34 static gchar *
35 get_tag_name(glui32 style)
36 {
37         switch(style) {
38                 case style_Normal: return "normal";
39                 case style_Emphasized: return "emphasized";
40                 case style_Preformatted: return "preformatted";
41                 case style_Header: return "header";
42                 case style_Subheader: return "subheader";
43                 case style_Alert: return "alert";
44                 case style_Note: return "note";
45                 case style_BlockQuote: return "block-quote";
46                 case style_Input: return "input";
47                 case style_User1: return "user1";
48                 case style_User2: return "user2";
49         }
50
51         WARNING("Unsupported style");
52         return "normal";
53 }
54
55 /** 
56  * glk_set_style_stream:
57  * @str: Output stream to change the style of
58  * @styl: The style to apply
59  *
60  * This changes the style of the stream @str. See glk_set_style().
61  */
62 void
63 glk_set_style_stream(strid_t str, glui32 styl) {
64         str->style = get_tag_name(styl);
65 }
66
67 /* Internal function: call this to initialize the default styles to a textbuffer. */
68 void
69 style_init_textbuffer(GtkTextBuffer *buffer)
70 {
71         g_return_if_fail(buffer != NULL);
72
73         if( G_UNLIKELY(!chimara_style_initialized) ) {
74                 style_init();
75         }
76
77         ChimaraGlkPrivate *glk_data = g_private_get(glk_data_key);
78         g_hash_table_foreach(glk_data->default_styles, style_add_tag_to_textbuffer, gtk_text_buffer_get_tag_table(buffer));
79 }
80
81 static void
82 style_add_tag_to_textbuffer(gpointer key, gpointer tag, gpointer tag_table)
83 {
84         gtk_text_tag_table_add(tag_table, tag);
85 }
86
87 void
88 style_init()
89 {
90         ChimaraGlkPrivate *glk_data = g_private_get(glk_data_key);
91         GtkTextTag *tag;
92
93         /* Create the CSS file scanner */
94         GScanner *scanner = g_scanner_new(NULL);
95         int f = open(glk_data->css_file, O_RDONLY);
96         g_return_if_fail(f != -1);
97         g_scanner_input_file(scanner, f);
98         scanner->input_name = glk_data->css_file;
99         scanner->config->cset_identifier_first = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ#";
100         scanner->config->cset_identifier_nth = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ-_0123456789";
101         scanner->config->symbol_2_token = TRUE;
102         scanner->config->cpair_comment_single = NULL;
103
104         /* Initialise the default styles */
105         g_hash_table_insert(glk_data->default_styles, "normal", gtk_text_tag_new("normal"));
106
107         tag = gtk_text_tag_new("emphasized");
108         g_object_set(tag, "style", PANGO_STYLE_ITALIC, "style-set", TRUE, NULL);
109         g_hash_table_insert(glk_data->default_styles, "emphasized", tag);
110
111         tag = gtk_text_tag_new("preformatted");
112         g_object_set(tag, "font-desc", glk_data->monospace_font_desc, NULL);
113         g_hash_table_insert(glk_data->default_styles, "preformatted", tag);
114
115         tag = gtk_text_tag_new("header");
116         g_object_set(tag, "size-points", 18.0, "weight", PANGO_WEIGHT_BOLD, NULL);
117         g_hash_table_insert(glk_data->default_styles, "header", tag);
118
119         tag = gtk_text_tag_new("subheader");
120         g_object_set(tag, "size-points", 14.0, "weight", PANGO_WEIGHT_BOLD, NULL);
121         g_hash_table_insert(glk_data->default_styles, "subheader", tag);
122
123         tag = gtk_text_tag_new("alert");
124         g_object_set(tag, "foreground", "#aa0000", "weight", PANGO_WEIGHT_BOLD, NULL);
125         g_hash_table_insert(glk_data->default_styles, "alert", tag);
126
127         tag = gtk_text_tag_new("note");
128         g_object_set(tag, "foreground", "#aaaa00", "weight", PANGO_WEIGHT_BOLD, NULL);
129         g_hash_table_insert(glk_data->default_styles, "note", tag);
130
131         tag = gtk_text_tag_new("block-quote");
132         g_object_set(tag, "justification", GTK_JUSTIFY_CENTER, "style", PANGO_STYLE_ITALIC, NULL);
133         g_hash_table_insert(glk_data->default_styles, "block-quote", tag);
134
135         g_hash_table_insert(glk_data->default_styles, "input", gtk_text_tag_new("input"));
136         g_hash_table_insert(glk_data->default_styles, "user1", gtk_text_tag_new("user1"));
137         g_hash_table_insert(glk_data->default_styles, "user2", gtk_text_tag_new("user2"));
138
139         /* Run the scanner over the CSS file */
140         while( g_scanner_peek_next_token(scanner) != G_TOKEN_EOF) {
141                 if( !style_accept_style_identifier(scanner) )
142                         break;
143         }
144
145         g_scanner_destroy(scanner);
146 }
147
148 static gboolean
149 style_accept(GScanner *scanner, GTokenType token)
150 {
151         if( g_scanner_get_next_token(scanner) != token ) {
152                 g_scanner_unexp_token(scanner, token, NULL, NULL, NULL, "CSS Error", 1);
153                 return FALSE;
154         } else {
155                 return TRUE;
156         }
157 }
158
159 static gboolean
160 style_accept_style_identifier(GScanner *scanner)
161 {
162         ChimaraGlkPrivate *glk_data = g_private_get(glk_data_key);
163
164         GtkTextTag *current_tag;
165         GTokenType token = g_scanner_get_next_token(scanner);
166         GTokenValue value = g_scanner_cur_value(scanner);
167
168         if(token != G_TOKEN_IDENTIFIER) {
169                 g_scanner_error(scanner, "CSS Error: style identifier expected");
170                 return FALSE;
171         }
172
173         printf("Identifier: %s\n", value.v_identifier);
174         current_tag = g_hash_table_lookup(glk_data->default_styles, value.v_identifier);
175
176         if(current_tag == NULL) {
177                 g_scanner_error(scanner, "CSS Error: invalid style identifier");
178                 return FALSE;
179         }
180
181         if( !style_accept(scanner, '{') )
182                 return FALSE;
183
184         while( g_scanner_peek_next_token(scanner) != '}') {
185                 if( !style_accept_style_hint(scanner, current_tag) )
186                         return FALSE;
187         }
188                 
189         if( !style_accept(scanner, '}') )
190                 return FALSE;
191
192         return TRUE;
193 }
194
195 static gboolean
196 style_accept_style_hint(GScanner *scanner, GtkTextTag *current_tag)
197 {
198         GTokenType token = g_scanner_get_next_token(scanner);
199         GTokenValue value = g_scanner_cur_value(scanner);
200         gchar *hint;
201
202         if(token != G_TOKEN_IDENTIFIER) {
203                 g_scanner_error(scanner, "CSS Error: style hint expected");
204                 return FALSE;
205         }
206
207         hint = g_strdup(value.v_identifier);
208         printf("Hint: %s\n", hint);
209
210         if( !style_accept(scanner, ':') )
211                 return FALSE;
212
213         token = g_scanner_get_next_token(scanner);
214         value = g_scanner_cur_value(scanner);
215
216         if( !strcmp(hint, "font-family") ) {
217                 if(token != G_TOKEN_STRING) {
218                         g_scanner_error(scanner, "CSS Error: string expected");
219                         return FALSE;
220                 }
221                 g_object_set(current_tag, "family", value.v_string, "family-set", TRUE, NULL);
222         }
223         else if( !strcmp(hint, "font-weight") ) {
224                 if(token != G_TOKEN_IDENTIFIER) {
225                         g_scanner_error(scanner, "CSS Error: bold/normal expected");
226                         return FALSE;
227                 }
228
229                 if( !strcmp(value.v_identifier, "bold") )
230                         g_object_set(current_tag, "weight", PANGO_WEIGHT_BOLD, "weight-set", TRUE, NULL);
231                 else if( !strcmp(value.v_identifier, "normal") )
232                         g_object_set(current_tag, "weight", PANGO_WEIGHT_NORMAL, "weight-set", TRUE, NULL);
233                 else {
234                         g_scanner_error(scanner, "CSS Error: bold/normal expected");
235                         return FALSE;
236                 }
237         }
238         else if( !strcmp(hint, "font-style") ) {
239                 if(token != G_TOKEN_IDENTIFIER) {
240                         g_scanner_error(scanner, "CSS Error: italic/normal expected");
241                         return FALSE;
242                 }
243
244                 if( !strcmp(value.v_identifier, "italic") )
245                         g_object_set(current_tag, "style", PANGO_STYLE_ITALIC, "style-set", TRUE, NULL);
246                 else if( !strcmp(value.v_identifier, "normal") )
247                         g_object_set(current_tag, "style", PANGO_STYLE_NORMAL, "style-set", TRUE, NULL);
248                 else {
249                         g_scanner_error(scanner, "CSS Error: italic/normal expected");
250                         return FALSE;
251                 }
252         }
253         else if( !strcmp(hint, "font-size") ) {
254                 if(token == G_TOKEN_INT) 
255                         g_object_set(current_tag, "size-points", (float)value.v_int, "size-set", TRUE, NULL);
256                 else if(token == G_TOKEN_FLOAT)
257                         g_object_set(current_tag, "size-points", value.v_float, "size-set", TRUE, NULL);
258                 else {
259                         g_scanner_error(scanner, "CSS Error: integer or float expected");
260                         return FALSE;
261                 }
262         }
263         else if( !strcmp(hint, "color") ) {
264                 if(token != G_TOKEN_IDENTIFIER) {
265                         g_scanner_error(scanner, "CSS Error: hex color expected");
266                         return FALSE;
267                 }
268                 g_object_set(current_tag, "foreground", value.v_identifier, "foreground-set", TRUE, NULL);
269         }
270         else if( !strcmp(hint, "background-color") ) {
271                 if(token != G_TOKEN_IDENTIFIER) {
272                         g_scanner_error(scanner, "CSS Error: hex color expected");
273                         return FALSE;
274                 }
275                 g_object_set(current_tag, "background", value.v_identifier, "background-set", TRUE, NULL);
276         }
277         else if( !strcmp(hint, "text-align") ) {
278                 if(token != G_TOKEN_IDENTIFIER) {
279                         g_scanner_error(scanner, "CSS Error: left/right/center expected");
280                         return FALSE;
281                 }
282                 
283                 if( !strcmp(value.v_identifier, "left") )
284                         g_object_set(current_tag, "justification", GTK_JUSTIFY_LEFT, "justification-set", TRUE, NULL);
285                 else if( !strcmp(value.v_identifier, "right") )
286                         g_object_set(current_tag, "justification", GTK_JUSTIFY_RIGHT, "justification-set", TRUE, NULL);
287                 else if( !strcmp(value.v_identifier, "center") )
288                         g_object_set(current_tag, "justification", GTK_JUSTIFY_CENTER, "justification-set", TRUE, NULL);
289                 else {
290                         g_scanner_error(scanner, "CSS Error: left/right/center expected");
291                         return FALSE;
292                 }
293         }
294         else if( !strcmp(hint, "margin-left") ) {
295                 if(token != G_TOKEN_INT) {
296                         g_scanner_error(scanner, "CSS Error: integer expected");
297                         return FALSE;
298                 }
299                 g_object_set(current_tag, "left-margin", value.v_int, "left-margin-set", TRUE, NULL);
300         }
301         else if( !strcmp(hint, "margin-right") ) {
302                 if(token != G_TOKEN_INT) {
303                         g_scanner_error(scanner, "CSS Error: integer expected");
304                         return FALSE;
305                 }
306                 g_object_set(current_tag, "right-margin", value.v_int, "right-margin-set", TRUE, NULL);
307         }
308         else if( !strcmp(hint, "margin-top") ) {
309                 if(token != G_TOKEN_INT) {
310                         g_scanner_error(scanner, "CSS Error: integer expected");
311                         return FALSE;
312                 }
313                 g_object_set(current_tag, "pixels-above-lines", value.v_int, "pixels-above-lines-set", TRUE, NULL);
314         }
315         else if( !strcmp(hint, "margin-bottom") ) {
316                 if(token != G_TOKEN_INT) {
317                         g_scanner_error(scanner, "CSS Error: integer expected");
318                         return FALSE;
319                 }
320                 g_object_set(current_tag, "pixels-below-lines", value.v_int, "pixels-below-lines-set", TRUE, NULL);
321         }
322                 
323         else {
324                 g_scanner_error(scanner, "CSS Error: invalid style hint %s", hint);
325                 return FALSE;
326         }
327
328         if( !style_accept(scanner, ';') )
329                 return FALSE;
330
331         return TRUE;
332 }
333
334 static void
335 color_format(glui32 val, gchar *buffer)
336 {
337         sprintf(buffer, "#%02X%02X%02X",
338                 ((val & 0xff0000) >> 16),
339                 ((val & 0x00ff00) >> 8),
340                 (val & 0x0000ff)
341         );
342 }
343
344 /* Internal function: changes a GTK tag to correspond with the given style. */
345 static void
346 apply_stylehint_to_tag(GtkTextTag *tag, glui32 hint, glsi32 val)
347 {
348         g_return_if_fail(tag != NULL);
349
350         ChimaraGlkPrivate *glk_data = g_private_get(glk_data_key);
351         GObject *tag_object = G_OBJECT(tag);
352         gint reverse_color = 0;
353
354         /* FIXME where should we keep track of this?
355         g_object_get(tag, "reverse_color", &reverse_color, NULL);
356         */
357
358         int i = 0;
359         gchar color[20];
360         switch(hint) {
361         case stylehint_Indentation:
362                 g_object_set(tag_object, "left_margin", 5*val, NULL);
363                 g_object_set(tag_object, "right_margin", 5*val, NULL);
364                 break;
365         
366         case stylehint_ParaIndentation:
367                 g_object_set(tag_object, "indent", 5*val, NULL);
368                 break;
369
370         case stylehint_Justification:
371                 switch(val) {
372                         case stylehint_just_LeftFlush:  i = GTK_JUSTIFY_LEFT; break;
373                         case stylehint_just_LeftRight:  i = GTK_JUSTIFY_FILL; break;
374                         case stylehint_just_Centered:   i = GTK_JUSTIFY_CENTER; break;
375                         case stylehint_just_RightFlush: i = GTK_JUSTIFY_RIGHT; break;
376                         default: 
377                                 WARNING("Unknown justification");
378                                 i = GTK_JUSTIFY_LEFT;
379                 }
380                 g_object_set(tag_object, "justification", i, NULL);
381                 break;
382
383         case stylehint_Weight:
384                 switch(val) {
385                         case -1: i = PANGO_WEIGHT_LIGHT; break;
386                         case  0: i = PANGO_WEIGHT_NORMAL; break;
387                         case  1: i = PANGO_WEIGHT_BOLD; break;
388                         default: WARNING("Unknown font weight");
389                 }
390                 g_object_set(tag_object, "weight", i, NULL);
391                 break;
392
393         case stylehint_Size:
394                 g_object_set(tag_object, "size", 14+(2*val), NULL);
395                 break;
396
397         case stylehint_Oblique:
398                 g_object_set(tag_object, "style", val ? PANGO_STYLE_ITALIC : PANGO_STYLE_NORMAL, NULL);
399                 break;
400
401         case stylehint_Proportional:
402                 g_object_set(tag_object, "font-desc", val ? glk_data->default_font_desc : glk_data->monospace_font_desc, NULL);
403                 break;
404
405         case stylehint_TextColor:
406                 color_format(val, color);
407
408                 if(!reverse_color)
409                         g_object_set(tag_object, "foreground", color, NULL);
410                 else
411                         g_object_set(tag_object, "background", color, NULL);
412
413                 break;
414
415         case stylehint_BackColor:
416                 color_format(val, color);
417
418                 if(!reverse_color)
419                         g_object_set(tag_object, "background", color, NULL);
420                 else
421                         g_object_set(tag_object, "foreground", color, NULL);
422
423                 break;
424
425         case stylehint_ReverseColor:
426                 if(reverse_color != val) {
427                         /* Flip the fore- and background colors */
428                         gchar* foreground_color;
429                         gchar* background_color;
430                         g_object_get(tag_object, "foreground", &foreground_color, NULL);
431                         g_object_get(tag_object, "background", &background_color, NULL);
432                         g_object_set(tag_object, "foreground", background_color, NULL);
433                         g_object_set(tag_object, "background", foreground_color, NULL);
434                         g_free(foreground_color);
435                         g_free(background_color);
436                 }
437                 break;
438
439         default:
440                 WARNING("Unknown style hint");
441         }
442 }
443
444 /**
445  * glk_stylehint_set:
446  * @wintype: The window type to set a style hint on, or %wintype_AllTypes.
447  * @styl: The style to set a hint for.
448  * @hint: The type of style hint, one of the <code>stylehint_</code> constants.
449  * @val: The style hint. The meaning of this depends on @hint.
450  *
451  * Sets a hint about the appearance of one style for a particular type of 
452  * window. You can also set wintype to %wintype_AllTypes, which sets a hint for 
453  * all types of window.
454  * <note><para>
455  *  There is no equivalent constant to set a hint for all styles of a single 
456  *  window type.
457  * </para></note>
458  */
459 void
460 glk_stylehint_set(glui32 wintype, glui32 styl, glui32 hint, glsi32 val)
461 {
462         gchar *tag_name = get_tag_name(styl);
463
464         /* Iterate over all the window and update their styles if nessecary */
465         winid_t win = glk_window_iterate(NULL, NULL);
466         while(win != NULL) {
467                 if(wintype != wintype_TextBuffer)
468                         continue; /* FIXME: add support for text grid windows */
469
470                 if(wintype == wintype_AllTypes || glk_window_get_type(win) == wintype) {
471                         GtkWidget *textview = win->widget;
472                         GtkTextBuffer *textbuffer = gtk_text_view_get_buffer( GTK_TEXT_VIEW(textview) );
473                         GtkTextTagTable *table = gtk_text_buffer_get_tag_table(textbuffer);
474                         GtkTextTag *to_change = gtk_text_tag_table_lookup(table, tag_name);
475
476                         apply_stylehint_to_tag(to_change, hint, val);
477                 }
478         }
479 }
480
481 void
482 glk_stylehint_clear(glui32 wintype, glui32 styl, glui32 hint)
483 {
484 }
485
486 glui32
487 glk_style_distinguish(winid_t win, glui32 styl1, glui32 styl2)
488 {
489         return styl1 != styl2;
490 }
491
492 glui32
493 glk_style_measure(winid_t win, glui32 styl, glui32 hint, glui32 *result)
494 {
495         return FALSE;
496 }