Fix for #453 (Menu frame lingers)
[supertux.git] / src / textscroller.cpp
1 //  $Id$
2 //
3 //  SuperTux
4 //  Copyright (C) 2006 Matthias Braun <matze@braunis.de>
5 //
6 //  This program is free software; you can redistribute it and/or
7 //  modify it under the terms of the GNU General Public License
8 //  as published by the Free Software Foundation; either version 2
9 //  of the License, or (at your option) any later version.
10 //
11 //  This program is distributed in the hope that it will be useful,
12 //  but WITHOUT ANY WARRANTY; without even the implied warranty of
13 //  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14 //  GNU General Public License for more details.
15 //
16 //  You should have received a copy of the GNU General Public License
17 //  along with this program; if not, write to the Free Software
18 //  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
19 //  02111-1307, USA.
20 #include <config.h>
21
22 #include "textscroller.hpp"
23
24 #include <stdexcept>
25 #include "log.hpp"
26 #include "mainloop.hpp"
27 #include "resources.hpp"
28 #include "video/font.hpp"
29 #include "video/drawing_context.hpp"
30 #include "video/surface.hpp"
31 #include "gui/menu.hpp"
32 #include "lisp/parser.hpp"
33 #include "lisp/lisp.hpp"
34 #include "audio/sound_manager.hpp"
35 #include "main.hpp"
36 #include "fadeout.hpp"
37 #include "control/joystickkeyboardcontroller.hpp"
38
39 static const float DEFAULT_SPEED = 20;
40 static const float LEFT_BORDER = 50;
41 static const float SCROLL = 60;
42 static const float ITEMS_SPACE = 4;
43
44 TextScroller::TextScroller(const std::string& filename)
45 {
46   defaultspeed = DEFAULT_SPEED;
47   speed = defaultspeed;
48
49   std::string text;
50   std::string background_file;
51
52   lisp::Parser parser;
53   try {
54     const lisp::Lisp* root = parser.parse(filename);
55
56     const lisp::Lisp* text_lisp = root->get_lisp("supertux-text");
57     if(!text_lisp)
58       throw std::runtime_error("File isn't a supertux-text file");
59
60     if(!text_lisp->get("text", text))
61       throw std::runtime_error("file doesn't contain a text field");
62     if(!text_lisp->get("background", background_file))
63       throw std::runtime_error("file doesn't contain a background file");
64     text_lisp->get("speed", defaultspeed);
65     text_lisp->get("music", music);
66   } catch(std::exception& e) {
67     std::ostringstream msg;
68     msg << "Couldn't load file '" << filename << "': " << e.what() << std::endl;
69     throw std::runtime_error(msg.str());
70   }
71
72   // Split text string lines into a vector
73   lines = InfoBoxLine::split(text, SCREEN_WIDTH - 2*LEFT_BORDER);
74
75   // load background image
76   background.reset(new Surface("images/background/" + background_file));
77
78   scroll = 0;
79   fading = false;
80 }
81
82 TextScroller::~TextScroller()
83 {
84   for(std::vector<InfoBoxLine*>::iterator i = lines.begin(); i != lines.end(); i++) delete *i;
85 }
86
87 void
88 TextScroller::setup()
89 {
90   sound_manager->play_music(music);
91 }
92
93 void
94 TextScroller::update(float elapsed_time)
95 {
96   if(main_controller->hold(Controller::UP)) {
97     speed = -defaultspeed*5;
98   } else if(main_controller->hold(Controller::DOWN)) {
99     speed = defaultspeed*5;
100   } else {
101     speed = defaultspeed;
102   }
103   if(main_controller->pressed(Controller::JUMP)
104       || main_controller->pressed(Controller::ACTION)
105       || main_controller->pressed(Controller::MENU_SELECT))
106     scroll += SCROLL;
107   if(main_controller->pressed(Controller::PAUSE_MENU)) {
108     main_loop->exit_screen(new FadeOut(0.5));
109   }
110
111   scroll += speed * elapsed_time;
112
113   if(scroll < 0)
114     scroll = 0;
115 }
116
117 void
118 TextScroller::draw(DrawingContext& context)
119 {
120   context.draw_filled_rect(Vector(0, 0), Vector(SCREEN_WIDTH, SCREEN_HEIGHT),
121       Color(0.6f, 0.7f, 0.8f, 0.5f), 0);
122   context.draw_surface(background.get(), Vector(SCREEN_WIDTH/2 - background->get_width()/2 , SCREEN_HEIGHT/2 - background->get_height()/2), 0);
123
124   float y = SCREEN_HEIGHT - scroll;
125   for(size_t i = 0; i < lines.size(); i++) {
126     if (y + lines[i]->get_height() >= 0 && SCREEN_HEIGHT - y >= 0) {
127         lines[i]->draw(context, Rect(LEFT_BORDER, y, SCREEN_WIDTH - 2*LEFT_BORDER, y), LAYER_GUI);
128     }
129
130     y += lines[i]->get_height();
131   }
132
133   if(y < 0 && !fading ) {
134     fading = true;
135     main_loop->exit_screen(new FadeOut(0.5));
136   }
137 }
138
139 InfoBox::InfoBox(const std::string& text)
140   : firstline(0)
141 {
142   // Split text string lines into a vector
143   lines = InfoBoxLine::split(text, 400);
144
145   try
146   {
147     // get the arrow sprites
148     arrow_scrollup   = new Surface("images/engine/menu/scroll-up.png");
149     arrow_scrolldown = new Surface("images/engine/menu/scroll-down.png");
150   }
151   catch (std::exception& e)
152   {
153     log_warning << "Could not load scrolling images: " << e.what() << std::endl;
154     arrow_scrollup = 0;
155     arrow_scrolldown = 0;
156   }
157 }
158
159 InfoBox::~InfoBox()
160 {
161   for(std::vector<InfoBoxLine*>::iterator i = lines.begin();
162       i != lines.end(); i++)
163     delete *i;
164   delete arrow_scrollup;
165   delete arrow_scrolldown;
166 }
167
168 void
169 InfoBox::draw(DrawingContext& context)
170 {
171   float x1 = SCREEN_WIDTH/2-200;
172   float y1 = SCREEN_HEIGHT/2-200;
173   float width = 400;
174   float height = 200;
175
176   context.draw_filled_rect(Vector(x1, y1), Vector(width, height),
177       Color(0.6f, 0.7f, 0.8f, 0.5f), LAYER_GUI-1);
178
179   float y = y1;
180   bool linesLeft = false;
181   for(size_t i = firstline; i < lines.size(); ++i) {
182     if(y >= y1 + height) {
183       linesLeft = true;
184       break;
185     }
186
187     lines[i]->draw(context, Rect(x1, y, x1+width, y), LAYER_GUI);
188     y += lines[i]->get_height();
189   }
190
191   {
192     // draw the scrolling arrows
193     if (arrow_scrollup && firstline > 0)
194       context.draw_surface(arrow_scrollup,
195       Vector( x1 + width  - arrow_scrollup->get_width(),  // top-right corner of box
196               y1), LAYER_GUI);
197
198     if (arrow_scrolldown && linesLeft && firstline < lines.size()-1)
199       context.draw_surface(arrow_scrolldown,
200       Vector( x1 + width  - arrow_scrolldown->get_width(),  // bottom-light corner of box
201               y1 + height - arrow_scrolldown->get_height()),
202               LAYER_GUI);
203   }
204 }
205
206 void
207 InfoBox::scrollup()
208 {
209   if(firstline > 0)
210     firstline--;
211 }
212
213 void
214 InfoBox::scrolldown()
215 {
216   if(firstline < lines.size()-1)
217     firstline++;
218 }
219
220 void
221 InfoBox::pageup()
222 {
223 }
224
225 void
226 InfoBox::pagedown()
227 {
228 }
229
230 namespace {
231 Font* get_font_by_format_char(char format_char) {
232   switch(format_char)
233   {
234     case ' ':
235       return small_font;
236       break;
237     case '-':
238       return big_font;
239       break;
240     case '\t':
241     case '*':
242     case '#':
243     case '!':
244       return normal_font;
245       break;
246     default:
247       return normal_font;
248       log_warning << "Unknown format_char: '" << format_char << "'" << std::endl;
249       break;
250   }
251 }
252
253 Color get_color_by_format_char(char format_char) {
254   switch(format_char)
255   {
256     case ' ':
257       return TextScroller::small_color;
258       break;
259     case '-':
260       return TextScroller::heading_color;
261       break;
262     case '*':
263       return TextScroller::reference_color;
264     case '\t':
265     case '#':
266     case '!':
267       return TextScroller::normal_color;
268       break;
269     default:
270       return Color(0,0,0);
271       log_warning << "Unknown format_char: '" << format_char << "'" << std::endl;
272       break;
273   }
274 }
275
276 InfoBoxLine::LineType get_linetype_by_format_char(char format_char) {
277   switch(format_char)
278   {
279     case ' ':
280       return InfoBoxLine::SMALL;
281       break;
282     case '\t':
283       return InfoBoxLine::NORMAL;
284       break;
285     case '-':
286       return InfoBoxLine::HEADING;
287       break;
288     case '*':
289       return InfoBoxLine::REFERENCE;
290       break;
291     case '#':
292       return InfoBoxLine::NORMAL_LEFT;
293       break;
294     case '!':
295       return InfoBoxLine::IMAGE;
296       break;
297     default:
298       return InfoBoxLine::SMALL;
299       log_warning << "Unknown format_char: '" << format_char << "'" << std::endl;
300       break;
301   }
302 }
303 }
304
305 InfoBoxLine::InfoBoxLine(char format_char, const std::string& text) : lineType(NORMAL), font(normal_font), text(text), image(0)
306 {
307   font = get_font_by_format_char(format_char);
308   lineType = get_linetype_by_format_char(format_char);
309   color = get_color_by_format_char(format_char);
310   if (lineType == IMAGE) image = new Surface(text);
311 }
312
313 InfoBoxLine::~InfoBoxLine()
314 {
315   delete image;
316 }
317
318 const std::vector<InfoBoxLine*>
319 InfoBoxLine::split(const std::string& text, float width)
320 {
321   std::vector<InfoBoxLine*> lines;
322
323   std::string::size_type i = 0;
324   std::string::size_type l;
325   char format_char = '#';
326   while(i < text.size()) {
327     // take care of empty lines - represent them as blank lines of normal text
328     if (text[i] == '\n') {
329       lines.push_back(new InfoBoxLine('\t', ""));
330       i++;
331       continue;
332     }
333
334     // extract the format_char
335     format_char = text[i];
336     i++;
337     if (i >= text.size()) break;
338
339     // extract one line
340     l = text.find("\n", i);
341     if (l == std::string::npos) l=text.size();
342     std::string s = text.substr(i, l-i);
343     i = l+1;
344
345     // if we are dealing with an image, just store the line
346     if (format_char == '!') {
347       lines.push_back(new InfoBoxLine(format_char, s));
348       continue;
349     }
350
351     // append wrapped parts of line into list
352     std::string overflow;
353     do {
354       Font* font = get_font_by_format_char(format_char);
355       std::string s2 = s;
356       if (font) s2 = font->wrap_to_width(s2, width, &overflow);
357       lines.push_back(new InfoBoxLine(format_char, s2));
358       s = overflow;
359     } while (s.length() > 0);
360   }
361
362   return lines;
363 }
364
365 void
366 InfoBoxLine::draw(DrawingContext& context, const Rect& bbox, int layer)
367 {
368   Vector position = bbox.p1;
369   switch (lineType) {
370     case IMAGE:
371       context.draw_surface(image, Vector( (bbox.p1.x + bbox.p2.x - image->get_width()) / 2, position.y), layer);
372       break;
373     case NORMAL_LEFT:
374       context.draw_text(font, text, Vector(position.x, position.y), ALIGN_LEFT, layer, color);
375       break;
376     default:
377       context.draw_text(font, text, Vector((bbox.p1.x + bbox.p2.x) / 2, position.y), ALIGN_CENTER, layer, color);
378       break;
379   }
380 }
381
382 float
383 InfoBoxLine::get_height()
384 {
385   switch (lineType) {
386     case IMAGE:
387       return image->get_height() + ITEMS_SPACE;
388     case NORMAL_LEFT:
389       return font->get_height() + ITEMS_SPACE;
390     default:
391       return font->get_height() + ITEMS_SPACE;
392   }
393 }