void backspace(editor_t *ed)
{
if (erase_selection(ed)) return;
if (ed->linepos + ed->col == 0) return;
if (ed->col == 0)
{
int pos = ed->linepos;
erase(ed, --pos, 1);
if (get(ed, pos - 1) == '\r') erase(ed, --pos, 1);
ed->line--;
ed->linepos = line_start(ed, pos);
ed->col = pos - ed->linepos;
ed->refresh = 1;
if (ed->line < ed->topline)
{
ed->toppos = ed->linepos;
ed->topline = ed->line;
}
}
else
{
ed->col--;
erase(ed, ed->linepos + ed->col, 1);
ed->lineupdate = 1;
}
ed->lastcol = ed->col;
adjust(ed);
}
void paste_selection(editor_t *ed)
{
erase_selection(ed);
insert(ed, ed->linepos + ed->col, ed->clipboard, ed->clipsize);
moveto(ed, ed->linepos + ed->col + ed->clipsize, 0);
ed->refresh = 1;
}
void del(editor_t *ed)
{
int pos, ch;
if (erase_selection(ed)) return;
pos = ed->linepos + ed->col;
ch = get(ed, pos);
if (ch < 0) return;
erase(ed, pos, 1);
if (ch == '\r')
{
ch = get(ed, pos);
if (ch == '\n') erase(ed, pos, 1);
}
if (ch == '\n')
{
ed->refresh = 1;
}
else
{
ed->lineupdate = 1;
}
}
static void
insert_function_into_syntax_area (GtkTreeIter iter,
GtkWidget *text_view,
GtkTreeModel *model,
gpointer data
)
{
GString *string;
GValue name_value = {0};
GValue arity_value = {0};
gint arity;
gint i;
GtkTextBuffer *buffer ;
g_return_if_fail (GTK_IS_TEXT_VIEW (text_view));
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (text_view));
gtk_tree_model_get_value (model, &iter, COMPUTE_COL_NAME, &name_value);
gtk_tree_model_get_value (model, &iter, COMPUTE_COL_ARITY, &arity_value);
arity = g_value_get_int (&arity_value);
string = g_string_new (g_value_get_string (&name_value));
g_string_append (string, "(");
for ( i = 0 ; i < arity -1 ; ++i )
{
g_string_append (string, "?,");
}
g_string_append (string, "?)");
erase_selection (buffer);
gtk_text_buffer_insert_at_cursor (buffer, string->str, string->len);
g_value_unset (&name_value);
g_value_unset (&arity_value);
g_string_free (string, TRUE);
/* Now position the cursor over the first '?' */
{
GtkTextIter insert;
GtkTextIter selectbound;
GtkTextMark *cursor = gtk_text_buffer_get_insert (buffer);
gtk_text_buffer_get_iter_at_mark (buffer, &insert, cursor);
for ( i = 0 ; i < arity ; ++i )
{
gtk_text_iter_backward_cursor_position (&insert);
gtk_text_iter_backward_cursor_position (&insert);
}
selectbound = insert;
gtk_text_iter_forward_cursor_position (&selectbound);
gtk_text_buffer_select_range (buffer, &insert, &selectbound);
}
}
void insert_char(editor_t *ed, char ch)
{
erase_selection(ed);
insert(ed, ed->linepos + ed->col, &ch, 1);
ed->col++;
ed->lastcol = ed->col;
adjust(ed);
if (!ed->refresh) ed->lineupdate = 1;
}
static void
erase (PsppireKeypad *kp, gpointer data)
{
GtkBuilder *xml = data;
GtkWidget *rhs = get_widget_assert (xml, "compute-textview1");
GtkTextBuffer *buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (rhs));
erase_selection (buffer);
}
/* Inserts the name of the selected variable into the destination widget.
The destination widget must be a GtkTextView
*/
static void
insert_source_row_into_text_view (GtkTreeIter iter,
GtkWidget *dest,
GtkTreeModel *model,
gpointer data
)
{
GtkTreePath *path;
PsppireDict *dict;
gint *idx;
struct variable *var;
GtkTreeIter dict_iter;
GtkTextBuffer *buffer;
g_return_if_fail (GTK_IS_TEXT_VIEW (dest));
if ( GTK_IS_TREE_MODEL_FILTER (model))
{
dict = PSPPIRE_DICT (gtk_tree_model_filter_get_model
(GTK_TREE_MODEL_FILTER(model)));
gtk_tree_model_filter_convert_iter_to_child_iter (GTK_TREE_MODEL_FILTER
(model),
&dict_iter, &iter);
}
else
{
dict = PSPPIRE_DICT (model);
dict_iter = iter;
}
path = gtk_tree_model_get_path (GTK_TREE_MODEL (dict), &dict_iter);
idx = gtk_tree_path_get_indices (path);
var = psppire_dict_get_variable (dict, *idx);
gtk_tree_path_free (path);
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (dest));
erase_selection (buffer);
gtk_text_buffer_insert_at_cursor (buffer, var_get_name (var), -1);
}
void newline(editor_t *ed)
{
int p;
char ch;
erase_selection(ed);
insert(ed, ed->linepos + ed->col, "\r\n", 2);
ed->col = ed->lastcol = 0;
ed->line++;
p = ed->linepos;
ed->linepos = next_line(ed, ed->linepos);
/*
for (;;)
{
ch = get(ed, p++);
if (ch == ' ' || ch == '\t')
{
insert(ed, ed->linepos + ed->col, &ch, 1);
ed->col++;
}
else
{
break;
}
}
*/
ed->lastcol = ed->col;
ed->refresh = 1;
if (ed->line >= ed->topline + ed->lines)
{
ed->toppos = next_line(ed, ed->toppos);
ed->topline++;
ed->refresh = 1;
}
adjust(ed);
}
static void
on_keypad_button (PsppireKeypad *kp, const gchar *syntax, gpointer data)
{
GtkBuilder *xml = data;
GtkWidget *rhs = get_widget_assert (xml, "compute-textview1");
GtkTextBuffer *buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (rhs));
erase_selection (buffer);
gtk_text_buffer_insert_at_cursor (buffer, syntax, strlen (syntax));
if (0 == strcmp (syntax, "()"))
{
GtkTextIter iter;
GtkTextMark *cursor = gtk_text_buffer_get_insert (buffer);
gtk_text_buffer_get_iter_at_mark (buffer, &iter, cursor);
gtk_text_iter_backward_cursor_position (&iter);
gtk_text_buffer_move_mark (buffer, cursor, &iter);
}
}
int
vim_run_choose_cmd(const FileView *view)
{
char *expanded_cmd;
if(is_null_or_empty(curr_stats.on_choose))
{
return 0;
}
if(!view->dir_entry[view->list_pos].selected)
{
erase_selection(curr_view);
}
expanded_cmd = expand_macros(curr_stats.on_choose, NULL, NULL, 1);
if(vifm_system(expanded_cmd) != EXIT_SUCCESS)
{
free(expanded_cmd);
return 1;
}
return 0;
}
void textbox::handle_event(const SDL_Event& event)
{
scrollarea::handle_event(event);
if(hidden())
return;
bool changed = false;
const int old_selstart = selstart_;
const int old_selend = selend_;
//Sanity check: verify that selection start and end are within text
//boundaries
if(is_selection() && !(size_t(selstart_) <= text_.size() && size_t(selend_) <= text_.size())) {
WRN_DP << "out-of-boundary selection\n";
selstart_ = selend_ = -1;
}
int mousex, mousey;
const Uint8 mousebuttons = SDL_GetMouseState(&mousex,&mousey);
if(!(mousebuttons & SDL_BUTTON(1))) {
grabmouse_ = false;
}
SDL_Rect const &loc = inner_location();
bool clicked_inside = !mouse_locked() && (event.type == SDL_MOUSEBUTTONDOWN
&& (mousebuttons & SDL_BUTTON(1))
&& point_in_rect(mousex, mousey, loc));
if(clicked_inside) {
set_focus(true);
}
if ((grabmouse_ && (!mouse_locked() && event.type == SDL_MOUSEMOTION)) || clicked_inside) {
const int x = mousex - loc.x + text_pos_;
const int y = mousey - loc.y;
int pos = 0;
int distance = x;
for(unsigned int i = 1; i < char_x_.size(); ++i) {
if(static_cast<int>(yscroll_) + y < char_y_[i]) {
break;
}
// Check individually each distance (if, one day, we support
// RTL languages, char_x_[c] may not be monotonous.)
if(abs(x - char_x_[i]) < distance && yscroll_ + y < char_y_[i] + line_height_) {
pos = i;
distance = abs(x - char_x_[i]);
}
}
cursor_ = pos;
if(grabmouse_)
selend_ = cursor_;
update_text_cache(false);
if(!grabmouse_ && mousebuttons & SDL_BUTTON(1)) {
grabmouse_ = true;
selstart_ = selend_ = cursor_;
} else if (! (mousebuttons & SDL_BUTTON(1))) {
grabmouse_ = false;
}
set_dirty();
}
if(editable_ == false) {
return;
}
//if we don't have the focus, then see if we gain the focus,
//otherwise return
if(focus(&event) == false) {
if (!mouse_locked() && event.type == SDL_MOUSEMOTION && point_in_rect(mousex, mousey, loc))
events::focus_handler(this);
return;
}
if(event.type != SDL_KEYDOWN || focus(&event) != true) {
draw();
return;
}
const SDL_keysym& key = reinterpret_cast<const SDL_KeyboardEvent&>(event).keysym;
const SDLMod modifiers = SDL_GetModState();
const int c = key.sym;
const int old_cursor = cursor_;
if(c == SDLK_LEFT && cursor_ > 0)
--cursor_;
if(c == SDLK_RIGHT && cursor_ < static_cast<int>(text_.size()))
++cursor_;
// ctrl-a, ctrl-e and ctrl-u are readline style shortcuts, even on Macs
if(c == SDLK_END || (c == SDLK_e && (modifiers & KMOD_CTRL)))
cursor_ = text_.size();
if(c == SDLK_HOME || (c == SDLK_a && (modifiers & KMOD_CTRL)))
cursor_ = 0;
if((old_cursor != cursor_) && (modifiers & KMOD_SHIFT)) {
if(selstart_ == -1)
selstart_ = old_cursor;
selend_ = cursor_;
}
if(c == SDLK_BACKSPACE) {
changed = true;
if(is_selection()) {
erase_selection();
} else if(cursor_ > 0) {
--cursor_;
text_.erase(text_.begin()+cursor_);
}
}
if(c == SDLK_u && (modifiers & KMOD_CTRL)) { // clear line
changed = true;
cursor_ = 0;
text_.resize(0);
}
if(c == SDLK_DELETE && !text_.empty()) {
changed = true;
if(is_selection()) {
erase_selection();
} else {
if(cursor_ < static_cast<int>(text_.size())) {
text_.erase(text_.begin()+cursor_);
}
}
}
wchar_t character = key.unicode;
//movement characters may have a "Unicode" field on some platforms, so ignore it.
if(!(c == SDLK_UP || c == SDLK_DOWN || c == SDLK_LEFT || c == SDLK_RIGHT ||
c == SDLK_DELETE || c == SDLK_BACKSPACE || c == SDLK_END || c == SDLK_HOME ||
c == SDLK_PAGEUP || c == SDLK_PAGEDOWN)) {
if(character != 0) {
DBG_G << "Char: " << character << ", c = " << c << "\n";
}
if(event.key.keysym.mod & copypaste_modifier) {
switch(c) {
case SDLK_v: // paste
{
changed = true;
if(is_selection())
erase_selection();
std::string str = copy_from_clipboard(false);
//cut off anything after the first newline
str.erase(std::find_if(str.begin(),str.end(),utils::isnewline),str.end());
wide_string s = utils::string_to_wstring(str);
if(text_.size() < max_size_) {
if(s.size() + text_.size() > max_size_) {
s.resize(max_size_ - text_.size());
}
text_.insert(text_.begin()+cursor_, s.begin(), s.end());
cursor_ += s.size();
}
}
break;
case SDLK_c: // copy
{
const size_t beg = std::min<size_t>(size_t(selstart_),size_t(selend_));
const size_t end = std::max<size_t>(size_t(selstart_),size_t(selend_));
wide_string ws = wide_string(text_.begin() + beg, text_.begin() + end);
std::string s = utils::wstring_to_string(ws);
copy_to_clipboard(s, false);
}
break;
}
} else {
if(character >= 32 && character != 127) {
changed = true;
if(is_selection())
erase_selection();
if(text_.size() + 1 <= max_size_) {
text_.insert(text_.begin()+cursor_,character);
++cursor_;
}
}
}
}
if(is_selection() && (selend_ != cursor_))
selstart_ = selend_ = -1;
//since there has been cursor activity, make the cursor appear for
//at least the next 500ms.
show_cursor_ = true;
show_cursor_at_ = SDL_GetTicks();
if(changed || old_cursor != cursor_ || old_selstart != selstart_ || old_selend != selend_) {
text_image_ = NULL;
handle_text_changed(text_);
}
set_dirty(true);
}
void cut_selection(editor_t *ed)
{
copy_selection(ed);
erase_selection(ed);
}
