/* * StarDict terminal UI * * Copyright (c) 2013, Přemysl Janouch * All rights reserved. * * Permission to use, copy, modify, and/or distribute this software for any * purpose with or without fee is hereby granted, provided that the above * copyright notice and this permission notice appear in all copies. * * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. * */ #define _XOPEN_SOURCE 500 //!< wcwidth #define _XOPEN_SOURCE_EXTENDED //!< Yes, we want ncursesw. #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "config.h" #include "stardict.h" #define CTRL_KEY(x) ((x) - 'A' + 1) #define KEY_SOH CTRL_KEY ('A') //!< Ctrl-A #define KEY_STX CTRL_KEY ('B') //!< Ctrl-B #define KEY_ENQ CTRL_KEY ('E') //!< Ctrl-E #define KEY_ACK CTRL_KEY ('F') //!< Ctrl-F #define KEY_VT CTRL_KEY ('K') //!< Ctrl-K #define KEY_FF CTRL_KEY ('L') //!< Ctrl-L #define KEY_SO CTRL_KEY ('N') //!< Ctrl-N #define KEY_DLE CTRL_KEY ('P') //!< Ctrl-P #define KEY_DC4 CTRL_KEY ('T') //!< Ctrl-T #define KEY_NAK CTRL_KEY ('U') //!< Ctrl-U #define KEY_ETB CTRL_KEY ('W') //!< Ctrl-W #define KEY_RETURN 13 //!< Enter #define KEY_ESCAPE 27 //!< Esc typedef enum { TERMINAL_UNKNOWN, //!< No extra handling TERMINAL_XTERM, //!< xterm and VTE extra keycodes TERMINAL_RXVT //!< rxvt extra keycodes } TerminalType; //!< Type of the terminal typedef enum { KEY_NOT_RECOGNISED, //!< Not recognised KEY_CTRL_UP, //!< Ctrl + Up arrow KEY_CTRL_DOWN, //!< Ctrl + Down arrow KEY_CTRL_LEFT, //!< Ctrl + Left arrow KEY_CTRL_RIGHT, //!< Ctrl + Right arrow KEY_ALT_UP, //!< Alt + Up arrow KEY_ALT_DOWN, //!< Alt + Down arrow KEY_ALT_LEFT, //!< Alt + Left arrow KEY_ALT_RIGHT //!< Alt + Right arrow } ExtraKeyCode; //!< Translated key codes above KEY_MAX // --- Utilities --------------------------------------------------------------- static int poll_restart (struct pollfd *fds, nfds_t nfds, int timeout) { int ret; do ret = poll (fds, nfds, timeout); while (ret == -1 && errno == EINTR); return ret; } /** Wrapper for curses event data. */ typedef struct curses_event CursesEvent; struct curses_event { wint_t code; guint is_char : 1; MEVENT mouse; }; static size_t unichar_width (gunichar ch) { if (g_unichar_iszerowidth (ch)) return 0; return 1 + g_unichar_iswide (ch); } #ifndef HAVE_WCWIDTH #define wcwidth(x) 1 #endif // ! HAVE_WCWIDTH static gboolean is_character_in_locale (wchar_t c) { wchar_t s[] = { c, 0 }; return wcstombs (NULL, s, 0) != (size_t) -1; } /** Translate key codes above KEY_MAX returned from ncurses into something * meaningful, based on the terminal type. The values have been obtained * experimentally. Some keycodes make ncurses return KEY_ESCAPE, even * depending on actual terminal settings, thus this is not reliable at all. * xterm/VTE seems to behave nicely, though. */ static guint translate_extra_keycode (wchar_t code, TerminalType terminal) { switch (terminal) { case TERMINAL_XTERM: switch (code) { case 565: return KEY_CTRL_UP; case 524: return KEY_CTRL_DOWN; case 544: return KEY_CTRL_LEFT; case 559: return KEY_CTRL_RIGHT; case 563: return KEY_ALT_UP; case 522: return KEY_ALT_DOWN; case 542: return KEY_ALT_LEFT; case 557: return KEY_ALT_RIGHT; } break; case TERMINAL_RXVT: switch (code) { case 521: return KEY_CTRL_UP; case 514: return KEY_CTRL_DOWN; } break; case TERMINAL_UNKNOWN: break; } return KEY_NOT_RECOGNISED; } /** Get the type of the terminal based on the TERM environment variable. */ static TerminalType get_terminal_type (void) { const gchar *term = g_getenv ("TERM"); if (!term) return TERMINAL_UNKNOWN; gchar term_copy[strcspn (term, "-") + 1]; g_strlcpy (term_copy, term, sizeof term_copy); if (!strcmp (term_copy, "xterm")) return TERMINAL_XTERM; if (!strcmp (term_copy, "rxvt")) return TERMINAL_RXVT; return TERMINAL_UNKNOWN; } // --- Application ------------------------------------------------------------- /** Data relating to one entry within the dictionary. */ typedef struct view_entry ViewEntry; /** Encloses application data. */ typedef struct application Application; struct view_entry { gchar * word; //!< Word gchar ** definitions; //!< Word definition entries gsize definitions_length; //!< Length of the @a definitions array }; struct application { TerminalType terminal_type; //!< Type of the terminal GIConv utf8_to_wchar; //!< utf-8 -> wchar_t conversion GIConv wchar_to_utf8; //!< wchar_t -> utf-8 conversion StardictDict * dict; //!< The current dictionary guint show_help : 1; //!< Whether help can be shown guint32 top_position; //!< Index of the topmost dict. entry guint top_offset; //!< Offset into the top entry guint selected; //!< Offset to the selected definition GPtrArray * entries; //!< ViewEntry's within the view gchar * search_label; //!< Text of the "Search" label GArray * input; //!< The current search input guint input_pos; //!< Cursor position within input gboolean input_confirmed; //!< Input has been confirmed gfloat division; //!< Position of the division column }; /** Splits the entry and adds it to a pointer array. */ static void view_entry_split_add (GPtrArray *out, const gchar *text) { gchar **it, **tmp = g_strsplit (text, "\n", -1); for (it = tmp; *it; it++) if (**it) g_ptr_array_add (out, g_strdup (*it)); g_strfreev (tmp); } /** Decomposes a dictionary entry into the format we want. */ static ViewEntry * view_entry_new (StardictIterator *iterator) { g_return_val_if_fail (stardict_iterator_is_valid (iterator), NULL); ViewEntry *ve = g_slice_alloc (sizeof *ve); GString *word = g_string_new (stardict_iterator_get_word (iterator)); StardictEntry *entry = stardict_iterator_get_entry (iterator); g_return_val_if_fail (entry != NULL, NULL); GPtrArray *definitions = g_ptr_array_new (); const GList *fields = stardict_entry_get_fields (entry); gboolean found_anything_displayable = FALSE; while (fields) { const StardictEntryField *field = fields->data; switch (field->type) { case STARDICT_FIELD_MEANING: view_entry_split_add (definitions, field->data); found_anything_displayable = TRUE; break; case STARDICT_FIELD_PANGO: { char *text; if (!pango_parse_markup (field->data, -1, 0, NULL, &text, NULL, NULL)) text = g_strdup_printf ("<%s>", _("error in entry")); view_entry_split_add (definitions, text); found_anything_displayable = TRUE; g_free (text); break; } case STARDICT_FIELD_PHONETIC: g_string_append_printf (word, " /%s/", (const gchar *) field->data); break; default: // TODO support more of them break; } fields = fields->next; } g_object_unref (entry); if (!found_anything_displayable) g_ptr_array_add (definitions, g_strdup_printf ("<%s>", _("no usable field found"))); ve->word = g_string_free (word, FALSE); ve->definitions_length = definitions->len; g_ptr_array_add (definitions, NULL); ve->definitions = (gchar **) g_ptr_array_free (definitions, FALSE); return ve; } /** Release resources associated with the view entry. */ static void view_entry_free (ViewEntry *ve) { g_free (ve->word); g_strfreev (ve->definitions); g_slice_free1 (sizeof *ve, ve); } /** Reload view items. */ static void app_reload_view (Application *self) { if (self->entries->len != 0) g_ptr_array_remove_range (self->entries, 0, self->entries->len); gint remains = LINES - 1 + self->top_offset; StardictIterator *iterator = stardict_iterator_new (self->dict, self->top_position); while (remains > 0 && stardict_iterator_is_valid (iterator)) { ViewEntry *entry = view_entry_new (iterator); remains -= entry->definitions_length; g_ptr_array_add (self->entries, entry); stardict_iterator_next (iterator); } g_object_unref (iterator); } /** Initialize the application core. */ static void app_init (Application *self, const gchar *filename) { GError *error = NULL; self->dict = stardict_dict_new (filename, &error); if (!self->dict) { g_printerr ("%s: %s\n", _("Error loading dictionary"), error->message); exit (EXIT_FAILURE); } self->terminal_type = get_terminal_type (); self->show_help = TRUE; self->top_position = 0; self->top_offset = 0; self->selected = 0; self->entries = g_ptr_array_new_with_free_func ((GDestroyNotify) view_entry_free); self->search_label = g_strdup_printf ("%s: ", _("Search")); self->input = g_array_new (TRUE, FALSE, sizeof (gunichar)); self->input_pos = 0; self->input_confirmed = FALSE; self->division = 0.5; self->wchar_to_utf8 = g_iconv_open ("utf-8//translit", "wchar_t"); self->utf8_to_wchar = g_iconv_open ("wchar_t//translit", "utf-8"); app_reload_view (self); } /** Free any resources used by the application. */ static void app_destroy (Application *self) { g_object_unref (self->dict); g_ptr_array_free (self->entries, TRUE); g_free (self->search_label); g_array_free (self->input, TRUE); g_iconv_close (self->wchar_to_utf8); g_iconv_close (self->utf8_to_wchar); } /** Write the given utf-8 string padded with spaces. * @param[in] n The number of characters to write, or -1 for the whole string. * @return The number of wide characters written. */ static gsize app_add_utf8_string (Application *self, const gchar *str, int n) { wchar_t *wide_str = (wchar_t *) g_convert_with_iconv (str, -1, self->utf8_to_wchar, NULL, NULL, NULL); g_return_val_if_fail (wide_str != NULL, 0); ssize_t wide_len = wcslen (wide_str); wchar_t padding = L' ', error = L'?', ellipsis = L'…'; if (!n) return 0; // Compute how many wide characters fit in the limit gint cols, i; for (cols = i = 0; i < wide_len; i++) { if (!is_character_in_locale (wide_str[i])) wide_str[i] = error; gint width = wcwidth (wide_str[i]); if (n >= 0 && cols + width > n) break; cols += width; } if (n < 0) n = cols; // Append ellipsis if the whole string didn't fit gint len = i; if (len != wide_len) { if (is_character_in_locale (ellipsis)) { if (cols + wcwidth (ellipsis) > n) cols -= wcwidth (wide_str[len - 1]); else len++; wide_str[len - 1] = ellipsis; cols += wcwidth (ellipsis); } else if (n >= 3 && len >= 3) { // With zero-width characters this overflows // It's just a fallback anyway cols -= wcwidth (wide_str[len - 1]); cols -= wcwidth (wide_str[len - 2]); cols -= wcwidth (wide_str[len - 3]); cols += 3; wide_str[len - 1] = L'.'; wide_str[len - 2] = L'.'; wide_str[len - 3] = L'.'; } } cchar_t cch; for (i = 0; i < len; i++) { if (setcchar (&cch, &wide_str[i], A_NORMAL, 0, NULL) == OK) add_wch (&cch); else // This shouldn't happen cols -= wcwidth (wide_str[i]); } setcchar (&cch, &padding, A_NORMAL, 0, NULL); while (cols++ < n) add_wch (&cch); g_free (wide_str); return n; } /** Render the top bar. */ static void app_redraw_top (Application *self) { mvwhline (stdscr, 0, 0, A_UNDERLINE, COLS); attrset (A_UNDERLINE); gsize indent = app_add_utf8_string (self, self->search_label, -1); gchar *input_utf8 = g_ucs4_to_utf8 ((gunichar *) self->input->data, -1, NULL, NULL, NULL); g_return_if_fail (input_utf8 != NULL); if (self->input_confirmed) attron (A_BOLD); app_add_utf8_string (self, input_utf8, COLS - indent); g_free (input_utf8); guint offset, i; for (offset = i = 0; i < self->input_pos; i++) // This may be inconsistent with the output of app_add_utf8_string() offset += unichar_width (g_array_index (self->input, gunichar, i)); move (0, indent + offset); refresh (); } /** Computes width for the left column. */ static guint app_get_left_column_width (Application *self) { gint width = COLS * self->division + 0.5; if (width < 1) width = 1; else if (width > COLS - 2) width = COLS - 2; return width; } /** Display a message in the view area. */ static void app_show_message (Application *self, const gchar *lines[], gsize len) { gint top = (LINES - 1 - len) / 2; gint i; for (i = 0; i < top; i++) { move (1 + i, 0); clrtoeol (); } attrset (0); while (len-- && i < LINES - 1) { move (1 + i, 0); clrtoeol (); gint x = (COLS - g_utf8_strlen (*lines, -1)) / 2; if (x < 0) x = 0; move (1 + i, x); app_add_utf8_string (self, *lines, COLS - x); lines++; i++; } clrtobot (); refresh (); } /** Show some information about the program. */ static void app_show_help (Application *self) { const gchar *lines[] = { PROJECT_NAME " " PROJECT_VERSION, _("Terminal UI for StarDict dictionaries"), "Copyright (c) 2013, Přemysl Janouch", "", _("Type to search") }; app_show_message (self, lines, G_N_ELEMENTS (lines)); } /** Redraw the dictionary view. */ static void app_redraw_view (Application *self) { if (self->show_help) { app_show_help (self); return; } move (1, 0); guint i, k = self->top_offset, shown = 0; for (i = 0; i < self->entries->len; i++) { ViewEntry *ve = g_ptr_array_index (self->entries, i); for (; k < ve->definitions_length; k++) { int attrs = 0; if (shown == self->selected) attrs |= A_REVERSE; if (k + 1 == ve->definitions_length) attrs |= A_UNDERLINE; attrset (attrs); guint left_width = app_get_left_column_width (self); app_add_utf8_string (self, ve->word, left_width); addwstr (L" "); app_add_utf8_string (self, ve->definitions[k], COLS - left_width - 1); if ((gint) ++shown == LINES - 1) goto done; } k = 0; } done: attrset (0); clrtobot (); refresh (); } /** Just prepends a new view entry into the entries array. */ static ViewEntry * prepend_entry (Application *self, guint32 position) { StardictIterator *iterator = stardict_iterator_new (self->dict, position); ViewEntry *ve = view_entry_new (iterator); g_object_unref (iterator); g_ptr_array_add (self->entries, NULL); memmove (self->entries->pdata + 1, self->entries->pdata, sizeof ve * (self->entries->len - 1)); return g_ptr_array_index (self->entries, 0) = ve; } /** Just appends a new view entry to the entries array. */ static ViewEntry * append_entry (Application *self, guint32 position) { ViewEntry *ve = NULL; StardictIterator *iterator = stardict_iterator_new (self->dict, position); if (stardict_iterator_is_valid (iterator)) { ve = view_entry_new (iterator); g_ptr_array_add (self->entries, ve); } g_object_unref (iterator); return ve; } /** Counts the number of definitions available for seeing. */ static guint app_count_view_items (Application *self) { guint i, n_definitions = 0; for (i = 0; i < self->entries->len; i++) { ViewEntry *entry = g_ptr_array_index (self->entries, i); n_definitions += entry->definitions_length; } return n_definitions; } /** Scroll up @a n entries. */ static gboolean app_scroll_up (Application *self, guint n) { gboolean success = TRUE; guint n_definitions = app_count_view_items (self); while (n--) { if (self->top_offset > 0) { self->top_offset--; continue; } /* We've reached the top */ if (self->top_position == 0) { success = FALSE; break; } ViewEntry *ve = prepend_entry (self, --self->top_position); self->top_offset = ve->definitions_length - 1; n_definitions += ve->definitions_length; /* Remove the last entry if not shown */ ViewEntry *last_entry = g_ptr_array_index (self->entries, self->entries->len - 1); if ((gint) (n_definitions - self->top_offset - last_entry->definitions_length) >= LINES - 1) { n_definitions -= last_entry->definitions_length; g_ptr_array_remove_index_fast (self->entries, self->entries->len - 1); } } app_redraw_view (self); return success; } /** Scroll down @a n entries. */ static gboolean app_scroll_down (Application *self, guint n) { gboolean success = TRUE; guint n_definitions = app_count_view_items (self); while (n--) { if (self->entries->len == 0) { success = FALSE; break; } ViewEntry *first_entry = g_ptr_array_index (self->entries, 0); if (self->top_offset < first_entry->definitions_length - 1) self->top_offset++; else { n_definitions -= first_entry->definitions_length; g_ptr_array_remove_index (self->entries, 0); self->top_position++; self->top_offset = 0; } if ((gint) (n_definitions - self->top_offset) < LINES - 1) { ViewEntry *ve = append_entry (self, self->top_position + self->entries->len); if (ve != NULL) n_definitions += ve->definitions_length; } } /* Fix cursor to not point below the view items */ if (self->selected >= n_definitions - self->top_offset) self->selected = n_definitions - self->top_offset - 1; app_redraw_view (self); return success; } /** Moves the selection one entry up. */ static gboolean app_one_entry_up (Application *self) { if (self->selected == 0 && self->top_offset == 0) { if (self->top_position == 0) return FALSE; prepend_entry (self, --self->top_position); } // Find the last entry that starts above the selection gint first = -self->top_offset; guint i; for (i = 0; i < self->entries->len; i++) { ViewEntry *ve = g_ptr_array_index (self->entries, i); gint new_first = first + ve->definitions_length; if (new_first >= (gint) self->selected) break; first = new_first; } if (first < 0) { self->selected = 0; app_scroll_up (self, -first); } else { self->selected = first; app_redraw_view (self); } return TRUE; } /** Moves the selection one entry down. */ static void app_one_entry_down (Application *self) { // Find the first entry that starts below the selection gint first = -self->top_offset; guint i; for (i = 0; i < self->entries->len; i++) { ViewEntry *ve = g_ptr_array_index (self->entries, i); first += ve->definitions_length; if (first > (gint) self->selected) break; } if (first > LINES - 2) { self->selected = LINES - 2; app_scroll_down (self, first - (LINES - 2)); } else { self->selected = first; app_redraw_view (self); } } /** Redraw everything. */ static void app_redraw (Application *self) { app_redraw_view (self); app_redraw_top (self); } /** Search for the current entry. */ static void app_search_for_entry (Application *self) { gchar *input_utf8 = g_ucs4_to_utf8 ((gunichar *) self->input->data, -1, NULL, NULL, NULL); g_return_if_fail (input_utf8 != NULL); StardictIterator *iterator = stardict_dict_search (self->dict, input_utf8, NULL); g_free (input_utf8); self->top_position = stardict_iterator_get_offset (iterator); self->top_offset = 0; self->selected = 0; g_object_unref (iterator); app_reload_view (self); app_redraw_view (self); } #define SAVE_CURSOR \ int last_x, last_y; \ getyx (stdscr, last_y, last_x); #define RESTORE_CURSOR \ move (last_y, last_x); \ refresh (); /** Process input above KEY_MAX. */ static gboolean app_process_extra_code (Application *self, CursesEvent *event) { SAVE_CURSOR switch (translate_extra_keycode (event->code, self->terminal_type)) { case KEY_CTRL_UP: app_one_entry_up (self); RESTORE_CURSOR break; case KEY_CTRL_DOWN: app_one_entry_down (self); RESTORE_CURSOR break; case KEY_ALT_LEFT: self->division = (app_get_left_column_width (self) - 1.) / COLS; app_redraw_view (self); RESTORE_CURSOR break; case KEY_ALT_RIGHT: self->division = (app_get_left_column_width (self) + 1.) / COLS; app_redraw_view (self); RESTORE_CURSOR break; } return TRUE; } /** Process input that's not a character. */ static gboolean app_process_nonchar_code (Application *self, CursesEvent *event) { SAVE_CURSOR switch (event->code) { case KEY_RESIZE: { app_reload_view (self); guint n_visible = app_count_view_items (self) - self->top_offset; if ((gint) n_visible > LINES - 1) n_visible = LINES - 1; if (self->selected >= n_visible) { app_scroll_down (self, self->selected - n_visible + 1); self->selected = n_visible - 1; } app_redraw (self); break; } case KEY_MOUSE: if (!(event->mouse.bstate & BUTTON1_PRESSED)) break; if (event->mouse.y == 0) { gsize label_len = g_utf8_strlen (self->search_label, -1); gint pos = event->mouse.x - label_len; if (pos >= 0) { self->input_pos = MIN ((guint) pos, self->input->len); move (0, label_len + self->input_pos); refresh (); } } else if (event->mouse.y <= (int) (app_count_view_items (self) - self->top_offset)) { self->selected = event->mouse.y - 1; app_redraw_view (self); RESTORE_CURSOR } break; case KEY_UP: if (self->selected > 0) { self->selected--; app_redraw_view (self); } else app_scroll_up (self, 1); RESTORE_CURSOR break; case KEY_DOWN: if ((gint) self->selected < LINES - 2 && self->selected < app_count_view_items (self) - self->top_offset - 1) { self->selected++; app_redraw_view (self); } else app_scroll_down (self, 1); RESTORE_CURSOR break; case KEY_PPAGE: app_scroll_up (self, LINES - 1); // FIXME selection RESTORE_CURSOR break; case KEY_NPAGE: app_scroll_down (self, LINES - 1); // FIXME selection RESTORE_CURSOR break; case KEY_HOME: self->input_pos = 0; app_redraw_top (self); break; case KEY_END: self->input_pos = self->input->len; app_redraw_top (self); break; case KEY_LEFT: if (self->input_pos > 0) { self->input_pos--; app_redraw_top (self); } break; case KEY_RIGHT: if (self->input_pos < self->input->len) { self->input_pos++; app_redraw_top (self); } break; case KEY_BACKSPACE: if (self->input_pos > 0) { g_array_remove_index (self->input, --self->input_pos); app_search_for_entry (self); app_redraw_top (self); } break; case KEY_DC: if (self->input_pos < self->input->len) { g_array_remove_index (self->input, self->input_pos); app_search_for_entry (self); app_redraw_top (self); } break; default: return app_process_extra_code (self, event); } return TRUE; } /** Process input events from ncurses. */ static gboolean app_process_curses_event (Application *self, CursesEvent *event) { if (!event->is_char) return app_process_nonchar_code (self, event); switch (event->code) { case KEY_ESCAPE: return FALSE; case KEY_RETURN: self->input_confirmed = TRUE; app_redraw_top (self); break; case KEY_FF: // Ctrl-L -- redraw everything clear (); app_redraw (self); break; case KEY_STX: // Ctrl-B -- back case KEY_ACK: // Ctrl-F -- forward case KEY_DLE: // Ctrl-P -- previous case KEY_SO: // Ctrl-N -- next // TODO map this to something useful break; case KEY_SOH: // Ctrl-A -- move to the start of line self->input_pos = 0; app_redraw_top (self); break; case KEY_ENQ: // Ctrl-E -- move to the end of line self->input_pos = self->input->len; app_redraw_top (self); break; case KEY_VT: // Ctrl-K -- delete until the end of line if (self->input_pos < self->input->len) { g_array_remove_range (self->input, self->input_pos, self->input->len - self->input_pos); app_search_for_entry (self); app_redraw_top (self); } return TRUE; case KEY_ETB: // Ctrl-W -- delete word before cursor { if (self->input_pos == 0) return TRUE; gint i = self->input_pos; while (i) if (g_array_index (self->input, gunichar, --i) != L' ') break; while (i--) if (g_array_index (self->input, gunichar, i) == L' ') break; i++; g_array_remove_range (self->input, i, self->input_pos - i); self->input_pos = i; app_search_for_entry (self); app_redraw_top (self); return TRUE; } case KEY_NAK: // Ctrl-U -- delete everything before the cursor if (self->input->len != 0) { g_array_remove_range (self->input, 0, self->input_pos); self->input_pos = 0; app_search_for_entry (self); app_redraw_top (self); } return TRUE; case KEY_DC4: // Ctrl-T -- transposition { if (!self->input_pos || self->input->len < 2) break; guint start = self->input_pos - 1; if (self->input_pos >= self->input->len) start--; gunichar tmp = g_array_index (self->input, gunichar, start); g_array_index (self->input, gunichar, start) = g_array_index (self->input, gunichar, start + 1); g_array_index (self->input, gunichar, start + 1) = tmp; if (self->input_pos < self->input->len) self->input_pos++; app_search_for_entry (self); app_redraw_top (self); return TRUE; } } wchar_t code = event->code; gchar *letter = g_convert_with_iconv ((gchar *) &code, sizeof code, self->wchar_to_utf8, NULL, NULL, NULL); g_return_val_if_fail (letter != NULL, FALSE); gunichar c = g_utf8_get_char (letter); if (g_unichar_isprint (c)) { self->show_help = FALSE; if (self->input_confirmed) { if (self->input->len != 0) g_array_remove_range (self->input, 0, self->input->len); self->input_pos = 0; self->input_confirmed = FALSE; } g_array_insert_val (self->input, self->input_pos++, c); app_search_for_entry (self); app_redraw_top (self); } g_free (letter); return TRUE; } // --- SIGWINCH ---------------------------------------------------------------- static int g_winch_pipe[2]; /**< SIGWINCH signalling pipe. */ static void (*g_old_winch_handler) (int); static void winch_handler (int signum) { /* Call the ncurses handler. */ if (g_old_winch_handler) g_old_winch_handler (signum); /* And wake up the poll() call. */ write (g_winch_pipe[1], "x", 1); } static void install_winch_handler (void) { struct sigaction act, oldact; act.sa_handler = winch_handler; act.sa_flags = SA_RESTART; sigemptyset (&act.sa_mask); sigaction (SIGWINCH, &act, &oldact); /* Save the ncurses handler. */ if (oldact.sa_handler != SIG_DFL && oldact.sa_handler != SIG_IGN) g_old_winch_handler = oldact.sa_handler; } // --- Initialisation, event handling ------------------------------------------ Application g_application; static gboolean process_stdin_input (void) { CursesEvent event; int sta; while ((sta = get_wch (&event.code)) != ERR) { event.is_char = (sta == OK); if (sta == KEY_CODE_YES && event.code == KEY_MOUSE && getmouse (&event.mouse) == ERR) abort (); if (!app_process_curses_event (&g_application, &event)) return FALSE; } return TRUE; } static gboolean process_winch_input (int fd) { char c; read (fd, &c, 1); return process_stdin_input (); } int main (int argc, char *argv[]) { G_GNUC_BEGIN_IGNORE_DEPRECATIONS if (glib_check_version (2, 36, 0)) g_type_init (); G_GNUC_END_IGNORE_DEPRECATIONS gboolean show_version = FALSE; GOptionEntry entries[] = { { "version", 0, G_OPTION_FLAG_IN_MAIN, G_OPTION_ARG_NONE, &show_version, N_("Output version information and exit"), NULL }, { NULL } }; if (!setlocale (LC_ALL, "")) g_printerr ("%s: %s\n", _("Warning"), _("failed to set the locale")); bindtextdomain (GETTEXT_PACKAGE, GETTEXT_DIRNAME); bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8"); textdomain (GETTEXT_PACKAGE); GError *error = NULL; GOptionContext *ctx = g_option_context_new (N_("dictionary.ifo - StarDict terminal UI")); g_option_context_add_main_entries (ctx, entries, GETTEXT_PACKAGE); g_option_context_set_translation_domain (ctx, GETTEXT_PACKAGE); if (!g_option_context_parse (ctx, &argc, &argv, &error)) { g_printerr ("%s: %s: %s\n", _("Error"), _("option parsing failed"), error->message); exit (EXIT_FAILURE); } if (show_version) { g_print (PROJECT_NAME " " PROJECT_VERSION "\n"); exit (EXIT_SUCCESS); } if (argc != 2) { gchar *help = g_option_context_get_help (ctx, TRUE, FALSE); g_printerr ("%s", help); g_free (help); exit (EXIT_FAILURE); } g_option_context_free (ctx); app_init (&g_application, argv[1]); if (!initscr () || cbreak () == ERR || noecho () == ERR || nonl () == ERR) abort (); keypad (stdscr, TRUE); /* Enable character processing. */ nodelay (stdscr, TRUE); /* Don't block on get_wch(). */ mousemask (ALL_MOUSE_EVENTS, NULL); /* Register mouse events. */ mouseinterval (0); if (pipe (g_winch_pipe) == -1) abort (); install_winch_handler (); app_redraw (&g_application); /* Message loop. */ struct pollfd pollfd[2]; pollfd[0].fd = fileno (stdin); pollfd[0].events = POLLIN; pollfd[1].fd = g_winch_pipe[0]; pollfd[1].events = POLLIN; while (TRUE) { if (poll_restart (pollfd, 2, -1) == -1) abort (); if ((pollfd[0].revents & POLLIN) && !process_stdin_input ()) break; if ((pollfd[1].revents & POLLIN) && !process_winch_input (pollfd[1].fd)) break; } endwin (); app_destroy (&g_application); if (close (g_winch_pipe[0]) == -1 || close (g_winch_pipe[1]) == -1) abort (); return 0; }