, where div is selected auto element = get_element(start_stored); if(std::any_of(void_elements.begin(), void_elements.end(), [&element](const std::string &e) { return e == element; })) { auto next = end_stored; next.forward_char(); get_buffer()->select_range(start_stored_prev, next); return; } start_backward_search = start_forward_search = end_stored; start_forward_search.forward_char(); } else if(start_angle_reversed_iter && end_angle_reversed_iter) { // If not inside angle brackets, for instance <>selection here start_backward_search = start_angle_reversed_iter; start_forward_search = end_angle_reversed_iter; } if(start_backward_search && start_forward_search) { Gtk::TextIter start_children, end_children; auto iter = start_backward_search; int depth = 0; // Search backward for opening element while(find_open_symbol_backward(iter, iter, '>', '<') && iter.backward_char()) { // Backward to > (end of opening element) start_children = iter; start_children.forward_chars(2); auto prev = iter; prev.backward_char(); bool no_child_element = *iter == '/' && *prev != '<'; // Excludes as it is always closing element of <> if(find_open_symbol_backward(iter, iter, '<', '>')) { // Backward to < if(!no_child_element) { iter.forward_char(); if(*iter == '/') { if(!iter.backward_chars(2)) break; --depth; continue; } auto element = get_element(iter); if(std::any_of(void_elements.begin(), void_elements.end(), [&element](const std::string &e) { return e == element; })) { if(!iter.backward_chars(2)) break; continue; } else if(depth == 0) { iter.backward_char(); auto start_selection = iter; iter = start_forward_search; // Search forward for closing element int depth = 0; while(find_close_symbol_forward(iter, iter, '>', '<') && iter.forward_char()) { // Forward to < (start of closing element) end_children = iter; end_children.backward_char(); if(*iter == '/') { if(iter.forward_char() && find_close_symbol_forward(iter, iter, '<', '>') && iter.forward_char()) { // Forward to > if(depth == 0) { if(start_children <= start_stored && end_children >= end_stored && (start_children != start_stored || end_children != end_stored)) // Select children get_buffer()->select_range(start_children, end_children); else get_buffer()->select_range(start_selection, iter); return; } else --depth; } else break; } else { auto element = get_element(iter); if(std::any_of(void_elements.begin(), void_elements.end(), [&element](const std::string &e) { return e == element; })) { if(!(find_close_symbol_forward(iter, iter, '<', '>') && iter.forward_char())) // Forward to > break; } else if(find_close_symbol_forward(iter, iter, '<', '>') && iter.backward_char()) { // Forward to > if(*iter == '/') iter.forward_chars(2); else { ++depth; iter.forward_chars(2); } } else break; } } break; } else if(!iter.backward_chars(2)) break; ++depth; } else if(!iter.backward_char()) break; } else break; } } } // Test for <> used for template arguments if(start_angle_iter && end_angle_iter && is_template_arguments(start_angle_iter, end_angle_iter)) { start_angle_iter.forward_char(); get_buffer()->select_range(start_angle_iter, end_angle_iter); return; } // Test for matching brackets and try select regions within brackets separated by ',' bool comma_used = false; bool select_matching_brackets = false; if((*start == '(' && *end == ')') || (*start == '[' && *end == ']') || (*start == '<' && *end == '>') || (*start == '{' && *end == '}')) { if(start_comma_iter && start < start_comma_iter) { start = start_comma_iter; comma_used = true; } if(end_comma_iter && end > end_comma_iter) { end = end_comma_iter; comma_used = true; } select_matching_brackets = true; } // Attempt to select a sentence, for instance: int a = 2; if(!is_bracket_language) { // If for instance cmake, meson or python if(!select_matching_brackets) { bool select_end_block = is_language({"cmake", "meson", "julia", "xml"}); auto get_tabs = [this](Gtk::TextIter iter) -> boost::optional { iter = get_buffer()->get_iter_at_line(iter.get_line()); int tabs = 0; while(!iter.ends_line() && (*iter == ' ' || *iter == '\t')) { tabs++; if(!iter.forward_char()) break; } if(iter.ends_line()) return {}; return tabs; }; start = start_stored; end = end_stored; // Select following line with code (for instance when inside comment) // Forward start to non-empty line forward_to_code(start); start = get_buffer()->get_iter_at_line(start.get_line()); while(!start.is_end() && (*start == ' ' || *start == '\t') && start.forward_char()) { } // Forward end of line if(start > end) end = start; end = get_iter_at_line_end(end.get_line()); while(end.backward_char() && (*end == ' ' || *end == '\t' || end.ends_line())) { } end.forward_char(); if(end == end_stored) // Cancel line selection if the line is already selected start = start_stored; if(start != start_stored || end != end_stored) { get_buffer()->select_range(start, end); return; } // Select current line // Backward to line start start = get_buffer()->get_iter_at_line(start.get_line()); auto start_tabs = get_tabs(start); while((*start == ' ' || *start == '\t' || start.ends_line()) && start.forward_char()) { } // Forward to line end end = get_iter_at_line_end(end.get_line()); bool include_children = false; if(start_tabs) { while(end.forward_char()) { auto tabs = get_tabs(end); if(tabs) { if(tabs > start_tabs) include_children = true; else if(tabs == start_tabs) { if(include_children && select_end_block) end = get_iter_at_line_end(end.get_line()); break; } else break; } end = get_iter_at_line_end(end.get_line()); } } // Backward end to non-empty line while(end.backward_char() && (*end == ' ' || *end == '\t' || end.ends_line())) { } end.forward_char(); if(start != start_stored || end != end_stored) { // Forward to closing symbol if open symbol is found between start and end auto iter = start; para_count = 0; square_count = 0; curly_count = 0; do { if(*iter == '(' && is_code_iter(iter)) para_count++; else if(*iter == ')' && is_code_iter(iter)) para_count--; else if(*iter == '[' && is_code_iter(iter)) square_count++; else if(*iter == ']' && is_code_iter(iter)) square_count--; else if(*iter == '{' && is_code_iter(iter)) curly_count++; else if(*iter == '}' && is_code_iter(iter)) curly_count--; if(para_count < 0 || square_count < 0 || curly_count < 0) break; } while(iter.forward_char() && iter < end); if(iter == end && (para_count > 0 || square_count > 0 || curly_count > 0)) { do { if(*iter == '(' && is_code_iter(iter)) para_count++; else if(*iter == ')' && is_code_iter(iter)) para_count--; else if(*iter == '[' && is_code_iter(iter)) square_count++; else if(*iter == ']' && is_code_iter(iter)) square_count--; else if(*iter == '{' && is_code_iter(iter)) curly_count++; else if(*iter == '}' && is_code_iter(iter)) curly_count--; if(para_count == 0 && square_count == 0 && curly_count == 0) break; } while(iter.forward_char()); if(iter) { end = iter; end.forward_char(); } } get_buffer()->select_range(start, end); return; } // Select block that cursor is within // Backward start block start if(start_tabs > 0) { start = get_buffer()->get_iter_at_line(start.get_line()); while(start.backward_char()) { auto tabs = get_tabs(start); if(tabs && tabs < start_tabs) break; start = get_buffer()->get_iter_at_line(start.get_line()); } while((*start == ' ' || *start == '\t' || start.ends_line()) && start.forward_char()) { } // Forward to block end end = get_iter_at_line_end(end.get_line()); while(end.forward_char()) { auto tabs = get_tabs(end); if(tabs && tabs < start_tabs) break; end = get_iter_at_line_end(end.get_line()); } // Backward end to non-empty line while(end.backward_char() && (*end == ' ' || *end == '\t' || end.ends_line())) { } end.forward_char(); if(start != start_stored || end != end_stored) { get_buffer()->select_range(start, end); return; } // Select expression surrounding block // Backward to expression starting block if(start.backward_char()) { backward_to_code(start); if(start_tabs > get_tabs(start)) { start = get_buffer()->get_iter_at_line(start.get_line()); while((*start == ' ' || *start == '\t' || start.ends_line()) && start.forward_char()) { } } else start = start_stored; } // Forward to expression ending block if(select_end_block) { forward_to_code(end); if(start_tabs > get_tabs(end)) { end = get_iter_at_line_end(end.get_line()); while(end.backward_char() && (*end == ' ' || *end == '\t' || end.ends_line())) { } end.forward_char(); } else end = end_stored; } if(start != start_stored || end != end_stored) { get_buffer()->select_range(start, end); return; } } // Select no_spellcheck_tag block if markdown if(language_id == "markdown" && no_spellcheck_tag && start.has_tag(no_spellcheck_tag) && end.has_tag(no_spellcheck_tag)) { if(!start.starts_tag(no_spellcheck_tag)) start.backward_to_tag_toggle(no_spellcheck_tag); if(!end.ends_tag(no_spellcheck_tag)) end.forward_to_tag_toggle(no_spellcheck_tag); auto prev = start; while(*start == '`' && start.forward_char()) { } if(start.get_offset() - prev.get_offset() > 1) { start.forward_to_line_end(); start.forward_char(); } while(end.backward_char() && *end == '`') { } if(!end.ends_line()) end.forward_char(); if(start != start_stored || end != end_stored) { get_buffer()->select_range(start, end); return; } } get_buffer()->select_range(get_buffer()->begin(), get_buffer()->end()); return; } } else if(!comma_used && end_sentence_iter && end > end_sentence_iter) { if(!start_sentence_iter) start_sentence_iter = start; else start_sentence_iter.forward_char(); // Forward to code iter (move passed macros) while(forward_to_code(start_sentence_iter) && *start_sentence_iter == '#' && start_sentence_iter.forward_to_line_end()) { auto prev = start_sentence_iter; if(prev.backward_char() && *prev == '\\' && start_sentence_iter.forward_char()) { while(start_sentence_iter.forward_to_line_end()) { prev = start_sentence_iter; if(prev.backward_char() && *prev == '\\' && start_sentence_iter.forward_char()) continue; break; } } } // Select sentence end_sentence_iter.forward_char(); if((start_sentence_iter != start_stored || end_sentence_iter != end_stored) && ((*start == '{' && *end == '}') || (start.is_start() && end.is_end()))) { get_buffer()->select_range(start_sentence_iter, end_sentence_iter); return; } } if(select_matching_brackets) start.forward_char(); if(start != start_stored || end != end_stored) { get_buffer()->select_range(start, end); return; } // In case of no change due to inbalanced brackets previous_extended_selections.pop_back(); if(!start.backward_char() && !end.forward_char()) return; get_buffer()->select_range(start, end); extend_selection(); } void Source::View::shrink_selection() { if(previous_extended_selections.empty()) { Info::get().print("No previous extended selections found"); return; } auto selection = previous_extended_selections.back(); keep_previous_extended_selections = true; get_buffer()->select_range(selection.first, selection.second); hide_tooltips(); keep_previous_extended_selections = false; previous_extended_selections.pop_back(); } void Source::View::show_or_hide() { Gtk::TextIter start, end; get_buffer()->get_selection_bounds(start, end); if(start == end && !(start.starts_line() && start.ends_line())) { // Select code block instead if no current selection start = get_buffer()->get_iter_at_line(start.get_line()); auto tabs_end = get_tabs_end_iter(start); auto start_tabs = tabs_end.get_line_offset() - start.get_line_offset(); if(!end.ends_line()) end.forward_to_line_end(); auto last_empty = get_buffer()->end(); auto last_tabs_end = get_buffer()->end(); while(true) { if(end.ends_line()) { auto line_start = get_buffer()->get_iter_at_line(end.get_line()); auto tabs_end = get_tabs_end_iter(line_start); if(end.starts_line() || tabs_end.ends_line()) { // Empty line if(!last_empty) last_empty = end; } else { auto tabs = tabs_end.get_line_offset() - line_start.get_line_offset(); if((is_c || is_cpp) && tabs == 0 && *line_start == '#') { // C/C++ defines can be at the first line if(end.get_line() == start.get_line()) // Do not try to find define blocks since these rarely are indented break; } else if(tabs < start_tabs) { end = get_buffer()->get_iter_at_line(end.get_line()); break; } else if(tabs == start_tabs) { // Check for block continuation keywords std::string text = get_buffer()->get_text(tabs_end, end); if(end.get_line() != start.get_line()) { if(text.empty()) { end = get_buffer()->get_iter_at_line(end.get_line()); break; } static std::vector starts_with_symbols = {"}", ")", "]", ">", " exact_tokens = {"else", "end", "endif", "elseif", "elif", "catch", "case", "default", "private", "public", "protected"}; if(text == "{") { // C/C++ sometimes starts a block with a standalone { if(!is_token_char(*last_tabs_end)) { end = get_buffer()->get_iter_at_line(end.get_line()); break; } else { // Check for ; at the end of last line auto iter = tabs_end; while(iter.backward_char() && iter > last_tabs_end && (*iter == ' ' || *iter == '\t' || iter.ends_line() || !is_code_iter(iter))) { } if(*iter == ';') { end = get_buffer()->get_iter_at_line(end.get_line()); break; } } } else if(std::none_of(starts_with_symbols.begin(), starts_with_symbols.end(), [&text](const std::string &symbol) { return starts_with(text, symbol); }) && std::none_of(exact_tokens.begin(), exact_tokens.end(), [this, &text](const std::string &token) { return starts_with(text, token) && (text.size() <= token.size() || !is_token_char(text[token.size()])); })) { end = get_buffer()->get_iter_at_line(end.get_line()); break; } } last_tabs_end = tabs_end; } last_empty = get_buffer()->end(); } } if(end.is_end()) break; end.forward_char(); } if(last_empty) end = get_buffer()->get_iter_at_line(last_empty.get_line()); } if(start == end) end.forward_char(); // Select empty line if(!start.starts_line()) start = get_buffer()->get_iter_at_line(start.get_line()); if(!end.ends_line() && !end.starts_line()) end.forward_to_line_end(); if((start.begins_tag(hide_tag) || start.has_tag(hide_tag)) && (end.ends_tag(hide_tag) || end.has_tag(hide_tag))) { get_buffer()->remove_tag(hide_tag, start, end); return; } auto iter = start; if(iter.forward_to_tag_toggle(hide_tag) && iter < end) { get_buffer()->remove_tag(hide_tag, start, end); return; } get_buffer()->apply_tag(hide_tag, start, end); } void Source::View::add_diagnostic_tooltip(const Gtk::TextIter &start, const Gtk::TextIter &end, bool error, std::function &&set_buffer) { diagnostic_offsets.emplace(start.get_offset()); std::string severity_tag_name = error ? "def:error" : "def:warning"; diagnostic_tooltips.emplace_back(this, start, end, [error, severity_tag_name, set_buffer = std::move(set_buffer)](Tooltip &tooltip) { tooltip.buffer->insert_with_tag(tooltip.buffer->get_insert()->get_iter(), error ? "Error" : "Warning", severity_tag_name); tooltip.buffer->insert(tooltip.buffer->get_insert()->get_iter(), ":\n"); set_buffer(tooltip); }); get_buffer()->apply_tag_by_name(severity_tag_name + "_underline", start, end); auto iter = get_buffer()->get_insert()->get_iter(); if(iter.ends_line()) { auto next_iter = iter; if(next_iter.forward_char()) get_buffer()->remove_tag_by_name(severity_tag_name + "_underline", iter, next_iter); } } void Source::View::clear_diagnostic_tooltips() { diagnostic_offsets.clear(); diagnostic_tooltips.clear(); get_buffer()->remove_tag_by_name("def:warning_underline", get_buffer()->begin(), get_buffer()->end()); get_buffer()->remove_tag_by_name("def:error_underline", get_buffer()->begin(), get_buffer()->end()); } void Source::View::place_cursor_at_next_diagnostic() { auto insert_offset = get_buffer()->get_insert()->get_iter().get_offset(); for(auto offset : diagnostic_offsets) { if(offset > insert_offset) { get_buffer()->place_cursor(get_buffer()->get_iter_at_offset(offset)); scroll_to(get_buffer()->get_insert(), 0.0, 1.0, 0.5); return; } } if(diagnostic_offsets.size() == 0) Info::get().print("No diagnostics found in current buffer"); else { auto iter = get_buffer()->get_iter_at_offset(*diagnostic_offsets.begin()); get_buffer()->place_cursor(iter); scroll_to(get_buffer()->get_insert(), 0.0, 1.0, 0.5); } } bool Source::View::backward_to_code(Gtk::TextIter &iter) { while((*iter == ' ' || *iter == '\t' || iter.ends_line() || !is_code_iter(iter)) && iter.backward_char()) { } return !iter.is_start() || is_code_iter(iter); } bool Source::View::forward_to_code(Gtk::TextIter &iter) { while((*iter == ' ' || *iter == '\t' || iter.ends_line() || !is_code_iter(iter)) && iter.forward_char()) { } return !iter.is_end(); } bool Source::View::backward_to_code_or_line_start(Gtk::TextIter &iter) { while(!iter.starts_line() && (*iter == ' ' || *iter == '\t' || iter.ends_line() || !is_code_iter(iter)) && iter.backward_char()) { } return !iter.is_start() || is_code_iter(iter); } bool Source::View::forward_to_code_or_line_end(Gtk::TextIter &iter) { while(!iter.ends_line() && (*iter == ' ' || *iter == '\t' || !is_code_iter(iter)) && iter.forward_char()) { } return !iter.is_end(); } Gtk::TextIter Source::View::get_start_of_expression(Gtk::TextIter iter) { backward_to_code_or_line_start(iter); if(iter.starts_line()) return iter; bool has_semicolon = false; bool has_open_curly = false; if(is_bracket_language) { if(*iter == ';' && is_code_iter(iter)) has_semicolon = true; else if(*iter == '{' && is_code_iter(iter)) { iter.backward_char(); has_open_curly = true; } } int para_count = 0; int square_count = 0; long curly_count = 0; do { if(*iter == '(' && is_code_iter(iter)) para_count++; else if(*iter == ')' && is_code_iter(iter)) para_count--; else if(*iter == '[' && is_code_iter(iter)) square_count++; else if(*iter == ']' && is_code_iter(iter)) square_count--; else if(*iter == '{' && is_code_iter(iter)) curly_count++; else if(*iter == '}' && is_code_iter(iter)) { curly_count--; if(iter.starts_line()) break; } if(para_count > 0 || square_count > 0 || curly_count > 0) break; if(iter.starts_line() && para_count == 0 && square_count == 0) { if(!is_bracket_language) return iter; // Handle << at the beginning of the sentence if iter initially started with ; if(has_semicolon) { auto test_iter = get_tabs_end_iter(iter); if(!test_iter.starts_line() && *test_iter == '<' && is_code_iter(test_iter) && test_iter.forward_char() && *test_iter == '<') continue; } // Handle for instance: test\n .test(); if(has_semicolon && use_fixed_continuation_indenting) { auto test_iter = get_tabs_end_iter(iter); if(!test_iter.starts_line() && *test_iter == '.' && is_code_iter(test_iter)) continue; } // Handle : at the beginning of the sentence if iter initially started with { if(has_open_curly) { auto test_iter = get_tabs_end_iter(iter); if(!test_iter.starts_line() && *test_iter == ':' && is_code_iter(test_iter)) continue; } // Handle ',', ':', or operators that can be used between two lines, on previous line // Return if previous line is empty auto previous_iter = iter; previous_iter.backward_char(); backward_to_code_or_line_start(previous_iter); if(previous_iter.starts_line()) return iter; // Handle for instance: Test::Test():\n test(2) { if(has_open_curly && *previous_iter == ':') { previous_iter.backward_char(); backward_to_code_or_line_start(previous_iter); if(*previous_iter == ')') { auto token = get_token(get_tabs_end_iter(previous_iter)); if(token != "case") continue; } return iter; } // Handle for instance: int a =\n b; if(*previous_iter == '=' || *previous_iter == '+' || *previous_iter == '-' || *previous_iter == '*' || *previous_iter == '/' || *previous_iter == '%' || *previous_iter == '<' || *previous_iter == '>' || *previous_iter == '&' || *previous_iter == '|') { if(has_semicolon) continue; return iter; } if(*previous_iter != ',') return iter; else { // Return if , is followed by }, for instance: {\n 1,\n 2,\n} auto next_iter = iter; if(forward_to_code_or_line_end(next_iter) && *next_iter == '}') return iter; } } } while(iter.backward_char()); return iter; } bool Source::View::find_close_symbol_forward(Gtk::TextIter iter, Gtk::TextIter &found_iter, unsigned int positive_char, unsigned int negative_char) { long count = 0; if(positive_char == '{' && negative_char == '}') { do { if(*iter == positive_char && is_code_iter(iter)) count++; else if(*iter == negative_char && is_code_iter(iter)) { if(count == 0) { found_iter = iter; return true; } count--; } } while(iter.forward_char()); return false; } else { long curly_count = 0; do { if(curly_count == 0 && *iter == positive_char && is_code_iter(iter)) { if((is_c || is_cpp) && positive_char == '>') { auto prev = iter; if(prev.backward_char() && *prev == '-') continue; } else if(is_js && positive_char == '>') { auto prev = iter; if(prev.backward_char() && *prev == '=') continue; } count++; } else if(curly_count == 0 && *iter == negative_char && is_code_iter(iter)) { if((is_c || is_cpp) && negative_char == '>') { auto prev = iter; if(prev.backward_char() && *prev == '-') continue; } else if(is_js && negative_char == '>') { auto prev = iter; if(prev.backward_char() && *prev == '=') continue; } if(count == 0) { found_iter = iter; return true; } count--; } else if(*iter == '{' && is_code_iter(iter)) curly_count++; else if(*iter == '}' && is_code_iter(iter)) { if(curly_count == 0) return false; curly_count--; } } while(iter.forward_char()); return false; } } bool Source::View::find_open_symbol_backward(Gtk::TextIter iter, Gtk::TextIter &found_iter, unsigned int positive_char, unsigned int negative_char) { long count = 0; if(positive_char == '{' && negative_char == '}') { do { if(*iter == positive_char && is_code_iter(iter)) { if(count == 0) { found_iter = iter; return true; } count++; } else if(*iter == negative_char && is_code_iter(iter)) count--; } while(iter.backward_char()); return false; } else { long curly_count = 0; do { if(curly_count == 0 && *iter == positive_char && is_code_iter(iter)) { if((is_c || is_cpp) && positive_char == '>') { auto prev = iter; if(prev.backward_char() && *prev == '-') continue; } else if(is_js && positive_char == '>') { auto prev = iter; if(prev.backward_char() && *prev == '=') continue; } if(count == 0) { found_iter = iter; return true; } count++; } else if(curly_count == 0 && *iter == negative_char && is_code_iter(iter)) { if((is_c || is_cpp) && negative_char == '>') { auto prev = iter; if(prev.backward_char() && *prev == '-') continue; } else if(is_js && negative_char == '>') { auto prev = iter; if(prev.backward_char() && *prev == '=') continue; } count--; } else if(*iter == '{' && is_code_iter(iter)) { if(curly_count == 0) return false; curly_count++; } else if(*iter == '}' && is_code_iter(iter)) curly_count--; } while(iter.backward_char()); return false; } } long Source::View::symbol_count(Gtk::TextIter iter, unsigned int positive_char, unsigned int negative_char) { auto iter_stored = iter; long symbol_count = 0; if(positive_char == '{' && negative_char == '}') { // If checking top-level curly brackets, check whole buffer auto previous_iter = iter; if(iter.starts_line() || (previous_iter.backward_char() && previous_iter.starts_line() && *previous_iter == '{')) { auto iter = get_buffer()->begin(); do { if(*iter == '{' && is_code_iter(iter)) ++symbol_count; else if(*iter == '}' && is_code_iter(iter)) --symbol_count; } while(iter.forward_char()); return symbol_count; } // Can stop when text is found at top-level indentation else { do { if(*iter == '{' && is_code_iter(iter)) ++symbol_count; else if(*iter == '}' && is_code_iter(iter)) --symbol_count; if(iter.starts_line() && !iter.ends_line() && *iter != '#' && *iter != ' ' && *iter != '\t') break; } while(iter.backward_char()); iter = iter_stored; if(!iter.forward_char()) return symbol_count; do { if(*iter == '{' && is_code_iter(iter)) ++symbol_count; else if(*iter == '}' && is_code_iter(iter)) --symbol_count; if(iter.starts_line() && !iter.ends_line() && *iter != '#' && *iter != ' ' && *iter != '\t') { if(*iter == 'p') { auto token = get_token(iter); if(token == "public" || token == "protected" || token == "private") continue; } break; } } while(iter.forward_char()); return symbol_count; } } long curly_count = 0; do { if(*iter == positive_char && is_code_iter(iter)) symbol_count++; else if(*iter == negative_char && is_code_iter(iter)) symbol_count--; else if(*iter == '{' && is_code_iter(iter)) { if(curly_count == 0) break; curly_count++; } else if(*iter == '}' && is_code_iter(iter)) curly_count--; } while(iter.backward_char()); iter = iter_stored; if(!iter.forward_char()) return symbol_count; curly_count = 0; do { if(*iter == positive_char && is_code_iter(iter)) symbol_count++; else if(*iter == negative_char && is_code_iter(iter)) symbol_count--; else if(*iter == '{' && is_code_iter(iter)) curly_count++; else if(*iter == '}' && is_code_iter(iter)) { if(curly_count == 0) break; curly_count--; } } while(iter.forward_char()); return symbol_count; } bool Source::View::is_templated_function(Gtk::TextIter iter, Gtk::TextIter &parenthesis_end_iter) { auto iter_stored = iter; long bracket_count = 0; long curly_count = 0; if(!(iter.backward_char() && *iter == '>' && *iter_stored == '(')) return false; do { if(*iter == '<' && is_code_iter(iter)) bracket_count++; else if(*iter == '>' && is_code_iter(iter)) bracket_count--; else if(*iter == '{' && is_code_iter(iter)) curly_count++; else if(*iter == '}' && is_code_iter(iter)) curly_count--; if(bracket_count == 0) break; if(curly_count > 0) break; } while(iter.backward_char()); if(bracket_count != 0) return false; iter = iter_stored; bracket_count = 0; curly_count = 0; do { if(*iter == '(' && is_code_iter(iter)) bracket_count++; else if(*iter == ')' && is_code_iter(iter)) bracket_count--; else if(*iter == '{' && is_code_iter(iter)) curly_count++; else if(*iter == '}' && is_code_iter(iter)) curly_count--; if(bracket_count == 0) { parenthesis_end_iter = iter; return true; } if(curly_count < 0) return false; } while(iter.forward_char()); return false; } bool Source::View::is_possible_argument() { auto iter = get_buffer()->get_insert()->get_iter(); if(iter.backward_char() && (!interactive_completion || last_keyval == '(' || last_keyval == ',' || last_keyval == ' ' || last_keyval == GDK_KEY_Return || last_keyval == GDK_KEY_KP_Enter)) { if(backward_to_code(iter) && (*iter == '(' || *iter == ',')) return true; } return false; } bool Source::View::on_key_press_event(GdkEventKey *event) { enable_multiple_cursors = true; ScopeGuard guard{[this] { enable_multiple_cursors = false; }}; if(SelectionDialog::get() && SelectionDialog::get()->is_visible()) { if(SelectionDialog::get()->on_key_press(event)) return true; } if(CompletionDialog::get() && CompletionDialog::get()->is_visible()) { if(CompletionDialog::get()->on_key_press(event)) return true; } if(last_keyval < GDK_KEY_Shift_L || last_keyval > GDK_KEY_Hyper_R) previous_non_modifier_keyval = last_keyval; if((event->state & (GDK_CONTROL_MASK | GDK_MOD2_MASK)) == 0) last_keyval = event->keyval; if((event->keyval == GDK_KEY_Tab || event->keyval == GDK_KEY_ISO_Left_Tab) && (event->state & GDK_SHIFT_MASK) == 0 && select_snippet_parameter()) return true; if(on_key_press_event_extra_cursors(event)) return true; { LockGuard lock(snippets_mutex); if(snippets) { guint keyval_without_state; gdk_keymap_translate_keyboard_state(gdk_keymap_get_default(), event->hardware_keycode, (GdkModifierType)0, 0, &keyval_without_state, nullptr, nullptr, nullptr); for(auto &snippet : *snippets) { if(snippet.key == keyval_without_state && (event->state & (GDK_CONTROL_MASK | GDK_SHIFT_MASK | GDK_MOD1_MASK | GDK_META_MASK)) == snippet.modifier) { insert_snippet(get_buffer()->get_insert()->get_iter(), snippet.body); return true; } } } } get_buffer()->begin_user_action(); // Shift+enter: go to end of line and enter if((event->keyval == GDK_KEY_Return || event->keyval == GDK_KEY_KP_Enter) && (event->state & GDK_SHIFT_MASK) > 0) { auto iter = get_buffer()->get_insert()->get_iter(); if(!iter.ends_line()) { iter.forward_to_line_end(); get_buffer()->place_cursor(iter); } } if(Config::get().source.smart_brackets && on_key_press_event_smart_brackets(event)) { get_buffer()->end_user_action(); return true; } if(Config::get().source.smart_inserts && on_key_press_event_smart_inserts(event)) { get_buffer()->end_user_action(); return true; } if(is_bracket_language && on_key_press_event_bracket_language(event)) { get_buffer()->end_user_action(); return true; } else if(on_key_press_event_basic(event)) { get_buffer()->end_user_action(); return true; } else { get_buffer()->end_user_action(); return BaseView::on_key_press_event(event); } } // Basic indentation bool Source::View::on_key_press_event_basic(GdkEventKey *event) { auto iter = get_buffer()->get_insert()->get_iter(); // Indent as in current or next line if((event->keyval == GDK_KEY_Return || event->keyval == GDK_KEY_KP_Enter) && !get_buffer()->get_has_selection() && !iter.starts_line()) { remove_whitespace_characters(iter); iter = get_buffer()->get_insert()->get_iter(); auto condition_iter = iter; condition_iter.backward_char(); backward_to_code_or_line_start(condition_iter); auto start_iter = get_start_of_expression(condition_iter); auto tabs_end_iter = get_tabs_end_iter(start_iter); auto tabs = get_line_before(tabs_end_iter); // Python indenting after : if(*condition_iter == ':' && language_id == "python") { get_buffer()->insert_at_cursor('\n' + tabs + tab); scroll_to(get_buffer()->get_insert()); return true; } // Indent as in current or next line int line_nr = iter.get_line(); if(iter.ends_line() && (line_nr + 1) < get_buffer()->get_line_count()) { auto next_tabs_end_iter = get_tabs_end_iter(line_nr + 1); if(next_tabs_end_iter.get_line_offset() > tabs_end_iter.get_line_offset()) { get_buffer()->insert_at_cursor('\n' + get_line_before(next_tabs_end_iter)); scroll_to(get_buffer()->get_insert()); return true; } } get_buffer()->insert_at_cursor('\n' + tabs); scroll_to(get_buffer()->get_insert()); return true; } // Indent as in next or previous line else if(event->keyval == GDK_KEY_Tab && (event->state & GDK_SHIFT_MASK) == 0) { // Special case if insert is at beginning of empty line: if(iter.starts_line() && iter.ends_line() && !get_buffer()->get_has_selection()) { auto prev_line_iter = iter; while(prev_line_iter.starts_line() && prev_line_iter.backward_char()) { } auto start_iter = get_start_of_expression(prev_line_iter); auto prev_line_tabs_end_iter = get_tabs_end_iter(start_iter); auto next_line_iter = iter; while(next_line_iter.starts_line() && next_line_iter.forward_char()) { } auto next_line_tabs_end_iter = get_tabs_end_iter(next_line_iter); Gtk::TextIter tabs_end_iter; if(next_line_tabs_end_iter.get_line_offset() > prev_line_tabs_end_iter.get_line_offset()) tabs_end_iter = next_line_tabs_end_iter; else tabs_end_iter = prev_line_tabs_end_iter; auto tabs = get_line_before(tabs_end_iter); get_buffer()->insert_at_cursor(tabs.size() >= tab_size ? tabs : tab); return true; } if(!Config::get().source.tab_indents_line && !get_buffer()->get_has_selection()) { get_buffer()->insert_at_cursor(tab); return true; } // Indent right when clicking tab, no matter where in the line the cursor is. Also works on selected text. Gtk::TextIter selection_start, selection_end; get_buffer()->get_selection_bounds(selection_start, selection_end); Mark selection_end_mark(selection_end); int line_start = selection_start.get_line(); int line_end = selection_end.get_line(); for(int line = line_start; line <= line_end; line++) { auto line_it = get_buffer()->get_iter_at_line(line); if(!get_buffer()->get_has_selection() || line_it != selection_end_mark->get_iter()) get_buffer()->insert(line_it, tab); } return true; } // Indent left when clicking shift-tab, no matter where in the line the cursor is. Also works on selected text. else if((event->keyval == GDK_KEY_ISO_Left_Tab || event->keyval == GDK_KEY_Tab) && (event->state & GDK_SHIFT_MASK) > 0) { Gtk::TextIter selection_start, selection_end; get_buffer()->get_selection_bounds(selection_start, selection_end); int line_start = selection_start.get_line(); int line_end = selection_end.get_line(); unsigned indent_left_steps = tab_size; std::vector ignore_line; for(int line_nr = line_start; line_nr <= line_end; line_nr++) { auto line_it = get_buffer()->get_iter_at_line(line_nr); if(!get_buffer()->get_has_selection() || line_it != selection_end) { auto tabs_end_iter = get_tabs_end_iter(line_nr); if(tabs_end_iter.starts_line() && tabs_end_iter.ends_line()) ignore_line.push_back(true); else { auto line_tabs = get_line_before(tabs_end_iter); if(line_tabs.size() > 0) { indent_left_steps = std::min(indent_left_steps, static_cast(line_tabs.size())); ignore_line.push_back(false); } else return true; } } } for(int line_nr = line_start; line_nr <= line_end; line_nr++) { Gtk::TextIter line_it = get_buffer()->get_iter_at_line(line_nr); Gtk::TextIter line_plus_it = line_it; if(!get_buffer()->get_has_selection() || line_it != selection_end) { line_plus_it.forward_chars(indent_left_steps); if(!ignore_line.at(line_nr - line_start)) get_buffer()->erase(line_it, line_plus_it); } } return true; } // "Smart" backspace key else if(event->keyval == GDK_KEY_BackSpace && !get_buffer()->get_has_selection()) { auto line = get_line_before(); bool do_smart_backspace = true; for(auto &chr : line) { if(chr != ' ' && chr != '\t') { do_smart_backspace = false; break; } } if(iter.get_line() == 0) // Special case since there are no previous line do_smart_backspace = false; if(do_smart_backspace) { auto previous_line_end_iter = iter; if(previous_line_end_iter.backward_chars(line.size() + 1)) { if(!previous_line_end_iter.ends_line()) // For CR+LF previous_line_end_iter.backward_char(); if(previous_line_end_iter.starts_line()) // When previous line is empty, keep tabs in current line get_buffer()->erase(previous_line_end_iter, get_buffer()->get_iter_at_line(iter.get_line())); else get_buffer()->erase(previous_line_end_iter, iter); return true; } } } // "Smart" delete key else if(event->keyval == GDK_KEY_Delete && !get_buffer()->get_has_selection()) { auto insert_iter = iter; bool do_smart_delete = true; do { if(*iter != ' ' && *iter != '\t' && !iter.ends_line()) { do_smart_delete = false; break; } if(iter.ends_line()) { if(!iter.forward_char()) do_smart_delete = false; break; } } while(iter.forward_char()); if(do_smart_delete) { if(!insert_iter.starts_line()) { while((*iter == ' ' || *iter == '\t') && iter.forward_char()) { } } get_buffer()->erase(insert_iter, iter); return true; } } // Workaround for TextView::on_key_press_event bug sometimes causing segmentation faults // TODO: figure out the bug and create pull request to gtk // Have only experienced this on OS X // Note: valgrind reports issues on TextView::on_key_press_event as well auto unicode = gdk_keyval_to_unicode(event->keyval); if((event->state & (GDK_CONTROL_MASK | GDK_META_MASK)) == 0 && unicode >= 32 && unicode != 127 && (previous_non_modifier_keyval < GDK_KEY_dead_grave || previous_non_modifier_keyval > GDK_KEY_dead_greek)) { if(get_buffer()->get_has_selection()) { Gtk::TextIter selection_start, selection_end; get_buffer()->get_selection_bounds(selection_start, selection_end); get_buffer()->erase(selection_start, selection_end); } get_buffer()->insert_at_cursor(Glib::ustring(1, unicode)); scroll_to(get_buffer()->get_insert()); // Trick to make the cursor visible right after insertion: set_cursor_visible(false); set_cursor_visible(); return true; } return false; } // Bracket language indentation bool Source::View::on_key_press_event_bracket_language(GdkEventKey *event) { const static std::regex no_bracket_statement_regex("^[ \t]*(if( +constexpr)?|for|while) *\\(.*[^;}{] *$|" "^[ \t]*[}]? *else if( +constexpr)? *\\(.*[^;}{] *$|" "^[ \t]*[}]? *else *$", std::regex::extended | std::regex::optimize); auto iter = get_buffer()->get_insert()->get_iter(); if(get_buffer()->get_has_selection()) return false; if(!is_code_iter(iter)) { // Add * at start of line in comment blocks if(event->keyval == GDK_KEY_Return || event->keyval == GDK_KEY_KP_Enter) { if(!iter.starts_line() && (!string_tag || (!iter.has_tag(string_tag) && !iter.ends_tag(string_tag)))) { remove_whitespace_characters(iter); iter = get_buffer()->get_insert()->get_iter(); auto start_iter = get_tabs_end_iter(iter.get_line()); if(!is_code_iter(start_iter)) { auto end_iter = start_iter; end_iter.forward_chars(2); auto start_of_sentence = get_buffer()->get_text(start_iter, end_iter); if(!start_of_sentence.empty() && (start_of_sentence == "/*" || start_of_sentence[0] == '*')) { auto tabs = get_line_before(start_iter); auto insert_str = '\n' + tabs; if(start_of_sentence[0] == '/') insert_str += ' '; insert_str += "* "; get_buffer()->insert_at_cursor(insert_str); return true; } } } else if(!comment_tag || !iter.ends_tag(comment_tag)) return false; } else return false; } // Indent depending on if/else/etc and brackets if((event->keyval == GDK_KEY_Return || event->keyval == GDK_KEY_KP_Enter) && !iter.starts_line()) { remove_whitespace_characters(iter); iter = get_buffer()->get_insert()->get_iter(); auto previous_iter = iter; previous_iter.backward_char(); // Remove matching bracket highlights that get extended when inserting text in between the brackets ScopeGuard guard; if((*previous_iter == '{' && *iter == '}') || (*previous_iter == '(' && *iter == ')') || (*previous_iter == '[' && *iter == ']') || (*previous_iter == '<' && *iter == '>')) { get_source_buffer()->set_highlight_matching_brackets(false); guard.on_exit = [this] { get_source_buffer()->set_highlight_matching_brackets(true); }; } auto condition_iter = previous_iter; backward_to_code_or_line_start(condition_iter); auto start_iter = get_start_of_expression(condition_iter); auto tabs_end_iter = get_tabs_end_iter(start_iter); auto tabs = get_line_before(tabs_end_iter); /* * Change tabs after ending comment block with an extra space (as in this case) */ if(tabs.size() % tab_size == 1 && !start_iter.ends_line() && !is_code_iter(start_iter)) { auto end_of_line_iter = start_iter; end_of_line_iter.forward_to_line_end(); if(starts_with(get_buffer()->get_text(tabs_end_iter, end_of_line_iter).raw(), "*/")) { tabs.pop_back(); get_buffer()->insert_at_cursor('\n' + tabs); scroll_to(get_buffer()->get_insert()); return true; } } // Indent enter inside HTML or JSX elements, for instance: //

CURSOR

// to: //

// CURSOR //

// and //

CURSORtest // to //

// CURSORtest if(*condition_iter == '>' && is_js) { auto prev = condition_iter; Gtk::TextIter open_element_iter; if(prev.backward_char() && backward_to_code(prev) && *prev != '/' && find_open_symbol_backward(prev, open_element_iter, '<', '>') && open_element_iter.forward_char() && forward_to_code(open_element_iter) && *open_element_iter != '/') { auto get_element = [this](Gtk::TextIter iter) { auto start = iter; auto end = iter; while(iter.backward_char() && (is_token_char(*iter) || *iter == '.')) start = iter; while((is_token_char(*end) || *end == '.') && end.forward_char()) { } return get_buffer()->get_text(start, end); }; auto open_element_token = get_element(open_element_iter); static std::vector void_elements = {"area", "base", "br", "col", "command", "embed", "hr", "img", "input", "keygen", "link", "meta", "param", "source", "track", "wbr"}; if(std::none_of(void_elements.begin(), void_elements.end(), [&open_element_token](const std::string &e) { return e == open_element_token; })) { auto close_element_iter = iter; // If cursor is placed between open and close tag if(*close_element_iter == '<' && close_element_iter.forward_char() && forward_to_code(close_element_iter) && *close_element_iter == '/' && close_element_iter.forward_char() && forward_to_code(close_element_iter) && open_element_token == get_element(close_element_iter)) { get_buffer()->insert_at_cursor('\n' + tabs + tab + '\n' + tabs); auto insert_it = get_buffer()->get_insert()->get_iter(); if(insert_it.backward_chars(tabs.size() + 1)) { scroll_to(get_buffer()->get_insert()); get_buffer()->place_cursor(insert_it); } return true; } close_element_iter = iter; // Add closing tag if missing if(close_element_iter.ends_line()) { forward_to_code(close_element_iter); auto close_element_tabs_size = static_cast(get_tabs_end_iter(close_element_iter).get_line_offset()); if(!close_element_iter || close_element_tabs_size < tabs.size() || (close_element_tabs_size == tabs.size() && (*close_element_iter == '{' || (*close_element_iter == '<' && close_element_iter.forward_char() && forward_to_code(close_element_iter) && !(*close_element_iter == '/' && close_element_iter.forward_char() && forward_to_code(close_element_iter) && get_element(close_element_iter) == open_element_token))))) { get_buffer()->insert_at_cursor('\n' + tabs + tab + '\n' + tabs + "'); auto insert_it = get_buffer()->get_insert()->get_iter(); if(insert_it.backward_chars(tabs.size() + 1 + open_element_token.size() + 3)) { scroll_to(get_buffer()->get_insert()); get_buffer()->place_cursor(insert_it); } return true; } } // If line ends with closing element, move content after open to new line, and closing tag on the next line thereafter close_element_iter = iter; if(!close_element_iter.ends_line()) close_element_iter.forward_to_line_end(); if(close_element_iter.backward_char() && *close_element_iter == '>' && close_element_iter.backward_char() && find_open_symbol_backward(close_element_iter, close_element_iter, '<', '>')) { auto start_close_element_iter = close_element_iter; auto content_size = start_close_element_iter.get_offset() - iter.get_offset(); if(close_element_iter.forward_char() && forward_to_code(close_element_iter) && *close_element_iter == '/' && close_element_iter.forward_char() && forward_to_code(close_element_iter) && get_element(close_element_iter) == open_element_token) { get_buffer()->insert_at_cursor('\n' + tabs + tab); auto close_element_start_iter = get_buffer()->get_insert()->get_iter(); close_element_start_iter.forward_chars(content_size); get_buffer()->insert(close_element_start_iter, '\n' + tabs); scroll_to(get_buffer()->get_insert()); return true; } } get_buffer()->insert_at_cursor('\n' + tabs + tab); scroll_to(get_buffer()->get_insert()); return true; } } } // Special indentation of {, [ and ( for for instance JavaScript, JSON, Rust if(use_fixed_continuation_indenting) { unsigned int open_symbol = 0, close_symbol = 0; if(*condition_iter == '[') { open_symbol = '['; close_symbol = ']'; } else if(*condition_iter == '(') { open_symbol = '('; close_symbol = ')'; } else if(*condition_iter == '{') { open_symbol = '{'; close_symbol = '}'; } if(open_symbol != 0 && is_code_iter(condition_iter)) { Gtk::TextIter found_iter; // Check if an ), ] or } is needed bool has_right_bracket = false; if(find_close_symbol_forward(iter, found_iter, open_symbol, close_symbol)) { auto found_tabs_end_iter = get_tabs_end_iter(found_iter); if(found_tabs_end_iter.get_line_offset() == tabs_end_iter.get_line_offset()) has_right_bracket = true; } if(*iter == close_symbol) { get_buffer()->insert_at_cursor('\n' + tabs + tab + '\n' + tabs); auto insert_it = get_buffer()->get_insert()->get_iter(); if(insert_it.backward_chars(tabs.size() + 1)) { scroll_to(get_buffer()->get_insert()); get_buffer()->place_cursor(insert_it); } return true; } else if(!has_right_bracket) { // If line does not end with: (,[, or {, move contents after the left bracket to next line inside brackets if(!iter.ends_line() && *iter != ')' && *iter != ']' && *iter != '}') { get_buffer()->insert_at_cursor('\n' + tabs + tab); auto iter = get_buffer()->get_insert()->get_iter(); Mark mark(iter); iter.forward_to_line_end(); get_buffer()->insert(iter, '\n' + tabs + static_cast(close_symbol)); scroll_to(get_buffer()->get_insert()); get_buffer()->place_cursor(mark->get_iter()); return true; } else { // Insert new lines with bracket end get_buffer()->insert_at_cursor('\n' + tabs + tab + '\n' + tabs + static_cast(close_symbol)); auto insert_it = get_buffer()->get_insert()->get_iter(); if(insert_it.backward_chars(tabs.size() + 2)) { scroll_to(get_buffer()->get_insert()); get_buffer()->place_cursor(insert_it); } return true; } } else { get_buffer()->insert_at_cursor('\n' + tabs + tab); scroll_to(get_buffer()->get_insert()); return true; } } // JavaScript: simplified indentations inside brackets, after for example: // [\n 1, 2, 3,\n // return (\n // ReactDOM.render(\n

\n Gtk::TextIter found_iter; auto after_start_iter = start_iter; after_start_iter.forward_char(); if((*start_iter == '[' && (!find_close_symbol_forward(after_start_iter, found_iter, '[', ']') || found_iter > iter)) || (*start_iter == '(' && (!find_close_symbol_forward(after_start_iter, found_iter, '(', ')') || found_iter > iter)) || (*start_iter == '{' && (!find_close_symbol_forward(after_start_iter, found_iter, '{', '}') || found_iter > iter))) { get_buffer()->insert_at_cursor('\n' + tabs + tab); scroll_to(get_buffer()->get_insert()); return true; } } else { if(*condition_iter == '{' && is_code_iter(condition_iter)) { Gtk::TextIter close_iter; // Check if an '}' is needed bool has_right_curly_bracket = false; if(find_close_symbol_forward(iter, close_iter, '{', '}')) { auto found_tabs_end_iter = get_tabs_end_iter(close_iter); if(found_tabs_end_iter.get_line_offset() == tabs_end_iter.get_line_offset()) { has_right_curly_bracket = true; // Special case for functions and classes with no indentation after: namespace { if(is_cpp && tabs_end_iter.starts_line()) { auto iter = condition_iter; Gtk::TextIter open_iter; if(iter.backward_char() && find_open_symbol_backward(iter, open_iter, '{', '}')) { if(open_iter.starts_line()) // in case of: namespace test\n{ open_iter.backward_char(); auto iter = get_buffer()->get_iter_at_line(open_iter.get_line()); if(get_token(iter) == "namespace") has_right_curly_bracket = close_iter.forward_char() && find_close_symbol_forward(close_iter, close_iter, '{', '}'); } } } /** * Handle pressing enter after '{' in special expressions like: * enum class A { a, * b } */ else if(close_iter.get_line() > condition_iter.get_line() && close_iter.get_line_offset() > condition_iter.get_line_offset()) { get_buffer()->insert_at_cursor('\n' + get_line_before(get_tabs_end_iter(condition_iter.get_line() + 1))); scroll_to(get_buffer()->get_insert()); return true; } /** * Handle pressing enter after '{' in special expressions like: * test(2, * []() { * func(); * }); */ else if(close_iter.get_line() > condition_iter.get_line() && close_iter.get_line_offset() == get_tabs_end_iter(condition_iter).get_line_offset()) { get_buffer()->insert_at_cursor('\n' + get_line_before(get_tabs_end_iter(condition_iter)) + tab); scroll_to(get_buffer()->get_insert()); return true; } } // Check if one should add semicolon after '}' bool add_semicolon = false; if(is_c || is_cpp) { // add semicolon after class or struct? auto token = get_token(tabs_end_iter); if(token == "class" || token == "struct") add_semicolon = true; // Add semicolon after lambda unless it's an argument else if(*start_iter != '(' && *start_iter != '{' && *start_iter != '[') { auto it = condition_iter; long para_count = 0; long square_count = 0; bool square_outside_para_found = false; while(it.backward_char()) { if(*it == ']' && is_code_iter(it)) { --square_count; if(para_count == 0) square_outside_para_found = true; } else if(*it == '[' && is_code_iter(it)) ++square_count; else if(*it == ')' && is_code_iter(it)) --para_count; else if(*it == '(' && is_code_iter(it)) ++para_count; if(square_outside_para_found && square_count == 0 && para_count == 0) { // Look for equal sign while(it.backward_char() && (*it == ' ' || *it == '\t' || it.ends_line())) { } if(*it == '=') add_semicolon = true; break; } if(it == start_iter) break; if(!square_outside_para_found && square_count == 0 && para_count == 0) { if(is_token_char(*it) || *it == '-' || *it == ' ' || *it == '\t' || *it == '<' || *it == '>' || *it == '(' || *it == ':' || *it == '*' || *it == '&' || *it == '/' || it.ends_line() || !is_code_iter(it)) { continue; } else break; } } } } if(*iter == '}') { get_buffer()->insert_at_cursor('\n' + tabs + tab + '\n' + tabs); if(add_semicolon) { // Check if semicolon exists auto next_iter = get_buffer()->get_insert()->get_iter(); next_iter.forward_char(); if(*next_iter != ';') get_buffer()->insert(next_iter, ";"); } auto insert_it = get_buffer()->get_insert()->get_iter(); if(insert_it.backward_chars(tabs.size() + 1)) { scroll_to(get_buffer()->get_insert()); get_buffer()->place_cursor(insert_it); } return true; } else if(!has_right_curly_bracket) { // If line does not end with: {, move contents after { to next line inside brackets if(!iter.ends_line() && *iter != ')' && *iter != ']') { get_buffer()->insert_at_cursor('\n' + tabs + tab); auto iter = get_buffer()->get_insert()->get_iter(); Mark mark(iter); iter.forward_to_line_end(); get_buffer()->insert(iter, '\n' + tabs + '}'); scroll_to(get_buffer()->get_insert()); get_buffer()->place_cursor(mark->get_iter()); return true; } else { get_buffer()->insert_at_cursor('\n' + tabs + tab + '\n' + tabs + (add_semicolon ? "};" : "}")); auto insert_it = get_buffer()->get_insert()->get_iter(); if(insert_it.backward_chars(tabs.size() + (add_semicolon ? 3 : 2))) { scroll_to(get_buffer()->get_insert()); get_buffer()->place_cursor(insert_it); } return true; } } else { get_buffer()->insert_at_cursor('\n' + tabs + tab); scroll_to(get_buffer()->get_insert()); return true; } } // Indent multiline expressions if(*start_iter == '(' || *start_iter == '[') { auto iter = get_tabs_end_iter(start_iter); auto tabs = get_line_before(iter); while(iter <= start_iter) { tabs += ' '; iter.forward_char(); } get_buffer()->insert_at_cursor('\n' + tabs); scroll_to(get_buffer()->get_insert()); return true; } } auto after_condition_iter = condition_iter; after_condition_iter.forward_char(); std::string sentence = get_buffer()->get_text(start_iter, after_condition_iter); std::smatch sm; // Indenting after for instance: if(...)\n if(std::regex_match(sentence, sm, no_bracket_statement_regex)) { get_buffer()->insert_at_cursor('\n' + tabs + tab); scroll_to(get_buffer()->get_insert()); return true; } // Indenting after for instance: if(...)\n...;\n else if(*condition_iter == ';' && condition_iter.get_line() > 0 && is_code_iter(condition_iter)) { auto previous_end_iter = start_iter; while(previous_end_iter.backward_char() && !previous_end_iter.ends_line()) { } backward_to_code_or_line_start(previous_end_iter); auto previous_start_iter = get_tabs_end_iter(get_buffer()->get_iter_at_line(get_start_of_expression(previous_end_iter).get_line())); auto previous_tabs = get_line_before(previous_start_iter); if(!previous_end_iter.ends_line()) previous_end_iter.forward_char(); std::string previous_sentence = get_buffer()->get_text(previous_start_iter, previous_end_iter); std::smatch sm2; if(std::regex_match(previous_sentence, sm2, no_bracket_statement_regex)) { get_buffer()->insert_at_cursor('\n' + previous_tabs); scroll_to(get_buffer()->get_insert()); return true; } } // Indenting after ':' else if(*condition_iter == ':' && is_code_iter(condition_iter)) { bool perform_indent = true; auto iter = condition_iter; if(!iter.starts_line()) iter.backward_char(); backward_to_code_or_line_start(iter); if(*iter == ')') { auto token = get_token(get_tabs_end_iter(get_buffer()->get_iter_at_line(iter.get_line()))); if(token != "case") // Do not move left for instance: void Test::Test(): perform_indent = false; } if(perform_indent) { Gtk::TextIter found_curly_iter; if(find_open_symbol_backward(iter, found_curly_iter, '{', '}')) { auto tabs_end_iter = get_tabs_end_iter(get_buffer()->get_iter_at_line(found_curly_iter.get_line())); auto tabs_start_of_sentence = get_line_before(tabs_end_iter); if(tabs.size() == (tabs_start_of_sentence.size() + tab_size)) { auto start_line_iter = get_buffer()->get_iter_at_line(iter.get_line()); auto start_line_plus_tab_size = start_line_iter; for(size_t c = 0; c < tab_size; c++) start_line_plus_tab_size.forward_char(); get_buffer()->erase(start_line_iter, start_line_plus_tab_size); get_buffer()->insert_at_cursor('\n' + tabs); scroll_to(get_buffer()->get_insert()); return true; } else { get_buffer()->insert_at_cursor('\n' + tabs + tab); scroll_to(get_buffer()->get_insert()); return true; } } } } // Indent as in current or next line int line_nr = iter.get_line(); if(iter.ends_line() && (line_nr + 1) < get_buffer()->get_line_count()) { auto next_tabs_end_iter = get_tabs_end_iter(line_nr + 1); if(next_tabs_end_iter.get_line_offset() > tabs_end_iter.get_line_offset()) { get_buffer()->insert_at_cursor('\n' + get_line_before(next_tabs_end_iter)); scroll_to(get_buffer()->get_insert()); return true; } } get_buffer()->insert_at_cursor('\n' + tabs); scroll_to(get_buffer()->get_insert()); return true; } // Indent left when writing }, ) or ] on a new line else if(event->keyval == GDK_KEY_braceright || (use_fixed_continuation_indenting && (event->keyval == GDK_KEY_bracketright || event->keyval == GDK_KEY_parenright))) { std::string bracket; if(event->keyval == GDK_KEY_braceright) bracket = "}"; if(event->keyval == GDK_KEY_bracketright) bracket = "]"; else if(event->keyval == GDK_KEY_parenright) bracket = ")"; std::string line = get_line_before(); if(line.size() >= tab_size && iter.ends_line()) { bool indent_left = true; for(auto c : line) { if(c != tab_char) { indent_left = false; break; } } if(indent_left) { auto line_it = get_buffer()->get_iter_at_line(iter.get_line()); auto line_plus_it = line_it; line_plus_it.forward_chars(tab_size); get_buffer()->erase(line_it, line_plus_it); get_buffer()->insert_at_cursor(bracket); return true; } } } // Indent left when writing { on a new line after for instance if(...)\n... else if(event->keyval == GDK_KEY_braceleft) { auto tabs_end_iter = get_tabs_end_iter(); auto tabs = get_line_before(tabs_end_iter); size_t line_nr = iter.get_line(); if(line_nr > 0 && tabs.size() >= tab_size && iter == tabs_end_iter) { auto previous_end_iter = iter; while(previous_end_iter.backward_char() && !previous_end_iter.ends_line()) { } auto condition_iter = previous_end_iter; backward_to_code_or_line_start(condition_iter); auto previous_start_iter = get_tabs_end_iter(get_buffer()->get_iter_at_line(get_start_of_expression(condition_iter).get_line())); auto previous_tabs = get_line_before(previous_start_iter); auto after_condition_iter = condition_iter; after_condition_iter.forward_char(); if((tabs.size() - tab_size) == previous_tabs.size()) { std::string previous_sentence = get_buffer()->get_text(previous_start_iter, after_condition_iter); std::smatch sm; if(std::regex_match(previous_sentence, sm, no_bracket_statement_regex)) { auto start_iter = iter; start_iter.backward_chars(tab_size); get_buffer()->erase(start_iter, iter); get_buffer()->insert_at_cursor("{"); scroll_to(get_buffer()->get_insert()); return true; } } } } // Mark parameters of templated functions after pressing tab and after writing template argument else if(event->keyval == GDK_KEY_Tab && (event->state & GDK_SHIFT_MASK) == 0) { if(*iter == '>') { iter.forward_char(); Gtk::TextIter parenthesis_end_iter; if(*iter == '(' && is_templated_function(iter, parenthesis_end_iter)) { iter.forward_char(); get_buffer()->select_range(iter, parenthesis_end_iter); scroll_to(get_buffer()->get_insert()); return true; } } // Special case if insert is at beginning of empty line: else if(iter.starts_line() && iter.ends_line() && !get_buffer()->get_has_selection()) { // Indenting after for instance: if(...)\n...;\n auto condition_iter = iter; while(condition_iter.starts_line() && condition_iter.backward_char()) { } backward_to_code_or_line_start(condition_iter); if(*condition_iter == ';' && condition_iter.get_line() > 0 && is_code_iter(condition_iter)) { auto start_iter = get_start_of_expression(condition_iter); auto previous_end_iter = start_iter; while(previous_end_iter.backward_char() && !previous_end_iter.ends_line()) { } backward_to_code_or_line_start(previous_end_iter); auto previous_start_iter = get_tabs_end_iter(get_buffer()->get_iter_at_line(get_start_of_expression(previous_end_iter).get_line())); auto previous_tabs = get_line_before(previous_start_iter); if(!previous_end_iter.ends_line()) previous_end_iter.forward_char(); std::string previous_sentence = get_buffer()->get_text(previous_start_iter, previous_end_iter); std::smatch sm2; if(std::regex_match(previous_sentence, sm2, no_bracket_statement_regex)) { get_buffer()->insert_at_cursor(previous_tabs); scroll_to(get_buffer()->get_insert()); return true; } } } } return false; } bool Source::View::on_key_press_event_smart_brackets(GdkEventKey *event) { if(get_buffer()->get_has_selection()) return false; auto iter = get_buffer()->get_insert()->get_iter(); auto previous_iter = iter; previous_iter.backward_char(); if(is_code_iter(iter)) { // Move after ')' if closed expression if(event->keyval == GDK_KEY_parenright) { if(*iter == ')' && symbol_count(iter, '(', ')') <= 0) { iter.forward_char(); get_buffer()->place_cursor(iter); scroll_to(get_buffer()->get_insert()); return true; } } // Move after '>' if >( and closed expression else if(event->keyval == GDK_KEY_greater) { if(*iter == '>') { iter.forward_char(); Gtk::TextIter parenthesis_end_iter; if(*iter == '(' && is_templated_function(iter, parenthesis_end_iter)) { get_buffer()->place_cursor(iter); scroll_to(get_buffer()->get_insert()); return true; } } } // Move after '(' if >( and select text inside parentheses else if(event->keyval == GDK_KEY_parenleft) { auto previous_iter = iter; previous_iter.backward_char(); if(*previous_iter == '>') { Gtk::TextIter parenthesis_end_iter; if(*iter == '(' && is_templated_function(iter, parenthesis_end_iter)) { iter.forward_char(); get_buffer()->select_range(iter, parenthesis_end_iter); scroll_to(iter); return true; } } } } return false; } bool Source::View::on_key_press_event_smart_inserts(GdkEventKey *event) { keep_snippet_marks = true; ScopeGuard guard{[this] { keep_snippet_marks = false; }}; if(get_buffer()->get_has_selection()) { if(is_bracket_language) { // Remove /**/ around selection if(event->keyval == GDK_KEY_slash) { Gtk::TextIter start, end; get_buffer()->get_selection_bounds(start, end); auto before_start = start; auto after_end = end; if(before_start.backward_char() && *before_start == '*' && before_start.backward_char() && *before_start == '/' && *after_end == '*' && after_end.forward_char() && *after_end == '/') { Mark start_mark(start); Mark end_mark(end); get_buffer()->erase(before_start, start); after_end = end_mark->get_iter(); after_end.forward_chars(2); get_buffer()->erase(end_mark->get_iter(), after_end); get_buffer()->select_range(start_mark->get_iter(), end_mark->get_iter()); return true; } } } Glib::ustring left, right; // Insert () around selection if(event->keyval == GDK_KEY_parenleft) { left = '('; right = ')'; } // Insert [] around selection else if(event->keyval == GDK_KEY_bracketleft) { left = '['; right = ']'; } // Insert {} around selection else if(event->keyval == GDK_KEY_braceleft) { left = '{'; right = '}'; } // Insert <> around selection else if(event->keyval == GDK_KEY_less) { left = '<'; right = '>'; } // Insert '' around selection else if(event->keyval == GDK_KEY_apostrophe) { left = '\''; right = '\''; } // Insert "" around selection else if(event->keyval == GDK_KEY_quotedbl) { left = '"'; right = '"'; } // Insert /**/ around selection else if(is_bracket_language && event->keyval == GDK_KEY_slash) { left = "/*"; right = "*/"; } // Insert $$ around selection else if(event->keyval == GDK_KEY_dollar && language_id == "latex") { left = '$'; right = '$'; } else if(language_id == "markdown" || !is_code_iter(get_buffer()->get_insert()->get_iter()) || !is_code_iter(get_buffer()->get_selection_bound()->get_iter())) { // Insert `` around selection if(event->keyval == GDK_KEY_dead_grave) { left = '`'; right = '`'; } // Insert ** around selection else if(event->keyval == GDK_KEY_asterisk) { left = '*'; right = '*'; } // Insert __ around selection else if(event->keyval == GDK_KEY_underscore) { left = '_'; right = '_'; } // Insert ~~ around selection else if(event->keyval == GDK_KEY_dead_tilde) { left = '~'; right = '~'; } } if(!left.empty() && !right.empty()) { Gtk::TextIter start, end; get_buffer()->get_selection_bounds(start, end); Mark start_mark(start); Mark end_mark(end); get_buffer()->insert(start, left); get_buffer()->insert(end_mark->get_iter(), right); auto start_mark_next_iter = start_mark->get_iter(); start_mark_next_iter.forward_chars(left.size()); get_buffer()->select_range(start_mark_next_iter, end_mark->get_iter()); return true; } return false; } auto iter = get_buffer()->get_insert()->get_iter(); auto previous_iter = iter; previous_iter.backward_char(); auto next_iter = iter; next_iter.forward_char(); auto allow_insertion = [](const Gtk::TextIter &iter) { if(iter.ends_line() || *iter == ' ' || *iter == '\t' || *iter == ';' || *iter == ',' || *iter == ')' || *iter == ']' || *iter == '}' || *iter == '<' || *iter == '>' || *iter == '/') return true; return false; }; if(is_code_iter(iter)) { // Insert () if(event->keyval == GDK_KEY_parenleft && allow_insertion(iter)) { if(symbol_count(iter, '(', ')') >= 0) { get_buffer()->insert_at_cursor(")"); auto iter = get_buffer()->get_insert()->get_iter(); iter.backward_char(); get_buffer()->place_cursor(iter); scroll_to(get_buffer()->get_insert()); return false; } } // Insert [] else if(event->keyval == GDK_KEY_bracketleft && allow_insertion(iter)) { if(symbol_count(iter, '[', ']') >= 0) { get_buffer()->insert_at_cursor("]"); auto iter = get_buffer()->get_insert()->get_iter(); iter.backward_char(); get_buffer()->place_cursor(iter); scroll_to(get_buffer()->get_insert()); return false; } } // Move right on ] in [] else if(event->keyval == GDK_KEY_bracketright) { if(*iter == ']' && symbol_count(iter, '[', ']') <= 0) { iter.forward_char(); get_buffer()->place_cursor(iter); scroll_to(get_buffer()->get_insert()); return true; } } // Insert {} else if(event->keyval == GDK_KEY_braceleft && allow_insertion(iter)) { auto start_iter = get_start_of_expression(iter); // Do not add } if { is at end of line and next line has a higher indentation auto test_iter = iter; while(!test_iter.ends_line() && (*test_iter == ' ' || *test_iter == '\t' || !is_code_iter(test_iter)) && test_iter.forward_char()) { } if(test_iter.ends_line()) { if(iter.get_line() + 1 < get_buffer()->get_line_count() && *start_iter != '(' && *start_iter != '[' && *start_iter != '{') { auto tabs_end_iter = (get_tabs_end_iter(get_buffer()->get_iter_at_line(start_iter.get_line()))); auto next_line_iter = get_buffer()->get_iter_at_line(iter.get_line() + 1); auto next_line_tabs_end_iter = (get_tabs_end_iter(get_buffer()->get_iter_at_line(next_line_iter.get_line()))); if(next_line_tabs_end_iter.get_line_offset() > tabs_end_iter.get_line_offset()) return false; } } Gtk::TextIter close_iter; bool has_right_curly_bracket = false; auto tabs_end_iter = get_tabs_end_iter(start_iter); if(find_close_symbol_forward(iter, close_iter, '{', '}')) { auto found_tabs_end_iter = get_tabs_end_iter(close_iter); if(found_tabs_end_iter.get_line_offset() == tabs_end_iter.get_line_offset()) { has_right_curly_bracket = true; // Special case for functions and classes with no indentation after: namespace {: if(is_cpp && tabs_end_iter.starts_line()) { Gtk::TextIter open_iter; if(find_open_symbol_backward(iter, open_iter, '{', '}')) { if(open_iter.starts_line()) // in case of: namespace test\n{ open_iter.backward_char(); auto iter = get_buffer()->get_iter_at_line(open_iter.get_line()); if(get_token(iter) == "namespace") has_right_curly_bracket = close_iter.forward_char() && find_close_symbol_forward(close_iter, close_iter, '{', '}'); } } // Inside for example {}: else if(found_tabs_end_iter.get_line() == tabs_end_iter.get_line()) has_right_curly_bracket = symbol_count(iter, '{', '}') < 0; } } if(!has_right_curly_bracket) { get_buffer()->insert_at_cursor("}"); auto iter = get_buffer()->get_insert()->get_iter(); iter.backward_char(); get_buffer()->place_cursor(iter); scroll_to(get_buffer()->get_insert()); } return false; } // Move right on } in {} else if(event->keyval == GDK_KEY_braceright) { if(*iter == '}' && symbol_count(iter, '{', '}') <= 0) { iter.forward_char(); get_buffer()->place_cursor(iter); scroll_to(get_buffer()->get_insert()); return true; } } // Insert '' else if(event->keyval == GDK_KEY_apostrophe && allow_insertion(iter) && symbol_count(iter, '\'') % 2 == 0) { get_buffer()->insert_at_cursor("''"); auto iter = get_buffer()->get_insert()->get_iter(); iter.backward_char(); get_buffer()->place_cursor(iter); scroll_to(get_buffer()->get_insert()); return true; } // Insert "" else if(event->keyval == GDK_KEY_quotedbl && allow_insertion(iter) && symbol_count(iter, '"') % 2 == 0) { get_buffer()->insert_at_cursor("\"\""); auto iter = get_buffer()->get_insert()->get_iter(); iter.backward_char(); get_buffer()->place_cursor(iter); scroll_to(get_buffer()->get_insert()); return true; } // Move right on last ' in '', or last " in "" else if(((event->keyval == GDK_KEY_apostrophe && *iter == '\'') || (event->keyval == GDK_KEY_quotedbl && *iter == '\"')) && is_spellcheck_iter(iter)) { get_buffer()->place_cursor(next_iter); scroll_to(get_buffer()->get_insert()); return true; } // Insert ; at the end of line, if iter is at the last ) else if(event->keyval == GDK_KEY_semicolon) { if(*iter == ')' && symbol_count(iter, '(', ')') <= 0 && next_iter.ends_line()) { auto start_iter = get_start_of_expression(previous_iter); if(*start_iter == '(') { start_iter.backward_char(); if(*start_iter == ' ') start_iter.backward_char(); auto token = get_token(start_iter); if(token != "for" && token != "if" && token != "while" && token != "else") { iter.forward_char(); get_buffer()->place_cursor(iter); get_buffer()->insert_at_cursor(";"); scroll_to(get_buffer()->get_insert()); return true; } } } } // Delete () else if(event->keyval == GDK_KEY_BackSpace) { if(*previous_iter == '(' && *iter == ')' && symbol_count(iter, '(', ')') <= 0) { auto next_iter = iter; next_iter.forward_char(); get_buffer()->erase(previous_iter, next_iter); scroll_to(get_buffer()->get_insert()); return true; } // Delete [] else if(*previous_iter == '[' && *iter == ']' && symbol_count(iter, '[', ']') <= 0) { auto next_iter = iter; next_iter.forward_char(); get_buffer()->erase(previous_iter, next_iter); scroll_to(get_buffer()->get_insert()); return true; } // Delete {} else if(*previous_iter == '{' && *iter == '}' && symbol_count(iter, '{', '}') <= 0) { auto next_iter = iter; next_iter.forward_char(); get_buffer()->erase(previous_iter, next_iter); scroll_to(get_buffer()->get_insert()); return true; } // Delete '' or "" else if(event->keyval == GDK_KEY_BackSpace) { if((*previous_iter == '\'' && *iter == '\'') || (*previous_iter == '"' && *iter == '"')) { get_buffer()->erase(previous_iter, next_iter); scroll_to(get_buffer()->get_insert()); return true; } } } } return false; } bool Source::View::on_button_press_event(GdkEventButton *event) { // Select range when double clicking if(event->type == GDK_2BUTTON_PRESS) { Gtk::TextIter start, end; get_buffer()->get_selection_bounds(start, end); auto iter = start; while((*iter >= 48 && *iter <= 57) || (*iter >= 65 && *iter <= 90) || (*iter >= 97 && *iter <= 122) || *iter == 95) { start = iter; if(!iter.backward_char()) break; } while((*end >= 48 && *end <= 57) || (*end >= 65 && *end <= 90) || (*end >= 97 && *end <= 122) || *end == 95) { if(!end.forward_char()) break; } get_buffer()->select_range(start, end); return true; } // Go to implementation or declaration if((event->type == GDK_BUTTON_PRESS) && (event->button == 1)) { if(event->state & primary_modifier_mask) { int x, y; window_to_buffer_coords(Gtk::TextWindowType::TEXT_WINDOW_TEXT, event->x, event->y, x, y); Gtk::TextIter iter; get_iter_at_location(iter, x, y); if(iter) get_buffer()->place_cursor(iter); Menu::get().actions["source_goto_declaration_or_implementation"]->activate(); return true; } } // Open right click menu if((event->type == GDK_BUTTON_PRESS) && (event->button == 3)) { hide_tooltips(); if(!get_buffer()->get_has_selection()) { int x, y; window_to_buffer_coords(Gtk::TextWindowType::TEXT_WINDOW_TEXT, event->x, event->y, x, y); Gtk::TextIter iter; get_iter_at_location(iter, x, y); if(iter) get_buffer()->place_cursor(iter); Menu::get().right_click_line_menu->popup(event->button, event->time); } else { Menu::get().right_click_selected_menu->popup(event->button, event->time); } return true; } return Gsv::View::on_button_press_event(event); }