|
|
@@ -6,9 +6,15 @@
|
|
|
#include "zori_widget.h"
|
|
|
#include "zori_caption.h"
|
|
|
#include "zori_longtext.h"
|
|
|
+#include "zori_page.h"
|
|
|
+#include <math.h>
|
|
|
|
|
|
|
|
|
#define ZORI_LONGTEXT_LINE_POS_MAX 99999
|
|
|
+#define ZORI_LONGTEXT_ANIMATION_CYCLE_TIME 4.0
|
|
|
+#define ZORI_LONGTEXT_PAUSE_MARKER_DAMPER 2.0
|
|
|
+#define ZORI_LONGTEXT_PAUSE_MARKER_SCALE 0.75
|
|
|
+#define ZORI_LONGTEXT_DEFAULT_DELAY 0.2
|
|
|
|
|
|
|
|
|
struct zori_longtext * zori_widget_to_longtext(struct zori_widget * widget) {
|
|
|
@@ -17,17 +23,43 @@ struct zori_longtext * zori_widget_to_longtext(struct zori_widget * widget) {
|
|
|
}
|
|
|
|
|
|
|
|
|
+
|
|
|
+static bool
|
|
|
+zori_longtext_calculate_lines_aid(int line_num, const zori_string *line, void * extra) {
|
|
|
+ struct zori_longtext * longtext = extra;
|
|
|
+ longtext->state.total = line_num + 1;
|
|
|
+ return true;
|
|
|
+}
|
|
|
+
|
|
|
+/** Calculates the amount of lines needed for the longtext as per al_do_multiline_text
|
|
|
+ * The value is set in longtext->state.total and returned;
|
|
|
+ */
|
|
|
+
|
|
|
+int zori_longtext_calculate_lines(struct zori_longtext * longtext) {
|
|
|
+ double width = longtext->widget.inner.size.x;
|
|
|
+ longtext->state.total = 0;
|
|
|
+ al_do_multiline_ustr(zori_widget_font(&longtext->widget), width,
|
|
|
+ longtext->text, zori_longtext_calculate_lines_aid, longtext);
|
|
|
+ return longtext->state.total;
|
|
|
+}
|
|
|
+
|
|
|
struct zori_longtext *
|
|
|
zori_longtext_set(struct zori_longtext * longtext, const zori_string * text) {
|
|
|
if (longtext) {
|
|
|
if (longtext->text) {
|
|
|
ustr_free(longtext->text);
|
|
|
longtext->text = NULL;
|
|
|
+ longtext->state.total = 0;
|
|
|
}
|
|
|
if (text) {
|
|
|
longtext->text = ustr_dup(text);
|
|
|
if (!longtext->text) {
|
|
|
- LOG_ERROR("Out of memory in longtext setup.");
|
|
|
+ longtext->state.total = 0;
|
|
|
+ LOG_ERROR("Out of memory in longtext setup.\n");
|
|
|
+ return NULL;
|
|
|
+ } else {
|
|
|
+ zori_longtext_calculate_lines(longtext);
|
|
|
+ LOG_DEBUG("Longtext lines: %d\n", longtext->state.total);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
@@ -53,40 +85,74 @@ void zori_longtext_done(struct zori_longtext * longtext) {
|
|
|
zori_longtext_set(longtext, NULL);
|
|
|
}
|
|
|
|
|
|
+/** Gets the number of lines in one page. Always returns at least 1. */
|
|
|
+int zori_longtext_page_lines(struct zori_longtext * longtext) {
|
|
|
+ if (!longtext) return 1;
|
|
|
+ if (longtext->settings.lines > 1) {
|
|
|
+ return longtext->settings.lines;
|
|
|
+ }
|
|
|
+ return 1;
|
|
|
+}
|
|
|
+
|
|
|
|
|
|
-/** Gets the current text page for a longtext. */
|
|
|
+/** Sets the number of lines in one page. Sets at least 1. */
|
|
|
+int zori_longtext_page_lines_(struct zori_longtext * longtext, int pl) {
|
|
|
+ if (!longtext) return -1;
|
|
|
+ if (pl < 1) {
|
|
|
+ pl = 1;
|
|
|
+ }
|
|
|
+ longtext->settings.lines = pl;
|
|
|
+ return longtext->settings.lines;
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
+/** Gets the current text page for a longtext. Page 0 is the first page, etc.*/
|
|
|
int zori_longtext_page(struct zori_longtext * longtext) {
|
|
|
+ int pl = 1;
|
|
|
if (!longtext) return -2;
|
|
|
- return longtext->line_start / longtext->page_lines;
|
|
|
+ return longtext->state.page;
|
|
|
}
|
|
|
|
|
|
|
|
|
-/** Gets the last page number for a longtext or negative on error. */
|
|
|
+/** Gets the last page number (inclusive) for a longtext or negative on error. */
|
|
|
int zori_longtext_last_page(struct zori_longtext * longtext) {
|
|
|
+ int pl = 1;
|
|
|
if (!longtext) return -2;
|
|
|
- return longtext->line_max / longtext->page_lines;
|
|
|
+ pl = zori_longtext_page_lines(longtext);
|
|
|
+ return longtext->state.total / pl;
|
|
|
}
|
|
|
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
/** Advances long text to the given page. Automatically unpauses as well. */
|
|
|
int zori_longtext_page_(struct zori_longtext * longtext, int page) {
|
|
|
+ int pl = 1;
|
|
|
+ int line = 1;
|
|
|
+ if (!longtext) return -2;
|
|
|
if (!longtext) return -2;
|
|
|
if (page < 0) return -3;
|
|
|
- int line = page * longtext->page_lines;
|
|
|
+ pl = zori_longtext_page_lines(longtext);
|
|
|
+ line = page * pl;
|
|
|
/* Check for page overflow. */
|
|
|
- if (line >= longtext->line_max) {
|
|
|
- return -5;
|
|
|
+ LOG_NOTE("Selecting page nr %d, line nr %d, limit of %d", page, line, longtext->state.total);
|
|
|
+
|
|
|
+
|
|
|
+ if (line >= longtext->state.total) {
|
|
|
+ LOG_WARNING("Cannot select page nr %d, line nr %d, more than limit of %d",
|
|
|
+ page, line, longtext->state.total);
|
|
|
+ return -5;
|
|
|
}
|
|
|
|
|
|
- longtext->paused = false;
|
|
|
- longtext->line_start = line;
|
|
|
+ longtext->state.paused = false;
|
|
|
+ longtext->state.line = line;
|
|
|
+ longtext->state.page = page;
|
|
|
|
|
|
/* Negative delay is instant display. */
|
|
|
- if (longtext->delay < 0) {
|
|
|
- longtext->line_stop = longtext->line_start + longtext->page_lines;
|
|
|
- longtext->line_pos = ZORI_LONGTEXT_LINE_POS_MAX;
|
|
|
+ if (longtext->settings.delay < 0) {
|
|
|
+ longtext->state.position = ZORI_LONGTEXT_LINE_POS_MAX;
|
|
|
} else {
|
|
|
- longtext->line_stop = longtext->line_start + 1;
|
|
|
- longtext->line_pos = 0;
|
|
|
+ longtext->state.position = 0;
|
|
|
}
|
|
|
return page;
|
|
|
}
|
|
|
@@ -95,8 +161,8 @@ int zori_longtext_page_(struct zori_longtext * longtext, int page) {
|
|
|
* false if not (more text to display) */
|
|
|
int zori_longtext_at_end(struct zori_longtext * longtext) {
|
|
|
if (!longtext) return FALSE;
|
|
|
- return ((longtext->line_stop >= longtext->line_max) &&
|
|
|
- (longtext->line_pos >= ZORI_LONGTEXT_LINE_POS_MAX));
|
|
|
+ return ((longtext->state.line >= longtext->state.total)
|
|
|
+ /* && (longtext->state.position >= ZORI_LONGTEXT_LINE_POS_MAX) */);
|
|
|
}
|
|
|
|
|
|
|
|
|
@@ -105,35 +171,58 @@ int zori_longtext_at_end(struct zori_longtext * longtext) {
|
|
|
* updating scrolled/partial text for Longtexts.
|
|
|
*/
|
|
|
static bool
|
|
|
-zori_longtext_update_custom_partial_text(int line_num, const char *line, int size, void * extra) {
|
|
|
+zori_longtext_update_custom_partial_text(int line_num, const zori_text *line, void * extra) {
|
|
|
struct zori_longtext * longtext = extra;
|
|
|
- longtext->line_max = line_num;
|
|
|
-
|
|
|
+ int last_line = line_num;
|
|
|
+ int start_line = longtext->state.page * longtext->settings.lines;
|
|
|
+ int stop_line = (longtext->state.page + 1) * longtext->settings.lines;
|
|
|
+ int line_length = al_ustr_length(line);
|
|
|
+
|
|
|
/* Don't draw lines before start but keep on drawing (for later lines) */
|
|
|
- if (line_num < longtext->line_start) return true;
|
|
|
+ if (line_num < start_line) return true;
|
|
|
/* Don't draw lines after stop, but keep calculating to get correct amount of lines */
|
|
|
- if (line_num >= longtext->line_stop) return true;
|
|
|
+ if (line_num >= stop_line) return true;
|
|
|
/* Reveal letter by letter on last line */
|
|
|
- if (line_num == (longtext->line_stop - 1)) {
|
|
|
+ if (line_num == longtext->state.line) {
|
|
|
/* Advance the position automatically if not paused. */
|
|
|
- if (!longtext->paused) {
|
|
|
- longtext->line_pos++;
|
|
|
+ if (!longtext->state.paused) {
|
|
|
+ if (longtext->settings.flags & ZORI_LONGTEXT_SETTING_FLAG_SHOW_LETTERS) {
|
|
|
+ al_ustr_next(line, &longtext->state.position);
|
|
|
+ } else {
|
|
|
+ int next_word = al_ustr_find_set_cstr(line, longtext->state.position + 1, " \t\r\n");
|
|
|
+ if (next_word > 0) {
|
|
|
+ longtext->state.position = next_word;
|
|
|
+ } else if (longtext->state.position < (line_length -1)) { /* skip almost to the end of the line. */
|
|
|
+ longtext->state.position = line_length;
|
|
|
+ } else { /* Advance, to end of line. */
|
|
|
+ al_ustr_next(line, &longtext->state.position);
|
|
|
+ }
|
|
|
+ }
|
|
|
}
|
|
|
/* Reached eol, advance to next line. */
|
|
|
- if (longtext->line_pos >= size) {
|
|
|
+ if (longtext->state.position >= line_length) {
|
|
|
+ int pl = zori_longtext_page_lines(longtext);
|
|
|
/* Is if the text window is full, pause, otherwise show the next line. */
|
|
|
- if ((longtext->line_stop - longtext->line_start) >= longtext->page_lines) {
|
|
|
- longtext->paused = true;
|
|
|
- } else {
|
|
|
- longtext->line_stop++;
|
|
|
- longtext->line_pos = 0;
|
|
|
+ if (longtext->state.line >= (stop_line-1)) {
|
|
|
+ longtext->state.paused = true;
|
|
|
+ } else {
|
|
|
+ longtext->state.line++;
|
|
|
+ longtext->state.position = 0;
|
|
|
}
|
|
|
- }
|
|
|
+ }
|
|
|
}
|
|
|
- (void) line;
|
|
|
return true;
|
|
|
}
|
|
|
|
|
|
+
|
|
|
+/* Rerurns whether or no t the end of a page is reached on a longtext */
|
|
|
+int zori_longtext_end_of_page(struct zori_longtext * longtext) {
|
|
|
+ int limit;
|
|
|
+ if (zori_longtext_at_end(longtext)) return TRUE;
|
|
|
+ limit = (longtext->state.page + 1) * longtext->settings.lines;
|
|
|
+ return (longtext->state.line >= limit);
|
|
|
+}
|
|
|
+
|
|
|
/* Updates the longtext, enables scrolling and per character display. */
|
|
|
void zori_longtext_update_longtext(struct zori_longtext * longtext, double dt) {
|
|
|
float width = longtext->widget.inner.size.x;
|
|
|
@@ -143,31 +232,28 @@ void zori_longtext_update_longtext(struct zori_longtext * longtext, double dt) {
|
|
|
LOG_WARNING("Attempted to update a NULL longtext.");
|
|
|
return;
|
|
|
}
|
|
|
-
|
|
|
- /* Delay advance of characters somewhat. */
|
|
|
- longtext->delay_total += dt;
|
|
|
- if (longtext->delay_total < longtext->delay) return;
|
|
|
- longtext->delay_total = 0;
|
|
|
|
|
|
- longtext->line_max = 0;
|
|
|
- al_do_multiline_text(zori_widget_font(&longtext->widget), width,
|
|
|
- (const char *) text, zori_longtext_update_custom_partial_text, longtext);
|
|
|
- longtext->line_max++;
|
|
|
+ longtext->state.anitime += dt;
|
|
|
+ if (longtext->state.anitime > ZORI_LONGTEXT_ANIMATION_CYCLE_TIME) {
|
|
|
+ longtext->state.anitime = 0;
|
|
|
+ }
|
|
|
|
|
|
- /* pause if the last line is reached, and prevent overflow. */
|
|
|
- if (longtext->line_stop > longtext->line_max) {
|
|
|
- longtext->paused = true;
|
|
|
- longtext->line_pos = ZORI_LONGTEXT_LINE_POS_MAX;
|
|
|
- longtext->line_stop = longtext->line_max;
|
|
|
+ /* Delay advance of characters somewhat if requested. */
|
|
|
+ if (longtext->settings.delay > 0.0) {
|
|
|
+ longtext->state.wait += dt;
|
|
|
+ if (longtext->state.wait < longtext->settings.delay) return;
|
|
|
+ longtext->state.wait = 0;
|
|
|
}
|
|
|
-
|
|
|
-}
|
|
|
-
|
|
|
-/* Returns TRUE if the longtext node is at the end of the text to display,
|
|
|
- * false if not (more text to display) */
|
|
|
-int zori_longtext_longtext_at_end(struct zori_longtext * longtext) {
|
|
|
- return ((longtext->line_stop >= longtext->line_max) &&
|
|
|
- (longtext->line_pos >= ZORI_LONGTEXT_LINE_POS_MAX));
|
|
|
+
|
|
|
+ al_do_multiline_ustr(zori_widget_font(&longtext->widget), width,
|
|
|
+ text, zori_longtext_update_custom_partial_text, longtext);
|
|
|
+
|
|
|
+ /* pause if the last line of the page is reached, and prevent overflow. */
|
|
|
+ if (zori_longtext_end_of_page(longtext)) {
|
|
|
+ longtext->state.paused = TRUE;
|
|
|
+ longtext->state.position = ZORI_LONGTEXT_LINE_POS_MAX;
|
|
|
+ }
|
|
|
+
|
|
|
}
|
|
|
|
|
|
/* Calculates the x and y position where to draw text, taking alignment and
|
|
|
@@ -187,6 +273,7 @@ zori_longtext_calculate_text_position(struct zori_longtext * longtext) {
|
|
|
return result;
|
|
|
}
|
|
|
|
|
|
+/* Draws the longtext, if it has a single line.. */
|
|
|
void zori_longtext_draw_text(struct zori_longtext * longtext) {
|
|
|
zori_font * font;
|
|
|
int flags;
|
|
|
@@ -205,18 +292,59 @@ void zori_longtext_draw_text(struct zori_longtext * longtext) {
|
|
|
}
|
|
|
|
|
|
|
|
|
+/**
|
|
|
+ * Draws the paused marker if needed.
|
|
|
+ */
|
|
|
+static void zori_longtext_draw_paused_marker(const struct zori_longtext * longtext) {
|
|
|
+ struct zori_root * root = zori_get_root();
|
|
|
+ int line_skip;
|
|
|
+ float x, y, x1, y1, x2, y2, x3, y3, sp, ms;
|
|
|
+
|
|
|
+ if (!longtext->state.paused) return;
|
|
|
+
|
|
|
+ line_skip = (longtext->state.page + 1 * longtext->settings.lines);
|
|
|
+ x = longtext->widget.inner.at.x ;
|
|
|
+ y = longtext->widget.inner.at.y ;
|
|
|
+ sp = longtext->settings.spacing;
|
|
|
+ y += line_skip * sp;
|
|
|
+ ms = sp * ZORI_LONGTEXT_PAUSE_MARKER_SCALE;
|
|
|
+
|
|
|
+ /* Animate marker by varying its y position */
|
|
|
+ y -= sin(longtext->state.anitime * ALLEGRO_PI) * ms / ZORI_LONGTEXT_PAUSE_MARKER_DAMPER;
|
|
|
+
|
|
|
+ if (root->style.icons.paused) {
|
|
|
+ al_draw_bitmap(root->style.icons.paused, x, y, 0);
|
|
|
+ } else {
|
|
|
+ y2 = y + ms;
|
|
|
+ x2 = x + longtext->widget.inner.size.x;
|
|
|
+ x1 = x2 - ms;
|
|
|
+ y1 = y2;
|
|
|
+ x3 = x2 - ms / 2.0;
|
|
|
+ y3 = y2 + ms;
|
|
|
+ al_draw_filled_triangle(x1, y1, x2, y2, x3, y3, longtext->widget.style.text.color);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+
|
|
|
/* This function is the helper callback that implements the actual drawing
|
|
|
* for zori_longtext_draw_partial_text.
|
|
|
*/
|
|
|
-static bool zori_longtext_draw_custom_partial_text(int line_num, const char *line,
|
|
|
- int size, void *extra) {
|
|
|
+static bool zori_longtext_draw_custom_partial_text(int line_num, const zori_text *line,
|
|
|
+ void *extra) {
|
|
|
float x, y;
|
|
|
struct zori_longtext * longtext = extra;
|
|
|
ALLEGRO_USTR_INFO info;
|
|
|
- int real_size, flags;
|
|
|
- double width;
|
|
|
+ const ALLEGRO_USTR * subline;
|
|
|
+ int real_length, flags;
|
|
|
ALLEGRO_FONT * font;
|
|
|
BeVec pos;
|
|
|
+ int sublength = al_ustr_length(line);
|
|
|
+ int last_line = line_num;
|
|
|
+ int start_line = longtext->state.page * longtext->settings.lines;
|
|
|
+ int stop_line = longtext->state.line + 1;
|
|
|
+ if (stop_line >= longtext->state.total) {
|
|
|
+ stop_line = longtext->state.total;
|
|
|
+ }
|
|
|
|
|
|
font = zori_widget_font(&longtext->widget);
|
|
|
flags = longtext->widget.style.text.flags | ALLEGRO_ALIGN_INTEGER;
|
|
|
@@ -225,39 +353,42 @@ static bool zori_longtext_draw_custom_partial_text(int line_num, const char *lin
|
|
|
|
|
|
|
|
|
/* Don't draw lines before start but keep on drawing (for later lines) */
|
|
|
- if (line_num < longtext->line_start) return true;
|
|
|
+ if (line_num < start_line) return true;
|
|
|
/* Don't draw lines after stop, drawing is done */
|
|
|
- if (line_num >= longtext->line_stop) return false;
|
|
|
- real_size = size;
|
|
|
- /* calculate position */
|
|
|
+ if (line_num >= stop_line) return false;
|
|
|
+
|
|
|
+ real_length = sublength;
|
|
|
+
|
|
|
+ /* Reveal letter by letter on currently active line */
|
|
|
+ if (line_num == (longtext->state.line)) {
|
|
|
+ real_length = (longtext->state.position < sublength) ? longtext->state.position : sublength;
|
|
|
+ }
|
|
|
+
|
|
|
+
|
|
|
x = pos.x;
|
|
|
- y = pos.y + (longtext->line_height * (line_num - longtext->line_start));
|
|
|
+ y = pos.y + (longtext->settings.spacing * (line_num - start_line));
|
|
|
|
|
|
- /* Reveal letter by letter on last line */
|
|
|
- if (line_num == (longtext->line_stop - 1)) {
|
|
|
- real_size = (longtext->line_pos < size) ? longtext->line_pos : size;
|
|
|
-
|
|
|
- /* Draw continuation marker if paused. XXX... this needs to be done
|
|
|
- * better... Maybe a bitmap member or so? */
|
|
|
- if (longtext->paused) {
|
|
|
- float x1, y1, x2, y2, x3, y3;
|
|
|
- y2 = y + 8;
|
|
|
- x2 = x + longtext->widget.inner.size.x;
|
|
|
- x1 = x2 - 8;
|
|
|
- y1 = y2;
|
|
|
- x3 = x2 - 4;
|
|
|
- y3 = y2 + 8;
|
|
|
- al_draw_filled_triangle(x1, y1, x2, y2, x3, y3, longtext->widget.style.text.color);
|
|
|
- }
|
|
|
+
|
|
|
+ /* calculate position of subline */
|
|
|
+ subline = al_ref_ustr(&info, line, 0, al_ustr_offset(line, real_length));
|
|
|
+
|
|
|
+
|
|
|
+ if (flags & ALLEGRO_ALIGN_CENTER) {
|
|
|
+ /* x -= al_get_ustr_width(font, subline) / 2; */
|
|
|
+ } else if (flags & ALLEGRO_ALIGN_RIGHT) {
|
|
|
+ x -= al_get_ustr_width(font, subline);
|
|
|
}
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+ // real_size = size;
|
|
|
|
|
|
zori_color shadow = longtext->widget.style.back.color;
|
|
|
zori_color fore = longtext->widget.style.text.color;
|
|
|
|
|
|
- al_draw_ustr(font, shadow,
|
|
|
- x + 1, y + 1, flags, al_ref_buffer(&info, line, real_size));
|
|
|
- al_draw_ustr(font, fore,
|
|
|
- x, y, flags, al_ref_buffer(&info, line, real_size));
|
|
|
+ al_draw_ustr(font, shadow, x + 1, y + 1, flags, subline);
|
|
|
+ al_draw_ustr(font, fore, x, y, flags, subline);
|
|
|
|
|
|
return true;
|
|
|
}
|
|
|
@@ -266,47 +397,34 @@ static bool zori_longtext_draw_custom_partial_text(int line_num, const char *lin
|
|
|
/* Allows to draw a multi line text partially, from line_start up to
|
|
|
* line_stop. Draws scrolling text from a prefilled struct. */
|
|
|
void zori_longtext_draw_partial_text(struct zori_longtext * longtext) {
|
|
|
- float width = longtext->widget.inner.size.x;
|
|
|
+ float width = longtext->widget.inner.size.x - 20;
|
|
|
zori_font * font = zori_widget_font(&longtext->widget);
|
|
|
|
|
|
if (!longtext->text) {
|
|
|
LOG_WARNING("Trying to draw a NULL longtext.");
|
|
|
return;
|
|
|
}
|
|
|
-
|
|
|
- const char * text = ustr_c(longtext->text);
|
|
|
-
|
|
|
- /* It's a bit of a hack that this ends up here... */
|
|
|
- if (longtext->line_height < 1.0) {
|
|
|
- longtext->line_height = al_get_font_line_height(font);
|
|
|
- }
|
|
|
-
|
|
|
- al_do_multiline_text(font, width,
|
|
|
- (const char *) text, zori_longtext_draw_custom_partial_text, longtext);
|
|
|
+
|
|
|
+ al_do_multiline_ustr(font, width,
|
|
|
+ longtext->text, zori_longtext_draw_custom_partial_text, longtext);
|
|
|
}
|
|
|
|
|
|
|
|
|
void zori_draw_longtext(struct zori_longtext * longtext) {
|
|
|
+ zori_widget_draw_background(&longtext->widget);
|
|
|
zori_longtext_draw_partial_text(longtext);
|
|
|
+ zori_longtext_draw_paused_marker(longtext);
|
|
|
}
|
|
|
|
|
|
|
|
|
/** Sets the last line to display for a long text */
|
|
|
zori_id zori_set_line_stop(zori_id index, int stop) {
|
|
|
- struct zori_widget * widget = zori_get_widget(index);
|
|
|
- struct zori_longtext * longtext = zori_widget_to_longtext(widget);
|
|
|
- if (!longtext) return ZORI_ID_EINVAL;
|
|
|
- longtext->line_stop = stop;
|
|
|
- return index;
|
|
|
+ return ZORI_ID_EINVAL;
|
|
|
}
|
|
|
|
|
|
/** Sets the first line to display for a long text */
|
|
|
zori_id zori_line_start_(zori_id index, int start) {
|
|
|
-struct zori_widget * widget = zori_get_widget(index);
|
|
|
- struct zori_longtext * longtext = zori_widget_to_longtext(widget);
|
|
|
- if (!longtext) return ZORI_ID_EINVAL;
|
|
|
- longtext->line_start = start;
|
|
|
- return index;
|
|
|
+ return ZORI_ID_EINVAL;
|
|
|
}
|
|
|
|
|
|
/** Sets display delay between individual characters for a long text */
|
|
|
@@ -314,43 +432,34 @@ int zori_delay_(zori_id index, double delay) {
|
|
|
struct zori_widget * widget = zori_get_widget(index);
|
|
|
struct zori_longtext * longtext = zori_widget_to_longtext(widget);
|
|
|
if (!longtext) return ZORI_ID_EINVAL;
|
|
|
- longtext->delay = delay;
|
|
|
+ longtext->settings.delay = delay;
|
|
|
return index;
|
|
|
}
|
|
|
|
|
|
-
|
|
|
-
|
|
|
/** Gets the last line to display for a long text or negative on error*/
|
|
|
int zori_line_stop(int index) {
|
|
|
- struct zori_widget * widget = zori_get_widget(index);
|
|
|
- struct zori_longtext * longtext = zori_widget_to_longtext(widget);
|
|
|
- if (!longtext) return ZORI_ID_EINVAL;
|
|
|
- return longtext->line_stop;
|
|
|
+ return ZORI_ID_EINVAL;
|
|
|
}
|
|
|
|
|
|
/** Gets the first line to display for a long text */
|
|
|
int zori_line_start(int index) {
|
|
|
- struct zori_widget * widget = zori_get_widget(index);
|
|
|
- struct zori_longtext * longtext = zori_widget_to_longtext(widget);
|
|
|
- if (!longtext) return ZORI_ID_EINVAL;
|
|
|
- return longtext->line_start;
|
|
|
+ return ZORI_ID_EINVAL;
|
|
|
}
|
|
|
|
|
|
-/** Gets display delay between individual characters for a long text */
|
|
|
+/** Gets display delay between individual characters for a long text */
|
|
|
double zori_delay(int index) {
|
|
|
struct zori_widget * widget = zori_get_widget(index);
|
|
|
struct zori_longtext * longtext = zori_widget_to_longtext(widget);
|
|
|
if (!longtext) return ZORI_ID_EINVAL;
|
|
|
- return longtext->delay;
|
|
|
+ return longtext->settings.delay;
|
|
|
}
|
|
|
|
|
|
-
|
|
|
-/** Sets amount of shown lines for a long text */
|
|
|
+/** Sets amount of shown lines per page for a long text */
|
|
|
int zori_page_lines_(zori_id index, int lines) {
|
|
|
struct zori_widget * widget = zori_get_widget(index);
|
|
|
struct zori_longtext * longtext = zori_widget_to_longtext(widget);
|
|
|
- if (!longtext) return ZORI_ID_EINVAL;
|
|
|
- longtext->page_lines = lines;
|
|
|
+ if (!longtext) return ZORI_ID_EINVAL;
|
|
|
+ zori_longtext_page_lines_(longtext, lines);
|
|
|
return index;
|
|
|
}
|
|
|
|
|
|
@@ -359,7 +468,7 @@ int zori_page_lines(int index) {
|
|
|
struct zori_widget * widget = zori_get_widget(index);
|
|
|
struct zori_longtext * longtext = zori_widget_to_longtext(widget);
|
|
|
if (!longtext) return ZORI_ID_EINVAL;
|
|
|
- return longtext->page_lines;
|
|
|
+ return zori_longtext_page_lines(longtext);
|
|
|
}
|
|
|
|
|
|
/** Sets paused state of long text */
|
|
|
@@ -367,7 +476,7 @@ int zori_paused_(zori_id index, int paused) {
|
|
|
struct zori_widget * widget = zori_get_widget(index);
|
|
|
struct zori_longtext * longtext = zori_widget_to_longtext(widget);
|
|
|
if (!longtext) return ZORI_ID_EINVAL;
|
|
|
- longtext->paused = paused;
|
|
|
+ longtext->state.paused = paused;
|
|
|
return index;
|
|
|
}
|
|
|
|
|
|
@@ -376,7 +485,7 @@ int zori_paused(zori_id index) {
|
|
|
struct zori_widget * widget = zori_get_widget(index);
|
|
|
struct zori_longtext * longtext = zori_widget_to_longtext(widget);
|
|
|
if (!longtext) return 0;
|
|
|
- return longtext->paused;
|
|
|
+ return longtext->state.paused;
|
|
|
}
|
|
|
|
|
|
/** Gets the current text page for a longtext. */
|
|
|
@@ -424,8 +533,14 @@ int zori_previous_page(int index) {
|
|
|
return zori_page_(index, page - 1);
|
|
|
}
|
|
|
|
|
|
+/** Handles an update event and pass it on. */
|
|
|
+int zori_longtext_on_update(union zori_event * event) {
|
|
|
+ struct zori_widget * widget = event->any.widget;
|
|
|
+ struct zori_longtext * longtext = zori_widget_to_longtext(widget);
|
|
|
+ zori_longtext_update_longtext(longtext, event->update.dt);
|
|
|
|
|
|
-
|
|
|
+ return ZORI_HANDLE_PASS;
|
|
|
+}
|
|
|
|
|
|
/** Handles a mouse axis event and pass it on. */
|
|
|
int zori_longtext_on_mouse_axes(union zori_event * event) {
|
|
|
@@ -448,10 +563,27 @@ int zori_longtext_on_mouse_click(union zori_event * event) {
|
|
|
struct zori_longtext * longtext = zori_widget_to_longtext(widget);
|
|
|
float x = event->sys.ev->mouse.x;
|
|
|
float y = event->sys.ev->mouse.y;
|
|
|
+ int b = event->sys.ev->mouse.button;
|
|
|
if (zori_xy_inside_widget_p(widget, x, y)) {
|
|
|
+ struct zori_widget * page = zori_widget_get_parent_of_type(widget, ZORI_WIDGET_TYPE_PAGE);
|
|
|
widget->result.ready = widget->id;
|
|
|
widget->result.value.string = longtext->text;
|
|
|
LOG_NOTE("Longtext %d clicked: %d, result %d.\n", widget->id, widget->result);
|
|
|
+ LOG_NOTE("Longtext visible %d.\n", zori_widget_visible(widget));
|
|
|
+ LOG_NOTE("UI page visible %d.\n", zori_widget_visible(page));
|
|
|
+ LOG_NOTE("Longtext page visible %d.\n", zori_longtext_page(longtext));
|
|
|
+
|
|
|
+ longtext->state.paused = 0;
|
|
|
+
|
|
|
+ if (1==b) {
|
|
|
+ if (zori_longtext_at_end(longtext)) {
|
|
|
+ zori_widget_set_closed_result(&longtext->widget, longtext->state.total);
|
|
|
+ } else {
|
|
|
+ zori_longtext_page_(longtext, zori_longtext_page(longtext) + 1);
|
|
|
+ }
|
|
|
+ } else if (2==b) {
|
|
|
+ zori_longtext_page_(longtext, 0);
|
|
|
+ }
|
|
|
return zori_widget_raise_action_event(widget);
|
|
|
}
|
|
|
return ZORI_HANDLE_PASS;
|
|
|
@@ -470,6 +602,7 @@ struct zori_handler zori_longtext_handlers[] = {
|
|
|
{ ZORI_SYSTEM_EVENT_MOUSE_BUTTON_DOWN , zori_longtext_on_mouse_click , NULL },
|
|
|
{ ZORI_SYSTEM_EVENT_MOUSE_AXES , zori_longtext_on_mouse_axes , NULL },
|
|
|
{ ZORI_EVENT_DRAW , zori_longtext_on_draw , NULL },
|
|
|
+ { ZORI_EVENT_UPDATE , zori_longtext_on_update , NULL },
|
|
|
{ -1, NULL, NULL }
|
|
|
};
|
|
|
|
|
|
@@ -477,7 +610,23 @@ struct zori_handler zori_longtext_handlers[] = {
|
|
|
struct zori_longtext *
|
|
|
zori_longtext_init(struct zori_longtext * longtext, const char * text) {
|
|
|
if (longtext) {
|
|
|
+ int lh = 8;
|
|
|
zori_longtext_set_cstr(longtext, text);
|
|
|
+ zori_longtext_page_(longtext, 0);
|
|
|
+ lh = zori_font_lineheight(longtext->widget.style.text.font);
|
|
|
+ zori_longtext_page_lines_(longtext, lh / longtext->widget.inner.size.y);
|
|
|
+ longtext->settings.delay = ZORI_LONGTEXT_DEFAULT_DELAY;
|
|
|
+ longtext->state.line = 0;
|
|
|
+ longtext->state.page = 0;
|
|
|
+ longtext->state.position = 0;
|
|
|
+ longtext->state.paused = 0;
|
|
|
+ longtext->state.anitime = 0.0;
|
|
|
+ longtext->settings.lines = 2;
|
|
|
+
|
|
|
+ /* XXX It's a hack that this ends up here... */
|
|
|
+ if (longtext->settings.spacing < 1.0) {
|
|
|
+ longtext->settings.spacing = lh;
|
|
|
+ }
|
|
|
}
|
|
|
return longtext;
|
|
|
}
|
|
|
@@ -494,6 +643,7 @@ struct zori_longtext * zori_longtext_new(zori_id id, zori_id parent_id,
|
|
|
longtext = NULL;
|
|
|
}
|
|
|
zori_widget_hover_(&longtext->widget, 0);
|
|
|
+ zori_widget_live_(&longtext->widget, 1);
|
|
|
|
|
|
return longtext;
|
|
|
}
|
