2012-10-21 15:02:20 -04:00
|
|
|
/*
|
2013-02-02 14:57:46 -05:00
|
|
|
* inputwin.c
|
2012-02-20 15:07:38 -05:00
|
|
|
*
|
2014-03-08 20:18:19 -05:00
|
|
|
* Copyright (C) 2012 - 2014 James Booth <boothj5@gmail.com>
|
2012-10-21 15:02:20 -04:00
|
|
|
*
|
2012-02-20 15:07:38 -05:00
|
|
|
* This file is part of Profanity.
|
|
|
|
*
|
|
|
|
* Profanity is free software: you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License as published by
|
|
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
|
|
* (at your option) any later version.
|
|
|
|
*
|
|
|
|
* Profanity is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with Profanity. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
*
|
2014-08-24 15:57:39 -04:00
|
|
|
* In addition, as a special exception, the copyright holders give permission to
|
|
|
|
* link the code of portions of this program with the OpenSSL library under
|
|
|
|
* certain conditions as described in each individual source file, and
|
|
|
|
* distribute linked combinations including the two.
|
|
|
|
*
|
|
|
|
* You must obey the GNU General Public License in all respects for all of the
|
|
|
|
* code used other than OpenSSL. If you modify file(s) with this exception, you
|
|
|
|
* may extend this exception to your version of the file(s), but you are not
|
|
|
|
* obligated to do so. If you do not wish to do so, delete this exception
|
|
|
|
* statement from your version. If you delete this exception statement from all
|
|
|
|
* source files in the program, then also delete it here.
|
|
|
|
*
|
2012-02-20 15:07:38 -05:00
|
|
|
*/
|
|
|
|
|
2013-01-02 19:16:39 -05:00
|
|
|
#define _XOPEN_SOURCE_EXTENDED
|
2012-09-08 11:51:09 -04:00
|
|
|
#include "config.h"
|
|
|
|
|
2012-03-10 17:32:07 -05:00
|
|
|
#include <stdlib.h>
|
2012-08-25 20:50:50 -04:00
|
|
|
#include <string.h>
|
2013-01-02 19:16:39 -05:00
|
|
|
#include <wchar.h>
|
2012-05-10 18:51:06 -04:00
|
|
|
|
2013-01-02 15:27:37 -05:00
|
|
|
#ifdef HAVE_NCURSESW_NCURSES_H
|
|
|
|
#include <ncursesw/ncurses.h>
|
2013-01-03 19:35:54 -05:00
|
|
|
#elif HAVE_NCURSES_H
|
|
|
|
#include <ncurses.h>
|
2012-09-08 11:51:09 -04:00
|
|
|
#endif
|
2012-05-10 18:51:06 -04:00
|
|
|
|
2013-02-02 16:43:59 -05:00
|
|
|
#include "command/command.h"
|
2013-02-02 15:55:58 -05:00
|
|
|
#include "common.h"
|
2013-11-07 17:15:43 -05:00
|
|
|
#include "config/accounts.h"
|
2013-02-02 16:59:29 -05:00
|
|
|
#include "config/preferences.h"
|
|
|
|
#include "config/theme.h"
|
2012-10-30 21:36:52 -04:00
|
|
|
#include "log.h"
|
2014-07-08 19:35:43 -04:00
|
|
|
#include "muc.h"
|
2012-11-19 18:15:42 -05:00
|
|
|
#include "profanity.h"
|
2013-12-14 10:34:17 -05:00
|
|
|
#include "roster_list.h"
|
2013-02-02 15:55:58 -05:00
|
|
|
#include "ui/ui.h"
|
2014-04-07 16:12:30 -04:00
|
|
|
#include "ui/statusbar.h"
|
2014-04-07 16:50:28 -04:00
|
|
|
#include "ui/inputwin.h"
|
2013-09-25 15:51:54 -04:00
|
|
|
#include "ui/windows.h"
|
2013-05-06 18:04:46 -04:00
|
|
|
#include "xmpp/xmpp.h"
|
2012-02-08 18:55:11 -05:00
|
|
|
|
2014-04-01 16:52:04 -04:00
|
|
|
#define _inp_win_update_virtual() pnoutrefresh(inp_win, 0, pad_start, rows-1, 0, rows-1, cols-1)
|
2013-01-05 20:06:12 -05:00
|
|
|
|
2015-01-01 17:36:48 -05:00
|
|
|
#define KEY_CTRL_A 0001
|
|
|
|
#define KEY_CTRL_B 0002
|
|
|
|
#define KEY_CTRL_D 0004
|
|
|
|
#define KEY_CTRL_E 0005
|
|
|
|
#define KEY_CTRL_F 0006
|
|
|
|
#define KEY_CTRL_N 0016
|
|
|
|
#define KEY_CTRL_P 0020
|
|
|
|
#define KEY_CTRL_U 0025
|
|
|
|
#define KEY_CTRL_W 0027
|
|
|
|
|
2012-02-08 18:55:11 -05:00
|
|
|
static WINDOW *inp_win;
|
2012-07-07 16:51:43 -04:00
|
|
|
static int pad_start = 0;
|
2013-01-05 20:06:12 -05:00
|
|
|
static int rows, cols;
|
2012-02-08 18:55:11 -05:00
|
|
|
|
2013-01-16 19:28:44 -05:00
|
|
|
static int _handle_edit(int result, const wint_t ch, char *input, int *size);
|
2013-03-02 18:01:12 -05:00
|
|
|
static int _handle_alt_key(char *input, int *size, int key);
|
2013-09-08 11:14:26 -04:00
|
|
|
static void _handle_backspace(int display_size, int inp_x, int *size, char *input);
|
2013-01-02 19:16:39 -05:00
|
|
|
static int _printable(const wint_t ch);
|
2013-01-05 20:06:12 -05:00
|
|
|
static void _clear_input(void);
|
|
|
|
static void _go_to_end(int display_size);
|
2014-12-01 16:45:08 -05:00
|
|
|
static void _delete_previous_word(char *input, int *size);
|
2012-02-29 18:15:27 -05:00
|
|
|
|
2014-04-07 16:50:28 -04:00
|
|
|
void
|
|
|
|
create_input_window(void)
|
2012-02-08 18:55:11 -05:00
|
|
|
{
|
2012-10-22 20:31:19 -04:00
|
|
|
#ifdef NCURSES_REENTRANT
|
|
|
|
set_escdelay(25);
|
|
|
|
#else
|
|
|
|
ESCDELAY = 25;
|
|
|
|
#endif
|
2012-02-08 18:55:11 -05:00
|
|
|
getmaxyx(stdscr, rows, cols);
|
2012-07-09 18:48:53 -04:00
|
|
|
inp_win = newpad(1, INP_WIN_MAX);
|
2014-11-16 15:40:19 -05:00
|
|
|
wbkgd(inp_win, theme_attrs(THEME_INPUT_TEXT));;
|
2012-02-08 18:55:11 -05:00
|
|
|
keypad(inp_win, TRUE);
|
2012-07-07 21:43:28 -04:00
|
|
|
wmove(inp_win, 0, 0);
|
2014-04-01 16:52:04 -04:00
|
|
|
_inp_win_update_virtual();
|
2012-02-08 18:55:11 -05:00
|
|
|
}
|
|
|
|
|
2014-04-07 16:50:28 -04:00
|
|
|
void
|
2014-11-19 11:32:26 -05:00
|
|
|
inp_win_resize(void)
|
2012-04-22 15:59:36 -04:00
|
|
|
{
|
2013-01-05 20:06:12 -05:00
|
|
|
int inp_x;
|
2012-04-22 15:59:36 -04:00
|
|
|
getmaxyx(stdscr, rows, cols);
|
2012-09-10 17:57:42 -04:00
|
|
|
inp_x = getcurx(inp_win);
|
2012-10-21 15:02:20 -04:00
|
|
|
|
2012-07-07 22:31:54 -04:00
|
|
|
// if lost cursor off screen, move contents to show it
|
|
|
|
if (inp_x >= pad_start + cols) {
|
2012-07-09 18:48:53 -04:00
|
|
|
pad_start = inp_x - (cols / 2);
|
|
|
|
if (pad_start < 0) {
|
|
|
|
pad_start = 0;
|
|
|
|
}
|
2012-07-07 22:31:54 -04:00
|
|
|
}
|
|
|
|
|
2014-11-19 11:32:26 -05:00
|
|
|
wbkgd(inp_win, theme_attrs(THEME_INPUT_TEXT));;
|
2014-04-01 16:52:04 -04:00
|
|
|
_inp_win_update_virtual();
|
2012-02-08 18:55:11 -05:00
|
|
|
}
|
|
|
|
|
2014-04-07 16:50:28 -04:00
|
|
|
void
|
|
|
|
inp_non_block(void)
|
2012-02-08 18:55:11 -05:00
|
|
|
{
|
2014-12-21 13:15:29 -05:00
|
|
|
wtimeout(inp_win, prefs_get_inpblock());
|
2012-02-08 18:55:11 -05:00
|
|
|
}
|
|
|
|
|
2014-04-07 16:50:28 -04:00
|
|
|
void
|
|
|
|
inp_block(void)
|
2012-02-16 19:42:41 -05:00
|
|
|
{
|
|
|
|
wtimeout(inp_win, -1);
|
|
|
|
}
|
|
|
|
|
2014-04-07 16:50:28 -04:00
|
|
|
wint_t
|
2014-10-07 16:12:19 -04:00
|
|
|
inp_get_char(char *input, int *size, int *result)
|
2012-02-08 18:55:11 -05:00
|
|
|
{
|
2013-01-02 19:16:39 -05:00
|
|
|
wint_t ch;
|
|
|
|
int display_size = 0;
|
|
|
|
|
|
|
|
if (*size != 0) {
|
|
|
|
display_size = g_utf8_strlen(input, *size);
|
|
|
|
}
|
2012-10-21 15:02:20 -04:00
|
|
|
|
2012-07-07 16:24:39 -04:00
|
|
|
// echo off, and get some more input
|
2012-02-08 18:55:11 -05:00
|
|
|
noecho();
|
2014-10-07 16:12:19 -04:00
|
|
|
*result = wget_wch(inp_win, &ch);
|
2012-02-08 18:55:11 -05:00
|
|
|
|
2015-01-07 19:57:25 -05:00
|
|
|
// gboolean in_command = FALSE;
|
|
|
|
// if ((display_size > 0 && input[0] == '/') ||
|
|
|
|
// (display_size == 0 && ch == '/')) {
|
|
|
|
// in_command = TRUE;
|
|
|
|
// }
|
|
|
|
|
|
|
|
// if (*result == ERR) {
|
|
|
|
// prof_handle_idle();
|
|
|
|
// }
|
|
|
|
// if ((*result != ERR) && (*result != KEY_CODE_YES) && !in_command && _printable(ch)) {
|
|
|
|
// prof_handle_activity();
|
|
|
|
// }
|
2013-01-17 14:43:49 -05:00
|
|
|
|
2012-04-17 17:43:35 -04:00
|
|
|
// if it wasn't an arrow key etc
|
2014-10-07 16:12:19 -04:00
|
|
|
if (!_handle_edit(*result, ch, input, size)) {
|
|
|
|
if (_printable(ch) && *result != KEY_CODE_YES) {
|
2014-04-02 17:19:27 -04:00
|
|
|
if (*size >= INP_WIN_MAX) {
|
|
|
|
return ERR;
|
|
|
|
}
|
|
|
|
|
2014-04-25 19:36:36 -04:00
|
|
|
int inp_x = getcurx(inp_win);
|
2012-10-21 15:02:20 -04:00
|
|
|
|
2012-04-17 17:43:35 -04:00
|
|
|
// handle insert if not at end of input
|
2013-01-02 19:16:39 -05:00
|
|
|
if (inp_x < display_size) {
|
2013-01-03 19:57:02 -05:00
|
|
|
char bytes[MB_CUR_MAX];
|
2013-01-03 17:41:03 -05:00
|
|
|
size_t utf_len = wcrtomb(bytes, ch, NULL);
|
2012-04-17 17:43:35 -04:00
|
|
|
|
2013-01-03 17:41:03 -05:00
|
|
|
char *next_ch = g_utf8_offset_to_pointer(input, inp_x);
|
|
|
|
char *offset;
|
|
|
|
for (offset = &input[*size - 1]; offset >= next_ch; offset--) {
|
|
|
|
*(offset + utf_len) = *offset;
|
|
|
|
}
|
2014-04-25 19:36:36 -04:00
|
|
|
int i;
|
2013-01-03 17:41:03 -05:00
|
|
|
for (i = 0; i < utf_len; i++) {
|
|
|
|
*(next_ch + i) = bytes[i];
|
|
|
|
}
|
2012-04-17 17:43:35 -04:00
|
|
|
|
2013-01-03 17:41:03 -05:00
|
|
|
*size += utf_len;
|
|
|
|
input[*size] = '\0';
|
2013-02-09 15:39:52 -05:00
|
|
|
waddstr(inp_win, next_ch);
|
2013-01-05 19:20:34 -05:00
|
|
|
wmove(inp_win, 0, inp_x + 1);
|
2012-04-17 17:43:35 -04:00
|
|
|
|
2013-01-05 17:30:21 -05:00
|
|
|
if (inp_x - pad_start > cols-3) {
|
|
|
|
pad_start++;
|
2014-04-01 16:52:04 -04:00
|
|
|
_inp_win_update_virtual();
|
2013-01-05 17:30:21 -05:00
|
|
|
}
|
|
|
|
|
2012-04-17 17:43:35 -04:00
|
|
|
// otherwise just append
|
|
|
|
} else {
|
2013-01-05 17:37:11 -05:00
|
|
|
char bytes[MB_CUR_MAX+1];
|
2013-01-03 20:06:42 -05:00
|
|
|
size_t utf_len = wcrtomb(bytes, ch, NULL);
|
2012-10-21 15:02:20 -04:00
|
|
|
|
2013-01-05 17:56:59 -05:00
|
|
|
// wcrtomb can return (size_t) -1
|
|
|
|
if (utf_len < MB_CUR_MAX) {
|
2014-04-25 19:36:36 -04:00
|
|
|
int i;
|
2013-01-05 17:56:59 -05:00
|
|
|
for (i = 0 ; i < utf_len; i++) {
|
|
|
|
input[(*size)++] = bytes[i];
|
|
|
|
}
|
|
|
|
input[*size] = '\0';
|
|
|
|
|
|
|
|
bytes[utf_len] = '\0';
|
2013-02-09 15:39:52 -05:00
|
|
|
waddstr(inp_win, bytes);
|
2013-01-05 17:56:59 -05:00
|
|
|
display_size++;
|
|
|
|
|
2013-01-05 19:24:11 -05:00
|
|
|
// if gone over screen size follow input
|
2013-01-05 17:56:59 -05:00
|
|
|
int rows, cols;
|
|
|
|
getmaxyx(stdscr, rows, cols);
|
|
|
|
if (display_size - pad_start > cols-2) {
|
|
|
|
pad_start++;
|
2014-04-01 16:52:04 -04:00
|
|
|
_inp_win_update_virtual();
|
2013-01-05 17:56:59 -05:00
|
|
|
}
|
2012-07-07 16:51:43 -04:00
|
|
|
}
|
2012-02-29 18:15:27 -05:00
|
|
|
}
|
2012-04-17 17:43:35 -04:00
|
|
|
|
2012-10-27 20:42:26 -04:00
|
|
|
cmd_reset_autocomplete();
|
2012-02-29 18:15:27 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
echo();
|
2013-01-02 19:16:39 -05:00
|
|
|
|
|
|
|
return ch;
|
2012-02-29 18:15:27 -05:00
|
|
|
}
|
|
|
|
|
2014-04-07 16:50:28 -04:00
|
|
|
void
|
|
|
|
inp_get_password(char *passwd)
|
2012-02-29 18:15:27 -05:00
|
|
|
{
|
2013-01-05 20:09:46 -05:00
|
|
|
_clear_input();
|
2014-04-01 16:52:04 -04:00
|
|
|
_inp_win_update_virtual();
|
2014-02-02 18:56:50 -05:00
|
|
|
doupdate();
|
2012-02-29 18:15:27 -05:00
|
|
|
noecho();
|
2013-11-07 17:15:43 -05:00
|
|
|
mvwgetnstr(inp_win, 0, 1, passwd, MAX_PASSWORD_SIZE);
|
2012-07-07 21:43:28 -04:00
|
|
|
wmove(inp_win, 0, 0);
|
2012-02-29 18:15:27 -05:00
|
|
|
echo();
|
|
|
|
status_bar_clear();
|
|
|
|
}
|
|
|
|
|
2014-04-07 16:50:28 -04:00
|
|
|
void
|
|
|
|
inp_put_back(void)
|
2012-02-29 18:15:27 -05:00
|
|
|
{
|
2014-04-01 16:52:04 -04:00
|
|
|
_inp_win_update_virtual();
|
2012-02-29 18:15:27 -05:00
|
|
|
}
|
|
|
|
|
2014-04-07 16:50:28 -04:00
|
|
|
void
|
|
|
|
inp_replace_input(char *input, const char * const new_input, int *size)
|
2012-10-27 20:08:04 -04:00
|
|
|
{
|
2013-01-05 20:06:12 -05:00
|
|
|
int display_size;
|
2014-04-02 16:01:20 -04:00
|
|
|
strncpy(input, new_input, INP_WIN_MAX);
|
2012-10-27 20:08:04 -04:00
|
|
|
*size = strlen(input);
|
2013-01-05 20:06:12 -05:00
|
|
|
display_size = g_utf8_strlen(input, *size);
|
|
|
|
inp_win_reset();
|
2013-01-02 20:03:14 -05:00
|
|
|
input[*size] = '\0';
|
2013-02-09 15:39:52 -05:00
|
|
|
waddstr(inp_win, input);
|
2013-01-05 20:06:12 -05:00
|
|
|
_go_to_end(display_size);
|
2012-10-27 20:08:04 -04:00
|
|
|
}
|
|
|
|
|
2014-04-07 16:50:28 -04:00
|
|
|
void
|
|
|
|
inp_win_reset(void)
|
2013-01-05 20:06:12 -05:00
|
|
|
{
|
|
|
|
_clear_input();
|
|
|
|
pad_start = 0;
|
2014-04-01 16:52:04 -04:00
|
|
|
_inp_win_update_virtual();
|
2013-01-05 20:06:12 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_clear_input(void)
|
|
|
|
{
|
2013-04-21 19:02:56 -04:00
|
|
|
werase(inp_win);
|
2013-01-05 20:06:12 -05:00
|
|
|
wmove(inp_win, 0, 0);
|
|
|
|
}
|
2012-10-27 20:08:04 -04:00
|
|
|
|
2012-02-29 18:15:27 -05:00
|
|
|
/*
|
|
|
|
* Deal with command editing, return 1 if ch was an edit
|
|
|
|
* key press: up, down, left, right or backspace
|
2014-08-27 07:26:11 -04:00
|
|
|
* return 0 if it wasn't
|
2012-02-29 18:15:27 -05:00
|
|
|
*/
|
2012-07-24 18:19:48 -04:00
|
|
|
static int
|
2013-01-16 19:28:44 -05:00
|
|
|
_handle_edit(int result, const wint_t ch, char *input, int *size)
|
2012-02-29 18:15:27 -05:00
|
|
|
{
|
|
|
|
char *prev = NULL;
|
|
|
|
char *next = NULL;
|
|
|
|
int inp_x = 0;
|
2012-11-23 20:57:24 -05:00
|
|
|
int next_ch;
|
2013-01-02 20:42:02 -05:00
|
|
|
int display_size = 0;
|
|
|
|
|
|
|
|
if (*size != 0) {
|
|
|
|
display_size = g_utf8_strlen(input, *size);
|
|
|
|
}
|
2012-10-21 15:02:20 -04:00
|
|
|
|
2013-01-05 19:20:34 -05:00
|
|
|
inp_x = getcurx(inp_win);
|
2012-02-29 18:15:27 -05:00
|
|
|
|
2013-01-16 19:28:44 -05:00
|
|
|
// CTRL-LEFT
|
2014-10-09 17:43:06 -04:00
|
|
|
if ((result == KEY_CODE_YES) && (ch == 547 || ch == 545 || ch == 544 || ch == 540 || ch == 539) && (inp_x > 0)) {
|
2013-01-16 19:28:44 -05:00
|
|
|
input[*size] = '\0';
|
|
|
|
gchar *curr_ch = g_utf8_offset_to_pointer(input, inp_x);
|
2013-01-16 19:59:40 -05:00
|
|
|
curr_ch = g_utf8_find_prev_char(input, curr_ch);
|
|
|
|
gchar *prev_ch;
|
|
|
|
gunichar curr_uni;
|
|
|
|
gunichar prev_uni;
|
2012-10-21 15:02:20 -04:00
|
|
|
|
2013-01-16 19:59:40 -05:00
|
|
|
while (curr_ch != NULL) {
|
|
|
|
curr_uni = g_utf8_get_char(curr_ch);
|
2013-01-16 19:28:44 -05:00
|
|
|
|
2013-01-16 19:59:40 -05:00
|
|
|
if (g_unichar_isspace(curr_uni)) {
|
|
|
|
curr_ch = g_utf8_find_prev_char(input, curr_ch);
|
|
|
|
} else {
|
|
|
|
prev_ch = g_utf8_find_prev_char(input, curr_ch);
|
|
|
|
if (prev_ch == NULL) {
|
|
|
|
curr_ch = NULL;
|
2012-11-23 20:57:24 -05:00
|
|
|
break;
|
2013-01-16 19:59:40 -05:00
|
|
|
} else {
|
|
|
|
prev_uni = g_utf8_get_char(prev_ch);
|
|
|
|
if (g_unichar_isspace(prev_uni)) {
|
|
|
|
break;
|
|
|
|
} else {
|
|
|
|
curr_ch = prev_ch;
|
|
|
|
}
|
2013-01-16 19:28:44 -05:00
|
|
|
}
|
|
|
|
}
|
2013-01-16 19:59:40 -05:00
|
|
|
}
|
2013-01-16 19:28:44 -05:00
|
|
|
|
2013-01-16 19:59:40 -05:00
|
|
|
if (curr_ch == NULL) {
|
|
|
|
inp_x = 0;
|
|
|
|
wmove(inp_win, 0, inp_x);
|
|
|
|
} else {
|
|
|
|
glong offset = g_utf8_pointer_to_offset(input, curr_ch);
|
|
|
|
inp_x = offset;
|
|
|
|
wmove(inp_win, 0, inp_x);
|
2012-11-23 20:57:24 -05:00
|
|
|
}
|
2013-01-16 19:59:40 -05:00
|
|
|
|
2013-01-16 19:28:44 -05:00
|
|
|
// if gone off screen to left, jump left (half a screen worth)
|
|
|
|
if (inp_x <= pad_start) {
|
|
|
|
pad_start = pad_start - (cols / 2);
|
|
|
|
if (pad_start < 0) {
|
|
|
|
pad_start = 0;
|
|
|
|
}
|
|
|
|
|
2014-04-01 16:52:04 -04:00
|
|
|
_inp_win_update_virtual();
|
2013-01-16 19:28:44 -05:00
|
|
|
}
|
|
|
|
return 1;
|
2013-01-16 19:59:40 -05:00
|
|
|
|
|
|
|
// CTRL-RIGHT
|
2014-10-09 17:43:06 -04:00
|
|
|
} else if ((result == KEY_CODE_YES) && (ch == 562 || ch == 560 || ch == 555 || ch == 559 || ch == 554) && (inp_x < display_size)) {
|
2013-01-16 21:21:00 -05:00
|
|
|
input[*size] = '\0';
|
|
|
|
gchar *curr_ch = g_utf8_offset_to_pointer(input, inp_x);
|
|
|
|
gchar *next_ch = g_utf8_find_next_char(curr_ch, NULL);
|
|
|
|
gunichar curr_uni;
|
|
|
|
gunichar next_uni;
|
|
|
|
gboolean moved = FALSE;
|
|
|
|
|
|
|
|
while (g_utf8_pointer_to_offset(input, next_ch) < display_size) {
|
|
|
|
curr_uni = g_utf8_get_char(curr_ch);
|
|
|
|
next_uni = g_utf8_get_char(next_ch);
|
|
|
|
curr_ch = next_ch;
|
|
|
|
next_ch = g_utf8_find_next_char(next_ch, NULL);
|
|
|
|
|
|
|
|
if (!g_unichar_isspace(curr_uni) && g_unichar_isspace(next_uni) && moved) {
|
|
|
|
break;
|
|
|
|
} else {
|
|
|
|
moved = TRUE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (next_ch == NULL) {
|
|
|
|
inp_x = display_size;
|
|
|
|
wmove(inp_win, 0, inp_x);
|
|
|
|
} else {
|
|
|
|
glong offset = g_utf8_pointer_to_offset(input, curr_ch);
|
2013-01-16 21:30:26 -05:00
|
|
|
if (offset == display_size - 1) {
|
|
|
|
inp_x = offset + 1;
|
|
|
|
} else {
|
|
|
|
inp_x = offset;
|
|
|
|
}
|
2013-01-16 21:21:00 -05:00
|
|
|
wmove(inp_win, 0, inp_x);
|
|
|
|
}
|
2013-01-16 19:59:40 -05:00
|
|
|
|
2013-01-16 21:21:00 -05:00
|
|
|
// if gone off screen to right, jump right (half a screen worth)
|
|
|
|
if (inp_x > pad_start + cols) {
|
|
|
|
pad_start = pad_start + (cols / 2);
|
2014-04-01 16:52:04 -04:00
|
|
|
_inp_win_update_virtual();
|
2013-01-16 19:59:40 -05:00
|
|
|
}
|
2013-01-16 21:21:00 -05:00
|
|
|
|
2013-01-16 19:28:44 -05:00
|
|
|
return 1;
|
2013-01-16 19:59:40 -05:00
|
|
|
|
2013-09-25 19:25:04 -04:00
|
|
|
// ALT-LEFT
|
2014-05-26 14:53:44 -04:00
|
|
|
} else if ((result == KEY_CODE_YES) && (ch == 537 || ch == 542)) {
|
2013-09-25 19:25:04 -04:00
|
|
|
ui_previous_win();
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
// ALT-RIGHT
|
2014-05-26 14:53:44 -04:00
|
|
|
} else if ((result == KEY_CODE_YES) && (ch == 552 || ch == 557)) {
|
2013-09-25 19:25:04 -04:00
|
|
|
ui_next_win();
|
|
|
|
return 1;
|
|
|
|
|
2013-01-16 19:59:40 -05:00
|
|
|
// other editing keys
|
2013-01-16 19:28:44 -05:00
|
|
|
} else {
|
|
|
|
switch(ch) {
|
|
|
|
|
|
|
|
case 27: // ESC
|
2013-03-02 18:01:12 -05:00
|
|
|
// check for ALT-key
|
2013-01-16 19:28:44 -05:00
|
|
|
next_ch = wgetch(inp_win);
|
|
|
|
if (next_ch != ERR) {
|
2013-03-02 18:01:12 -05:00
|
|
|
return _handle_alt_key(input, size, next_ch);
|
2013-01-16 19:28:44 -05:00
|
|
|
} else {
|
|
|
|
*size = 0;
|
|
|
|
inp_win_reset();
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
case 127:
|
2013-09-08 11:14:26 -04:00
|
|
|
_handle_backspace(display_size, inp_x, size, input);
|
|
|
|
return 1;
|
2013-01-16 19:28:44 -05:00
|
|
|
case KEY_BACKSPACE:
|
2013-09-04 18:14:35 -04:00
|
|
|
if (result != KEY_CODE_YES) {
|
|
|
|
return 0;
|
|
|
|
}
|
2013-09-08 11:14:26 -04:00
|
|
|
_handle_backspace(display_size, inp_x, size, input);
|
2013-01-16 19:28:44 -05:00
|
|
|
return 1;
|
2012-02-26 18:33:14 -05:00
|
|
|
|
2013-01-16 19:28:44 -05:00
|
|
|
case KEY_DC: // DEL
|
2013-09-04 18:14:35 -04:00
|
|
|
if (result != KEY_CODE_YES) {
|
|
|
|
return 0;
|
|
|
|
}
|
2014-12-31 01:36:54 -05:00
|
|
|
case KEY_CTRL_D:
|
2013-01-16 19:28:44 -05:00
|
|
|
if (inp_x == display_size-1) {
|
|
|
|
gchar *start = g_utf8_substring(input, 0, inp_x);
|
2013-01-03 18:54:12 -05:00
|
|
|
for (*size = 0; *size < strlen(start); (*size)++) {
|
|
|
|
input[*size] = start[*size];
|
2013-01-02 20:42:02 -05:00
|
|
|
}
|
2013-01-03 18:54:12 -05:00
|
|
|
input[*size] = '\0';
|
|
|
|
|
|
|
|
g_free(start);
|
|
|
|
|
2013-01-05 20:06:12 -05:00
|
|
|
_clear_input();
|
2013-02-09 15:39:52 -05:00
|
|
|
waddstr(inp_win, input);
|
2013-01-16 19:28:44 -05:00
|
|
|
} else if (inp_x < display_size-1) {
|
|
|
|
gchar *start = g_utf8_substring(input, 0, inp_x);
|
|
|
|
gchar *end = g_utf8_substring(input, inp_x+1, *size);
|
2013-01-03 18:47:45 -05:00
|
|
|
GString *new = g_string_new(start);
|
|
|
|
g_string_append(new, end);
|
|
|
|
|
|
|
|
for (*size = 0; *size < strlen(new->str); (*size)++) {
|
|
|
|
input[*size] = new->str[*size];
|
|
|
|
}
|
|
|
|
input[*size] = '\0';
|
|
|
|
|
|
|
|
g_free(start);
|
|
|
|
g_free(end);
|
|
|
|
g_string_free(new, FALSE);
|
2012-02-26 18:33:14 -05:00
|
|
|
|
2013-01-05 20:06:12 -05:00
|
|
|
_clear_input();
|
2013-02-09 15:39:52 -05:00
|
|
|
waddstr(inp_win, input);
|
2013-01-16 19:28:44 -05:00
|
|
|
wmove(inp_win, 0, inp_x);
|
2012-02-26 18:33:14 -05:00
|
|
|
}
|
2013-01-16 19:28:44 -05:00
|
|
|
return 1;
|
2012-07-09 18:48:53 -04:00
|
|
|
|
2013-01-16 19:28:44 -05:00
|
|
|
case KEY_LEFT:
|
2013-09-04 18:14:35 -04:00
|
|
|
if (result != KEY_CODE_YES) {
|
|
|
|
return 0;
|
|
|
|
}
|
2014-12-31 01:36:54 -05:00
|
|
|
case KEY_CTRL_B:
|
2013-01-16 19:28:44 -05:00
|
|
|
if (inp_x > 0) {
|
|
|
|
wmove(inp_win, 0, inp_x-1);
|
2012-02-08 18:55:11 -05:00
|
|
|
|
2013-01-16 19:28:44 -05:00
|
|
|
// current position off screen to left
|
|
|
|
if (inp_x - 1 < pad_start) {
|
|
|
|
pad_start--;
|
2014-04-01 16:52:04 -04:00
|
|
|
_inp_win_update_virtual();
|
2013-01-16 19:28:44 -05:00
|
|
|
}
|
2013-01-03 19:19:18 -05:00
|
|
|
}
|
2013-01-16 19:28:44 -05:00
|
|
|
return 1;
|
2012-10-21 15:02:20 -04:00
|
|
|
|
2013-01-16 19:28:44 -05:00
|
|
|
case KEY_RIGHT:
|
2013-09-04 18:14:35 -04:00
|
|
|
if (result != KEY_CODE_YES) {
|
|
|
|
return 0;
|
|
|
|
}
|
2014-12-31 01:36:54 -05:00
|
|
|
case KEY_CTRL_F:
|
2013-01-16 19:28:44 -05:00
|
|
|
if (inp_x < display_size) {
|
|
|
|
wmove(inp_win, 0, inp_x+1);
|
2013-01-03 19:19:18 -05:00
|
|
|
|
2013-01-16 19:28:44 -05:00
|
|
|
// current position off screen to right
|
|
|
|
if ((inp_x + 1 - pad_start) >= cols) {
|
|
|
|
pad_start++;
|
2014-04-01 16:52:04 -04:00
|
|
|
_inp_win_update_virtual();
|
2013-01-16 19:28:44 -05:00
|
|
|
}
|
2013-01-03 19:19:18 -05:00
|
|
|
}
|
2013-01-16 19:28:44 -05:00
|
|
|
return 1;
|
2013-01-03 19:19:18 -05:00
|
|
|
|
2013-01-16 19:28:44 -05:00
|
|
|
case KEY_UP:
|
2013-09-04 18:14:35 -04:00
|
|
|
if (result != KEY_CODE_YES) {
|
|
|
|
return 0;
|
|
|
|
}
|
2014-12-31 01:36:54 -05:00
|
|
|
case KEY_CTRL_P:
|
2013-01-27 20:35:11 -05:00
|
|
|
prev = cmd_history_previous(input, size);
|
2013-01-16 19:28:44 -05:00
|
|
|
if (prev) {
|
|
|
|
inp_replace_input(input, prev, size);
|
|
|
|
}
|
|
|
|
return 1;
|
2012-04-09 18:40:26 -04:00
|
|
|
|
2013-01-16 19:28:44 -05:00
|
|
|
case KEY_DOWN:
|
2013-09-04 18:14:35 -04:00
|
|
|
if (result != KEY_CODE_YES) {
|
|
|
|
return 0;
|
|
|
|
}
|
2014-12-31 01:36:54 -05:00
|
|
|
case KEY_CTRL_N:
|
2013-01-27 20:35:11 -05:00
|
|
|
next = cmd_history_next(input, size);
|
2013-01-16 19:28:44 -05:00
|
|
|
if (next) {
|
|
|
|
inp_replace_input(input, next, size);
|
2013-07-13 17:59:42 -04:00
|
|
|
} else if (*size != 0) {
|
|
|
|
input[*size] = '\0';
|
|
|
|
cmd_history_append(input);
|
|
|
|
inp_replace_input(input, "", size);
|
2013-01-16 19:28:44 -05:00
|
|
|
}
|
|
|
|
return 1;
|
2012-10-21 15:02:20 -04:00
|
|
|
|
2013-01-16 19:28:44 -05:00
|
|
|
case KEY_HOME:
|
2013-09-04 18:14:35 -04:00
|
|
|
if (result != KEY_CODE_YES) {
|
|
|
|
return 0;
|
|
|
|
}
|
2014-12-31 01:36:54 -05:00
|
|
|
case KEY_CTRL_A:
|
2013-01-16 19:28:44 -05:00
|
|
|
wmove(inp_win, 0, 0);
|
|
|
|
pad_start = 0;
|
2014-04-01 16:52:04 -04:00
|
|
|
_inp_win_update_virtual();
|
2013-01-16 19:28:44 -05:00
|
|
|
return 1;
|
2012-10-21 15:02:20 -04:00
|
|
|
|
2013-01-16 19:28:44 -05:00
|
|
|
case KEY_END:
|
2013-09-04 18:14:35 -04:00
|
|
|
if (result != KEY_CODE_YES) {
|
|
|
|
return 0;
|
|
|
|
}
|
2014-12-31 01:36:54 -05:00
|
|
|
case KEY_CTRL_E:
|
2013-01-16 19:28:44 -05:00
|
|
|
_go_to_end(display_size);
|
|
|
|
return 1;
|
2012-02-29 18:15:27 -05:00
|
|
|
|
2013-01-16 19:28:44 -05:00
|
|
|
case 9: // tab
|
2014-07-08 20:04:54 -04:00
|
|
|
if (*size != 0) {
|
|
|
|
if ((strncmp(input, "/", 1) != 0) && (ui_current_win_type() == WIN_MUC)) {
|
|
|
|
muc_autocomplete(input, size);
|
|
|
|
} else if (strncmp(input, "/", 1) == 0) {
|
|
|
|
cmd_autocomplete(input, size);
|
|
|
|
}
|
2014-07-08 19:35:43 -04:00
|
|
|
}
|
2013-01-16 19:28:44 -05:00
|
|
|
return 1;
|
2012-07-07 21:21:39 -04:00
|
|
|
|
2014-12-31 01:36:54 -05:00
|
|
|
case KEY_CTRL_W:
|
2014-12-01 16:45:08 -05:00
|
|
|
_delete_previous_word(input, size);
|
|
|
|
return 1;
|
|
|
|
break;
|
2014-12-31 01:36:54 -05:00
|
|
|
|
|
|
|
case KEY_CTRL_U:
|
2015-01-01 17:44:21 -05:00
|
|
|
while (getcurx(inp_win) > 0) {
|
|
|
|
_delete_previous_word(input, size);
|
|
|
|
}
|
2014-12-31 01:36:54 -05:00
|
|
|
return 1;
|
|
|
|
break;
|
|
|
|
|
2013-01-16 19:28:44 -05:00
|
|
|
default:
|
|
|
|
return 0;
|
2012-07-07 22:18:39 -04:00
|
|
|
}
|
2012-02-08 18:55:11 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-09-08 11:14:26 -04:00
|
|
|
static void
|
|
|
|
_handle_backspace(int display_size, int inp_x, int *size, char *input)
|
|
|
|
{
|
|
|
|
roster_reset_search_attempts();
|
|
|
|
if (display_size > 0) {
|
|
|
|
|
|
|
|
// if at end, delete last char
|
|
|
|
if (inp_x >= display_size) {
|
|
|
|
gchar *start = g_utf8_substring(input, 0, inp_x-1);
|
|
|
|
for (*size = 0; *size < strlen(start); (*size)++) {
|
|
|
|
input[*size] = start[*size];
|
|
|
|
}
|
|
|
|
input[*size] = '\0';
|
|
|
|
|
|
|
|
g_free(start);
|
|
|
|
|
|
|
|
_clear_input();
|
|
|
|
waddstr(inp_win, input);
|
|
|
|
wmove(inp_win, 0, inp_x -1);
|
|
|
|
|
|
|
|
// if in middle, delete and shift chars left
|
|
|
|
} else if (inp_x > 0 && inp_x < display_size) {
|
|
|
|
gchar *start = g_utf8_substring(input, 0, inp_x - 1);
|
|
|
|
gchar *end = g_utf8_substring(input, inp_x, *size);
|
|
|
|
GString *new = g_string_new(start);
|
|
|
|
g_string_append(new, end);
|
|
|
|
|
|
|
|
for (*size = 0; *size < strlen(new->str); (*size)++) {
|
|
|
|
input[*size] = new->str[*size];
|
|
|
|
}
|
|
|
|
input[*size] = '\0';
|
|
|
|
|
|
|
|
g_free(start);
|
|
|
|
g_free(end);
|
|
|
|
g_string_free(new, FALSE);
|
|
|
|
|
|
|
|
_clear_input();
|
|
|
|
waddstr(inp_win, input);
|
|
|
|
wmove(inp_win, 0, inp_x -1);
|
|
|
|
}
|
|
|
|
|
|
|
|
// if gone off screen to left, jump left (half a screen worth)
|
|
|
|
if (inp_x <= pad_start) {
|
|
|
|
pad_start = pad_start - (cols / 2);
|
|
|
|
if (pad_start < 0) {
|
|
|
|
pad_start = 0;
|
|
|
|
}
|
|
|
|
|
2014-04-01 16:52:04 -04:00
|
|
|
_inp_win_update_virtual();
|
2013-09-08 11:14:26 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2013-03-02 18:01:12 -05:00
|
|
|
static int
|
|
|
|
_handle_alt_key(char *input, int *size, int key)
|
|
|
|
{
|
|
|
|
switch (key)
|
|
|
|
{
|
|
|
|
case '1':
|
2013-08-27 19:50:15 -04:00
|
|
|
ui_switch_win(1);
|
2013-03-02 18:01:12 -05:00
|
|
|
break;
|
|
|
|
case '2':
|
2013-08-27 19:50:15 -04:00
|
|
|
ui_switch_win(2);
|
2013-03-02 18:01:12 -05:00
|
|
|
break;
|
|
|
|
case '3':
|
2013-08-27 19:50:15 -04:00
|
|
|
ui_switch_win(3);
|
2013-03-02 18:01:12 -05:00
|
|
|
break;
|
|
|
|
case '4':
|
2013-08-27 19:50:15 -04:00
|
|
|
ui_switch_win(4);
|
2013-03-02 18:01:12 -05:00
|
|
|
break;
|
|
|
|
case '5':
|
2013-08-27 19:50:15 -04:00
|
|
|
ui_switch_win(5);
|
2013-03-02 18:01:12 -05:00
|
|
|
break;
|
|
|
|
case '6':
|
2013-08-27 19:50:15 -04:00
|
|
|
ui_switch_win(6);
|
2013-03-02 18:01:12 -05:00
|
|
|
break;
|
|
|
|
case '7':
|
2013-08-27 19:50:15 -04:00
|
|
|
ui_switch_win(7);
|
2013-03-02 18:01:12 -05:00
|
|
|
break;
|
|
|
|
case '8':
|
2013-08-27 19:50:15 -04:00
|
|
|
ui_switch_win(8);
|
2013-03-02 18:01:12 -05:00
|
|
|
break;
|
|
|
|
case '9':
|
2013-08-27 19:50:15 -04:00
|
|
|
ui_switch_win(9);
|
2013-03-02 18:01:12 -05:00
|
|
|
break;
|
|
|
|
case '0':
|
2013-08-27 19:50:15 -04:00
|
|
|
ui_switch_win(0);
|
2013-03-02 18:01:12 -05:00
|
|
|
break;
|
2013-09-25 15:51:54 -04:00
|
|
|
case KEY_LEFT:
|
2013-09-25 19:25:04 -04:00
|
|
|
ui_previous_win();
|
2013-09-25 15:51:54 -04:00
|
|
|
break;
|
|
|
|
case KEY_RIGHT:
|
2013-09-25 19:25:04 -04:00
|
|
|
ui_next_win();
|
2013-09-25 15:51:54 -04:00
|
|
|
break;
|
2013-03-04 03:31:02 -05:00
|
|
|
case 263:
|
2013-03-02 18:01:12 -05:00
|
|
|
case 127:
|
2014-12-01 16:45:08 -05:00
|
|
|
_delete_previous_word(input, size);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
return 1;
|
|
|
|
}
|
2013-03-02 21:23:16 -05:00
|
|
|
|
2014-12-01 16:45:08 -05:00
|
|
|
static void
|
|
|
|
_delete_previous_word(char *input, int *size)
|
|
|
|
{
|
|
|
|
int end_del = getcurx(inp_win);
|
|
|
|
int start_del = end_del;
|
2013-03-02 21:23:16 -05:00
|
|
|
|
2014-12-01 16:45:08 -05:00
|
|
|
input[*size] = '\0';
|
|
|
|
gchar *curr_ch = g_utf8_offset_to_pointer(input, end_del);
|
|
|
|
curr_ch = g_utf8_find_prev_char(input, curr_ch);
|
|
|
|
gchar *prev_ch;
|
|
|
|
gunichar curr_uni;
|
|
|
|
gunichar prev_uni;
|
2013-03-02 21:23:16 -05:00
|
|
|
|
2014-12-01 16:45:08 -05:00
|
|
|
while (curr_ch != NULL) {
|
|
|
|
curr_uni = g_utf8_get_char(curr_ch);
|
|
|
|
|
|
|
|
if (g_unichar_isspace(curr_uni)) {
|
|
|
|
curr_ch = g_utf8_find_prev_char(input, curr_ch);
|
|
|
|
} else {
|
|
|
|
prev_ch = g_utf8_find_prev_char(input, curr_ch);
|
|
|
|
if (prev_ch == NULL) {
|
|
|
|
curr_ch = NULL;
|
|
|
|
break;
|
2013-03-02 21:23:16 -05:00
|
|
|
} else {
|
2014-12-01 16:45:08 -05:00
|
|
|
prev_uni = g_utf8_get_char(prev_ch);
|
|
|
|
if (g_unichar_isspace(prev_uni)) {
|
|
|
|
break;
|
|
|
|
} else {
|
|
|
|
curr_ch = prev_ch;
|
|
|
|
}
|
2013-03-02 21:23:16 -05:00
|
|
|
}
|
2014-12-01 16:45:08 -05:00
|
|
|
}
|
|
|
|
}
|
2013-03-02 21:23:16 -05:00
|
|
|
|
2014-12-01 16:45:08 -05:00
|
|
|
if (curr_ch == NULL) {
|
|
|
|
start_del = 0;
|
|
|
|
} else {
|
|
|
|
start_del = g_utf8_pointer_to_offset(input, curr_ch);
|
|
|
|
}
|
2013-03-02 21:23:16 -05:00
|
|
|
|
2014-12-01 16:45:08 -05:00
|
|
|
gint len = g_utf8_strlen(input, -1);
|
|
|
|
gchar *start_string = g_utf8_substring(input, 0, start_del);
|
|
|
|
gchar *end_string = g_utf8_substring(input, end_del, len);
|
2013-03-02 21:23:16 -05:00
|
|
|
|
2014-12-01 16:45:08 -05:00
|
|
|
int i;
|
|
|
|
for (i = 0; i < strlen(start_string); i++) {
|
|
|
|
input[i] = start_string[i];
|
|
|
|
}
|
|
|
|
for (i = 0; i < strlen(end_string); i++) {
|
|
|
|
input[strlen(start_string)+i] = end_string[i];
|
|
|
|
}
|
2013-03-02 21:23:16 -05:00
|
|
|
|
2014-12-01 16:45:08 -05:00
|
|
|
*size = strlen(start_string)+i;
|
|
|
|
input[*size] = '\0';
|
2013-03-02 21:23:16 -05:00
|
|
|
|
2014-12-01 16:45:08 -05:00
|
|
|
_clear_input();
|
|
|
|
waddstr(inp_win, input);
|
|
|
|
wmove(inp_win, 0, start_del);
|
2013-03-02 21:23:16 -05:00
|
|
|
|
2014-12-01 16:45:08 -05:00
|
|
|
// if gone off screen to left, jump left (half a screen worth)
|
|
|
|
if (start_del <= pad_start) {
|
|
|
|
pad_start = pad_start - (cols / 2);
|
|
|
|
if (pad_start < 0) {
|
|
|
|
pad_start = 0;
|
|
|
|
}
|
2013-03-02 21:23:16 -05:00
|
|
|
|
2014-12-01 16:45:08 -05:00
|
|
|
_inp_win_update_virtual();
|
2013-03-02 18:01:12 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-01-05 17:45:34 -05:00
|
|
|
static void
|
2013-01-05 20:06:12 -05:00
|
|
|
_go_to_end(int display_size)
|
2013-01-05 17:45:34 -05:00
|
|
|
{
|
2013-01-05 19:20:34 -05:00
|
|
|
wmove(inp_win, 0, display_size);
|
2013-01-05 17:45:34 -05:00
|
|
|
if (display_size > cols-2) {
|
|
|
|
pad_start = display_size - cols + 1;
|
2014-04-01 16:52:04 -04:00
|
|
|
_inp_win_update_virtual();
|
2013-01-05 17:45:34 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-07-24 18:19:48 -04:00
|
|
|
static int
|
2013-01-02 19:16:39 -05:00
|
|
|
_printable(const wint_t ch)
|
2012-02-08 18:55:11 -05:00
|
|
|
{
|
2013-01-07 15:47:01 -05:00
|
|
|
char bytes[MB_CUR_MAX+1];
|
|
|
|
size_t utf_len = wcrtomb(bytes, ch, NULL);
|
|
|
|
bytes[utf_len] = '\0';
|
|
|
|
gunichar unichar = g_utf8_get_char(bytes);
|
|
|
|
return g_unichar_isprint(unichar) && (ch != KEY_MOUSE);
|
2014-04-25 19:36:36 -04:00
|
|
|
}
|