static void toggle_comment_multiline (IAnjutaEditor *editor, IAnjutaIterable *start, IAnjutaIterable *end) { IAnjutaIterable *start_copy, *end_copy; gchar *text; gboolean is_commented; start_copy = ianjuta_iterable_clone (start, NULL); end_copy = ianjuta_iterable_clone (end, NULL); is_commented = is_commented_multiline (editor, start_copy, end_copy); text = ianjuta_editor_get_text (editor, start_copy, end_copy, NULL); if (is_commented) { ianjuta_editor_erase (editor, start_copy, end_copy, NULL); ianjuta_editor_insert (editor, start_copy, text + 2, (strlen (text) - 4), NULL); } else { ianjuta_editor_insert (editor, end, "*/", -1, NULL); ianjuta_editor_insert (editor, start, "/*", -1, NULL); } g_object_unref (start_copy); g_object_unref (end_copy); g_free (text); }
/* Returns TRUE if the line is continuation of previous line (that is, it is * part of the same logical line). */ static gboolean line_is_continuation (IAnjutaEditor *editor, IAnjutaIterable *iter) { int is_continuation = FALSE; IAnjutaIterable *new_iter = ianjuta_iterable_clone (iter, NULL); if (skip_iter_to_previous_line (editor, new_iter)) { while (ianjuta_iterable_previous (new_iter, NULL)) { gchar ch = ianjuta_editor_cell_get_char (IANJUTA_EDITOR_CELL (new_iter), 0, NULL); if (ch == ' ' || ch == '\t') continue; if (ch == '\\') { is_continuation = TRUE; break; } if (iter_is_newline (new_iter, ch)) break; } } g_object_unref (new_iter); return is_continuation; }
void cpp_java_indentation_changed (IAnjutaEditor *editor, IAnjutaIterable *position, gboolean added, gint length, gint lines, const gchar *text, IndentCPlugin* plugin) { /* If autoindent is enabled*/ if (plugin->smart_indentation) { if (g_settings_get_boolean (plugin->settings, PREF_BRACE_AUTOCOMPLETION)) { if (!added && length == 1 && (*text == '[' || *text == '(')) { IAnjutaIterable *next; gchar *next_char; next = ianjuta_iterable_clone (position, NULL); ianjuta_iterable_next (next, NULL); next_char = ianjuta_editor_get_text (editor, position, next, NULL); if ((*text == '[' && *next_char == ']') || (*text == '(' && *next_char == ')')) erase_editor_blocked (editor, position, next, plugin); } } } }
static gboolean line_is_preprocessor (IAnjutaEditor *editor, IAnjutaIterable *iter) { gboolean is_preprocessor = FALSE; IAnjutaIterable *new_iter = ianjuta_iterable_clone (iter, NULL); if (skip_iter_to_previous_logical_line (editor, new_iter)) { /* Forward the newline char and point to line begin of next line */ gchar ch; ch = ianjuta_editor_cell_get_char (IANJUTA_EDITOR_CELL (new_iter), 0, NULL); skip_iter_to_newline_tail (new_iter, ch); ianjuta_iterable_next (new_iter, NULL); } /* else, line is already pointed at first char of the line */ do { gchar ch; ch = ianjuta_editor_cell_get_char (IANJUTA_EDITOR_CELL (new_iter), 0, NULL); if (ch == '#') { is_preprocessor = TRUE; break; } if (iter_is_newline (new_iter, ch) || !isspace (ch)) break; } while (ianjuta_iterable_next (new_iter, NULL)); g_object_unref (new_iter); return is_preprocessor; }
/** * parser_cxx_assist_parse_expression: * @assist: self, * @iter: current cursor position * @start_iter: return location for the start of the completion * * Returns: An iter of a list of IAnjutaSymbols or NULL */ static IAnjutaIterable* parser_cxx_assist_parse_expression (ParserCxxAssist* assist, IAnjutaIterable* iter, IAnjutaIterable** start_iter) { IAnjutaEditor* editor = IANJUTA_EDITOR (assist->priv->iassist); IAnjutaIterable* res = NULL; IAnjutaIterable* cur_pos = ianjuta_iterable_clone (iter, NULL); gboolean op_start = FALSE; gboolean ref_start = FALSE; gchar* stmt = NULL; /* Cursor points after the current characters, move back */ ianjuta_iterable_previous (cur_pos, NULL); /* Search for a operator in the current line */ do { gchar ch = ianjuta_editor_cell_get_char (IANJUTA_EDITOR_CELL(cur_pos), 0, NULL); if (parser_cxx_assist_is_expression_separator(ch, FALSE, iter)) { break; } if (ch == '.' || (op_start && ch == '-') || (ref_start && ch == ':')) { /* Found an operator, get the statement and the pre_word */ IAnjutaIterable* pre_word_start = ianjuta_iterable_clone (cur_pos, NULL); IAnjutaIterable* pre_word_end = ianjuta_iterable_clone (iter, NULL); IAnjutaIterable* stmt_end = ianjuta_iterable_clone (pre_word_start, NULL); /* we need to pass to the parser all the statement included the last * operator, being it "." or "->" or "::" * Increase the end bound of the statement. */ ianjuta_iterable_next (stmt_end, NULL); if (op_start == TRUE || ref_start == TRUE) ianjuta_iterable_next (stmt_end, NULL); /* Move one character forward so we have the start of the pre_word * and not the last operator */ ianjuta_iterable_next (pre_word_start, NULL); /* If this is a two character operator, skip the second character */ if (op_start) { ianjuta_iterable_next (pre_word_start, NULL); } parser_cxx_assist_update_pre_word (assist, ianjuta_editor_get_text ( editor, pre_word_start, pre_word_end, NULL)); /* Try to get the name of the variable */ while (ianjuta_iterable_previous (cur_pos, NULL)) { gchar word_ch = ianjuta_editor_cell_get_char ( IANJUTA_EDITOR_CELL(cur_pos), 0, NULL); if (parser_cxx_assist_is_expression_separator(word_ch, FALSE, cur_pos)) break; } ianjuta_iterable_next (cur_pos, NULL); stmt = ianjuta_editor_get_text (editor, cur_pos, stmt_end, NULL); *start_iter = pre_word_start; g_object_unref (stmt_end); g_object_unref (pre_word_end); break; } else if (ch == '>') op_start = TRUE; else if (ch == ':') ref_start = TRUE; else { op_start = FALSE; ref_start = FALSE; } } while (ianjuta_iterable_previous (cur_pos, NULL)); if (stmt) { gint lineno; gchar *above_text; IAnjutaIterable* start; if (!assist->priv->editor_filename) { g_free (stmt); return NULL; } start = ianjuta_editor_get_start_position (editor, NULL); above_text = ianjuta_editor_get_text (editor, start, iter, NULL); g_object_unref (start); lineno = ianjuta_editor_get_lineno (editor, NULL); /* the parser works even for the "Gtk::" like expressions, so it * shouldn't be created a specific case to handle this. */ res = engine_parser_process_expression (stmt, above_text, assist->priv->editor_filename, lineno); g_free (stmt); } g_object_unref (cur_pos); return res; }
static void toggle_comment_singleline (CppJavaPlugin *plugin, IAnjutaEditor *editor, gint line) { IAnjutaIterable *begin, *end, *begin_copy, *end_copy; gchar *text, *text_stripped, **text_diff = NULL; begin = ianjuta_editor_get_line_begin_position (editor, line, NULL); end = ianjuta_editor_get_line_end_position (editor, line, NULL); begin_copy = ianjuta_iterable_clone (begin, NULL); end_copy = ianjuta_iterable_clone (end, NULL); if (is_commented_multiline (editor, begin_copy, end_copy)) { toggle_comment_multiline (editor, begin_copy, end_copy); g_object_unref (begin); g_object_unref (end); g_object_unref (begin_copy); g_object_unref (end_copy); return; } g_object_unref (begin_copy); g_object_unref (end_copy); text = ianjuta_editor_get_text (editor, begin, end, NULL); text_stripped = g_strstrip (g_strdup (text)); text_diff = g_strsplit (text, text_stripped, 2); if (plugin->current_language && (g_str_equal (plugin->current_language, "C"))) { if (g_str_has_prefix (text_stripped, "/*") && g_str_has_suffix (text_stripped, "*/")) { ianjuta_editor_erase (editor, begin, end, NULL); ianjuta_editor_insert (editor, begin, text_stripped + 2, (strlen (text_stripped) - 4), NULL); if (text_diff != NULL) ianjuta_editor_insert (editor, begin, *text_diff, -1, NULL); } else { ianjuta_editor_insert (editor, end, "*/", -1, NULL); ianjuta_editor_insert (editor, begin, "/*", -1, NULL); } } else { if (g_str_has_prefix (text_stripped, "//")) { ianjuta_editor_erase (editor, begin, end, NULL); ianjuta_editor_insert (editor, begin, text_stripped + 2, -1, NULL); if (text_diff != NULL) ianjuta_editor_insert (editor, begin, *text_diff, -1, NULL); } else { ianjuta_editor_insert (editor, begin, "//", -1, NULL); } } g_object_unref (begin); g_object_unref (end); g_free (text); g_free (text_stripped); g_strfreev (text_diff); }
gboolean search_box_incremental_search (SearchBox* search_box, gboolean search_forward, gboolean search_next, gboolean wrap) { IAnjutaIterable* real_start; IAnjutaEditorCell* search_start; IAnjutaEditorCell* search_end; IAnjutaEditorCell* result_start; IAnjutaEditorCell* result_end; IAnjutaEditorSelection* selection; const gchar* search_text = gtk_entry_get_text (GTK_ENTRY (search_box->priv->search_entry)); gboolean found = FALSE; if (!search_box->priv->current_editor || !search_text || !strlen (search_text)) return FALSE; selection = IANJUTA_EDITOR_SELECTION (search_box->priv->current_editor); if (ianjuta_editor_selection_has_selection (selection, NULL)) { search_start = IANJUTA_EDITOR_CELL (ianjuta_editor_selection_get_start (selection, NULL)); } else { search_start = IANJUTA_EDITOR_CELL (ianjuta_editor_get_position (search_box->priv->current_editor, NULL)); } real_start = ianjuta_iterable_clone (IANJUTA_ITERABLE (search_start), NULL); /* If forward, set search start and end to current position of * cursor and editor end, respectively, or if backward to editor * start and current position of cursor, respectively. Current * position of cursor is selection start if have selection. */ if (search_forward) { search_end = IANJUTA_EDITOR_CELL (ianjuta_editor_get_position (search_box->priv->current_editor, NULL)); ianjuta_iterable_last (IANJUTA_ITERABLE (search_end), NULL); } else { search_end = search_start; search_start = IANJUTA_EDITOR_CELL (ianjuta_editor_get_position (search_box->priv->current_editor, NULL)); ianjuta_iterable_first (IANJUTA_ITERABLE (search_start), NULL); } /* When there's a selection, if forward, set search start and end * to match end and editor end, respectively, or if backward to * editor start and match start, respectively. If forward and * selection starts with a match, look for next match. */ if (ianjuta_editor_selection_has_selection (selection, NULL) && search_next) { gchar* selected_text = ianjuta_editor_selection_get (selection, NULL); gint start_pos, end_pos; gboolean selected_have_search_text = FALSE; selected_have_search_text = search_box->priv->regex_mode ? search_regex_in_text (search_text, selected_text, TRUE, &start_pos, &end_pos) : search_str_in_text (search_text, selected_text, search_box->priv->case_sensitive, &start_pos, &end_pos); if (selected_have_search_text) { IAnjutaIterable* selection_start = ianjuta_editor_selection_get_start (selection, NULL); if (search_forward && start_pos == 0) { end_pos += ianjuta_iterable_get_position(IANJUTA_ITERABLE (selection_start), NULL); ianjuta_iterable_set_position (IANJUTA_ITERABLE(search_start), end_pos, NULL); ianjuta_iterable_last (IANJUTA_ITERABLE (search_end), NULL); } else if (!search_forward) { start_pos += ianjuta_iterable_get_position(IANJUTA_ITERABLE (selection_start), NULL); ianjuta_iterable_set_position (IANJUTA_ITERABLE(search_end), start_pos, NULL); ianjuta_iterable_first (IANJUTA_ITERABLE (search_start), NULL); } g_object_unref (selection_start); } g_free (selected_text); } /* Try searching in current position */ found = editor_search (search_box->priv->current_editor, search_text, search_box->priv->case_sensitive, search_forward, search_box->priv->regex_mode, search_start, search_end, &result_start, &result_end); if (found) { anjuta_status_pop (ANJUTA_STATUS (search_box->priv->status)); } else if (wrap) { /* Try to wrap if not found */ ianjuta_iterable_first (IANJUTA_ITERABLE (search_start), NULL); ianjuta_iterable_last (IANJUTA_ITERABLE (search_end), NULL); /* Try to search again */ found = editor_search (search_box->priv->current_editor, search_text, search_box->priv->case_sensitive, search_forward, search_box->priv->regex_mode, search_start, search_end, &result_start, &result_end); /* Check if successful */ if (found) { if (ianjuta_iterable_compare (IANJUTA_ITERABLE (result_start), real_start, NULL) != 0) { anjuta_status_pop (search_box->priv->status); if (search_forward) { anjuta_status_push (search_box->priv->status, _("Search for \"%s\" reached the end and was continued at the top."), search_text); } else { anjuta_status_push (search_box->priv->status, _("Search for \"%s\" reached top and was continued at the bottom."), search_text); } } else if (ianjuta_editor_selection_has_selection (selection, NULL)) { found = FALSE; anjuta_status_pop (search_box->priv->status); if (search_forward) { anjuta_status_push (search_box->priv->status, _("Search for \"%s\" reached the end and was continued at the top but no new match was found."), search_text); } else { anjuta_status_push (search_box->priv->status, _("Search for \"%s\" reached top and was continued at the bottom but no new match was found."), search_text); } } else { found = FALSE; } } } if (found) { ianjuta_editor_selection_set (selection, IANJUTA_ITERABLE (result_start), IANJUTA_ITERABLE (result_end), TRUE, NULL); g_object_unref (result_start); g_object_unref (result_end); } search_box_set_entry_color (search_box, found); g_object_unref (real_start); g_object_unref (search_start); g_object_unref (search_end); return found; }
/* incomplete_statement: * 1 == COMPLETE STATEMENT * 0 == INCOMPLETE STATEMENT * -1 == UNKNOWN */ static gint get_line_indentation_base (IndentCPlugin *plugin, IAnjutaEditor *editor, gint line_num, gint *incomplete_statement, gint *parenthesis_indentation, gboolean *colon_indent) { IAnjutaIterable *iter; gchar point_ch; gint line_indent = 0; gint extra_indent = 0; gboolean looking_at_just_next_line = TRUE; gboolean current_line_is_preprocessor = FALSE; gboolean current_line_is_continuation = FALSE; gboolean line_checked_for_comment = FALSE; /* Determine whether or not to add multi-line comment asterisks */ const gchar *comment_continued = " * "; IAnjutaIterable *line_begin = ianjuta_editor_get_line_begin_position (editor, line_num, NULL); IAnjutaIterable *line_end = ianjuta_editor_get_line_end_position (editor, line_num, NULL); *incomplete_statement = -1; *parenthesis_indentation = 0; if (line_num <= 1) return 0; /* DEBUG_PRINT ("In %s()", __FUNCTION__); */ iter = ianjuta_editor_get_line_begin_position (editor, line_num, NULL); current_line_is_preprocessor = line_is_preprocessor (editor, iter); current_line_is_continuation = line_is_continuation (editor, iter); /* DEBUG_PRINT ("Current line is preprocessor = %d", current_line_is_preprocessor); DEBUG_PRINT ("Current line is continuation = %d", current_line_is_continuation); */ /* line_indent = get_line_indentation (editor, line_num - 1); */ if (current_line_is_preprocessor && current_line_is_continuation) { /* Continuation of preprocessor line -- just maintain indentation */ g_object_unref (iter); return get_line_indentation (editor, line_num - 1); } else if (current_line_is_preprocessor) { /* Preprocessor line -- indentation should be 0 */ g_object_unref (iter); return 0; } while (ianjuta_iterable_previous (iter, NULL)) { /* Skip strings */ IAnjutaEditorAttribute attrib = ianjuta_editor_cell_get_attribute (IANJUTA_EDITOR_CELL (iter), NULL); if (attrib == IANJUTA_EDITOR_STRING) continue; point_ch = ianjuta_editor_cell_get_char (IANJUTA_EDITOR_CELL (iter), 0, NULL); /* DEBUG_PRINT("point_ch = %c", point_ch); */ /* Check for line comment comment */ if (!line_checked_for_comment && !isspace(point_ch)) { gboolean comment = FALSE; IAnjutaIterable* new_iter = ianjuta_iterable_clone (iter, NULL); do { gchar c; /* Skip strings */ if (ianjuta_editor_cell_get_attribute (IANJUTA_EDITOR_CELL (new_iter), NULL) == IANJUTA_EDITOR_STRING) continue; c = ianjuta_editor_cell_get_char (IANJUTA_EDITOR_CELL (new_iter), 0, NULL); if (iter_is_newline (new_iter, c)) { line_checked_for_comment = TRUE; break; } if (c == '/') { IAnjutaIterable* tmp_iter = ianjuta_iterable_clone (new_iter, NULL); if (!ianjuta_iterable_previous (tmp_iter, NULL)) { g_object_unref (tmp_iter); break; } c = ianjuta_editor_cell_get_char (IANJUTA_EDITOR_CELL (tmp_iter), 0, NULL); if (c == '/') { /* is a line comment, skip until begin of comment */ comment = TRUE; g_object_unref (tmp_iter); break; } g_object_unref (tmp_iter); } } while (ianjuta_iterable_previous (new_iter, NULL)); if (comment) { ianjuta_iterable_assign (iter, new_iter, NULL); ianjuta_iterable_previous (iter, NULL); g_object_unref (new_iter); continue; } g_object_unref (new_iter); } /* Check if we are inside a comment */ if (point_ch == '/' || point_ch == '*') { gboolean comment = FALSE; gboolean comment_end = FALSE; IAnjutaIterable* new_iter = ianjuta_iterable_clone (iter, NULL); do { gchar c = ianjuta_editor_cell_get_char (IANJUTA_EDITOR_CELL(new_iter), 0, NULL); if (!comment_end && iter_is_newline (new_iter, c)) { break; } if (c == '*') { IAnjutaIterable* prev = ianjuta_iterable_clone (new_iter, NULL); IAnjutaIterable* next = ianjuta_iterable_clone (new_iter, NULL); ianjuta_iterable_previous (prev, NULL); ianjuta_iterable_next (next, NULL); gchar prev_c = ianjuta_editor_cell_get_char (IANJUTA_EDITOR_CELL (prev), 0, NULL); gchar next_c = ianjuta_editor_cell_get_char (IANJUTA_EDITOR_CELL (next), 0, NULL); if (prev_c == '/') { /* starts comment */ comment = TRUE; if (!comment_end) { extra_indent++; /* If a multiline comment is continuing, check the next line and insert " * " * only if it does not already exist there. The purpose of this fix is to avoid * extra " * " on auto-indent. */ if ((g_settings_get_boolean (plugin->settings, PREF_COMMENT_LEADING_ASTERISK)) && (ianjuta_iterable_compare (line_end, line_begin, NULL)) == 0) { ianjuta_editor_insert (editor, line_begin, comment_continued, -1, NULL); } /* In the middle of a comment we can't know * if the statement is incomplete */ *incomplete_statement = -1; /* ":" have to be ignored inside comments */ if (*colon_indent) { *colon_indent = FALSE; extra_indent -= INDENT_SIZE; } } g_object_unref (prev); g_object_unref (next); break; } else if (next_c == '/') { /* ends comment: */ comment_end = TRUE; g_object_unref (prev); g_object_unref (next); continue; } /* Possibly continued comment */ else if (isspace(prev_c)) { gboolean possible_comment = FALSE; while (ianjuta_iterable_previous (prev, NULL)) { prev_c = ianjuta_editor_cell_get_char (IANJUTA_EDITOR_CELL (prev), 0, NULL); if (!isspace(prev_c)) break; if (iter_is_newline (prev, prev_c)) { possible_comment = TRUE; break; } } if (possible_comment) { ianjuta_iterable_assign (new_iter, prev, NULL); g_object_unref (prev); g_object_unref (next); continue; } } g_object_unref (prev); g_object_unref (next); } } while (ianjuta_iterable_previous (new_iter, NULL)); if (comment) { ianjuta_iterable_assign (iter, new_iter, NULL); ianjuta_iterable_previous (iter, NULL); g_object_unref (new_iter); continue; } g_object_unref (new_iter); } if (point_ch == ')' || point_ch == ']' || point_ch == '}') { gint line_saved; line_saved = ianjuta_editor_get_line_from_position (editor, iter, NULL); /* If we encounter a block-end before anything else, the * statement could hardly be incomplte. */ if (point_ch == '}' && *incomplete_statement == -1) *incomplete_statement = 0; /* If at level 0 indentation, encoutered a * block end, don't bother going further */ if (point_ch == '}' && get_line_indentation (editor, line_saved) <= 0) { line_indent = 0; line_indent += extra_indent; break; } /* Find matching brace and continue */ if (!anjuta_util_jump_to_matching_brace (iter, point_ch, -1)) { line_indent = get_line_indentation (editor, line_saved); line_indent += extra_indent; break; } } else if (point_ch == '{') { gint line_for_indent = ianjuta_editor_get_line_from_position (editor, iter, NULL); line_indent = get_line_indentation (editor, line_for_indent); /* Increase line indentation */ line_indent += INDENT_SIZE; line_indent += extra_indent; /* If we encounter a block-start before anything else, the * statement could hardly be incomplte. */ if (point_ch == '{' && *incomplete_statement == -1) *incomplete_statement = 0; break; } else if (point_ch == '(' || point_ch == '[') { line_indent = 0; if (g_settings_get_boolean (plugin->settings, PREF_INDENT_PARENTHESIS_LINEUP)) { while (ianjuta_iterable_previous (iter, NULL)) { gchar dummy_ch = ianjuta_editor_cell_get_char (IANJUTA_EDITOR_CELL (iter), 0, NULL); if (iter_is_newline (iter, dummy_ch)) { skip_iter_to_newline_head (iter, dummy_ch); break; } if (dummy_ch == '\t') line_indent += TAB_SIZE; else (*parenthesis_indentation)++; } (*parenthesis_indentation)++; line_indent += extra_indent; } else { gint line_for_indent = ianjuta_editor_get_line_from_position (editor, iter, NULL); line_indent = get_line_indentation (editor, line_for_indent); line_indent += extra_indent; (*parenthesis_indentation) += g_settings_get_int (plugin->settings, PREF_INDENT_PARENTHESIS_SIZE); } /* Although statement is incomplete at this point, we don't * set it to incomplete and just leave it to unknown to avaoid * increating indentation for it, because incomplete braces, * overrides any existing indentation */ *incomplete_statement = -1; break; } else if (point_ch == ';' || point_ch == ',') { /* If we encounter statement-end before any non-whitespace * char, the statement is complete. */ if (*incomplete_statement == -1) *incomplete_statement = 0; } else if (point_ch == ':' && *colon_indent == FALSE) { /* This is a forward reference, all lines below should have * increased indentation until the next statement has * a ':' * If current line indentation is zero, that we don't indent */ IAnjutaIterable* new_iter = ianjuta_iterable_clone (iter, NULL); IAnjutaIterable* line_begin; gboolean indent = FALSE; gchar c; /* Is the last non-whitespace in line */ while (ianjuta_iterable_next (new_iter, NULL)) { c = ianjuta_editor_cell_get_char (IANJUTA_EDITOR_CELL (new_iter), 0, NULL); if (!isspace(c)) break; if (iter_is_newline (new_iter, c)) { indent = TRUE; break; } } line_begin = ianjuta_editor_get_line_begin_position(editor, ianjuta_editor_get_line_from_position(editor, iter, NULL), NULL); c = ianjuta_editor_cell_get_char (IANJUTA_EDITOR_CELL (line_begin), 0, NULL); if (indent) { *colon_indent = TRUE; if (*incomplete_statement == -1) *incomplete_statement = 0; } if (indent && isspace(c)) { extra_indent += INDENT_SIZE; } g_object_unref (new_iter); g_object_unref (line_begin); } else if (iter_is_newline (iter, point_ch)) { skip_iter_to_newline_head (iter, point_ch); /* We just crossed a line boundary. Skip any preprocessor lines, * and ensure that line_indent is updated with correct real * previous non-preprocessor line. */ if (skip_preprocessor_lines (editor, iter) && looking_at_just_next_line) { /* gint line = ianjuta_editor_get_line_from_position (editor, iter, NULL); line_indent = get_line_indentation (editor, line); */ } looking_at_just_next_line = FALSE; line_checked_for_comment = FALSE; } else if (!isspace (point_ch)) { /* If we encounter any non-whitespace char before any of the * statement-complete indicators, the statement is basically * incomplete */ if (*incomplete_statement == -1) *incomplete_statement = 1; } } if (!line_indent && extra_indent) { line_indent += extra_indent; } g_object_unref (iter); return line_indent; }
static gint set_line_indentation (IndentCPlugin *plugin, IAnjutaEditor *editor, gint line_num, gint indentation, gint parenthesis_indentation) { IAnjutaIterable *line_begin, *line_end, *indent_position; IAnjutaIterable *current_pos; gint carat_offset, nchars = 0; gchar *old_indent_string = NULL, *indent_string = NULL; /* DEBUG_PRINT ("In %s()", __FUNCTION__); */ line_begin = ianjuta_editor_get_line_begin_position (editor, line_num, NULL); line_end = ianjuta_editor_get_line_end_position (editor, line_num, NULL); /* DEBUG_PRINT ("line begin = %d, line end = %d, current_pos = %d", line_begin, line_end, current_pos); */ indent_position = ianjuta_iterable_clone (line_begin, NULL); if (ianjuta_iterable_compare (line_end, line_begin, NULL) > 0) { gchar *idx; gchar *line_string = ianjuta_editor_get_text (editor, line_begin, line_end, NULL); //DEBUG_PRINT ("line_string = '%s'", line_string); if (line_string) { idx = line_string; /* Find first non-white space */ while (*idx != '\0' && isspace (*idx)) { idx = g_utf8_find_next_char (idx, NULL); ianjuta_iterable_next (indent_position, NULL); } g_free (line_string); } } /* Indent iter defined at this point, Identify how much is current * position is beyound this point. We need to restore it later after * indentation */ current_pos = ianjuta_editor_get_position (editor, NULL); carat_offset = ianjuta_iterable_diff (indent_position, current_pos, NULL); //DEBUG_PRINT ("carat offset is = %d", carat_offset); /* Set new indentation */ if ((indentation + parenthesis_indentation) > 0) { indent_string = get_line_indentation_string (plugin, editor, indentation, parenthesis_indentation); nchars = indent_string ? g_utf8_strlen (indent_string, -1) : 0; /* Only indent if there is something to indent with */ if (indent_string) { /* Get existing indentation */ if (ianjuta_iterable_compare (indent_position, line_begin, NULL) > 0) { old_indent_string = ianjuta_editor_get_text (editor, line_begin, indent_position, NULL); //DEBUG_PRINT ("old_indent_string = '%s'", old_indent_string); } /* Only indent if there was no indentation before or old * indentation string was different from the new indent string */ if (old_indent_string == NULL || strcmp (old_indent_string, indent_string) != 0) { /* Remove the old indentation string, if there is any */ if (old_indent_string) ianjuta_editor_erase (editor, line_begin, indent_position, NULL); /* Insert the new indentation string */ ianjuta_editor_insert (editor, line_begin, indent_string, -1, NULL); } } } /* If indentation == 0, we really didn't enter the previous code block, * but we may need to clear existing indentation. */ if ((indentation + parenthesis_indentation) == 0) { /* Get existing indentation */ if (ianjuta_iterable_compare (indent_position, line_begin, NULL) > 0) { old_indent_string = ianjuta_editor_get_text (editor, line_begin, indent_position, NULL); } if (old_indent_string) ianjuta_editor_erase (editor, line_begin, indent_position, NULL); } /* Restore current position */ if (carat_offset >= 0) { /* If the cursor was not before the first non-space character in * the line, restore it's position after indentation. */ gint i; IAnjutaIterable *pos = ianjuta_editor_get_line_begin_position (editor, line_num, NULL); for (i = 0; i < nchars + carat_offset; i++) ianjuta_iterable_next (pos, NULL); ianjuta_document_begin_undo_action (IANJUTA_DOCUMENT(editor), NULL); ianjuta_editor_goto_position (editor, pos, NULL); ianjuta_document_end_undo_action (IANJUTA_DOCUMENT(editor), NULL); g_object_unref (pos); } else /* cursor_offset < 0 */ { /* If the cursor was somewhere in the old indentation spaces, * home the cursor to first non-space character in the line (or * end of line if there is no non-space characters in the line. */ gint i; IAnjutaIterable *pos = ianjuta_editor_get_line_begin_position (editor, line_num, NULL); for (i = 0; i < nchars; i++) ianjuta_iterable_next (pos, NULL); ianjuta_document_begin_undo_action (IANJUTA_DOCUMENT(editor), NULL); ianjuta_editor_goto_position (editor, pos, NULL); ianjuta_document_end_undo_action (IANJUTA_DOCUMENT(editor), NULL); g_object_unref (pos); } g_object_unref (current_pos); g_object_unref (indent_position); g_object_unref (line_begin); g_object_unref (line_end); g_free (old_indent_string); g_free (indent_string); return nchars; }
/* Skips to the end-of-line of previous non-preprocessor line. Any multiple * preprocessor lines are skipped. If current * line is not preprocessor line, nothing happens. If there is no previous * non-preprocessor line (we are at first line of the document which happens * to be preprocessor line), iter is set to the first character in the * document. It returns TRUE if the line is preprocessor line, otherwise * FALSE. */ static gboolean skip_preprocessor_lines (IAnjutaEditor *editor, IAnjutaIterable *iter) { gboolean line_found = FALSE; gboolean preprocessor_found = FALSE; IAnjutaIterable *new_iter = ianjuta_iterable_clone (iter, NULL); do { gboolean is_preprocessor = FALSE; if (skip_iter_to_previous_logical_line (editor, new_iter)) { gchar ch; ch = ianjuta_editor_cell_get_char (IANJUTA_EDITOR_CELL (new_iter), 0, NULL); skip_iter_to_newline_tail (new_iter, ch); ianjuta_iterable_next (new_iter, NULL); } do { gchar ch = ianjuta_editor_cell_get_char (IANJUTA_EDITOR_CELL (new_iter), 0, NULL); if (ch == '#') { is_preprocessor = TRUE; /* DEBUG_PRINT ("Line %d is preprocessor line .. Skipping", ianjuta_editor_get_line_from_position (editor, new_iter, NULL)); */ break; } if (iter_is_newline (new_iter, ch) || !isspace (ch)) { skip_iter_to_newline_tail (new_iter, ch); break; } } while (ianjuta_iterable_next (new_iter, NULL)); if (is_preprocessor) { line_found = skip_iter_to_previous_line (editor, new_iter); ianjuta_iterable_assign (iter, new_iter, NULL); preprocessor_found = TRUE; } else { /* DEBUG_PRINT ("Line %d is *not* preprocessor line .. Breaking", ianjuta_editor_get_line_from_position (editor, new_iter, NULL)); */ break; } } while (line_found); g_object_unref (new_iter); return preprocessor_found; }
void cpp_java_indentation_char_added (IAnjutaEditor *editor, IAnjutaIterable *insert_pos, gchar ch, IndentCPlugin *plugin) { IAnjutaEditorAttribute attrib; IAnjutaIterable *iter; gboolean should_auto_indent = FALSE; iter = ianjuta_iterable_clone (insert_pos, NULL); /* If autoindent is enabled*/ if (plugin->smart_indentation) { /* DEBUG_PRINT ("Char added at position %d: '%c'", insert_pos, ch); */ if (iter_is_newline (iter, ch)) { skip_iter_to_newline_head (iter, ch); /* All newline entries means enable indenting */ should_auto_indent = TRUE; } else if (ch == '{' || ch == '}' || ch == '#') { /* Indent only when it's the first non-white space char in the line */ /* Don't bother if we are inside string */ attrib = ianjuta_editor_cell_get_attribute (IANJUTA_EDITOR_CELL (iter), NULL); if (attrib != IANJUTA_EDITOR_STRING) { /* Iterate backwards till the begining of the line and disable * indenting if any non-white space char is encountered */ /* Begin by assuming it should be indented */ should_auto_indent = TRUE; while (ianjuta_iterable_previous (iter, NULL)) { ch = ianjuta_editor_cell_get_char (IANJUTA_EDITOR_CELL (iter), 0, NULL); //DEBUG_PRINT ("Looking at char '%c'", ch); /* Break on begining of line (== end of previous line) */ if (iter_is_newline (iter, ch)) { skip_iter_to_newline_head (iter, ch); break; } /* If a non-white space char is encountered, disabled indenting */ if (!isspace (ch)) { should_auto_indent = FALSE; break; } } } } if (should_auto_indent) { gint insert_line; gint line_indent; gint parenthesis_indentation; ianjuta_document_begin_undo_action (IANJUTA_DOCUMENT(editor), NULL); insert_line = ianjuta_editor_get_lineno (editor, NULL); line_indent = get_line_auto_indentation (plugin, editor, insert_line, &parenthesis_indentation); set_line_indentation (plugin, editor, insert_line, line_indent, parenthesis_indentation); ianjuta_document_end_undo_action (IANJUTA_DOCUMENT(editor), NULL); } } if (g_settings_get_boolean (plugin->settings, PREF_BRACE_AUTOCOMPLETION)) { if (ch == '[' || ch == '(') { gchar *prev_char, *next_char; IAnjutaIterable *previous, *next, *next_end; previous = ianjuta_iterable_clone (iter, NULL); ianjuta_iterable_previous (previous, NULL); prev_char = ianjuta_editor_get_text (editor, previous, iter, NULL); next = ianjuta_iterable_clone (iter, NULL); ianjuta_iterable_next (next, NULL); next_end = ianjuta_iterable_clone (next, NULL); ianjuta_iterable_next (next_end, NULL); next_char = ianjuta_editor_get_text (editor, next, next_end, NULL); /* If the previous char is a ' we don't have to autocomplete, also we only autocomplete if the next character is white-space a closing bracket, "," or ";" */ if (*prev_char != '\'' && (g_ascii_isspace(*next_char) || is_closing_bracket (*next_char) || *next_char == ',' || *next_char == ';'|| *next_char == '\0')) { ianjuta_document_begin_undo_action (IANJUTA_DOCUMENT (editor), NULL); ianjuta_iterable_next (iter, NULL); switch (ch) { case '[': insert_editor_blocked (editor, iter, "]", plugin); break; case '(': insert_editor_blocked (editor, iter, ")", plugin); break; default: break; } ianjuta_editor_goto_position (editor, iter, NULL); ianjuta_document_end_undo_action (IANJUTA_DOCUMENT (editor), NULL); } g_object_unref (previous); } else if (ch == '"' || ch == '\'') { gchar *prev_char; IAnjutaIterable *previous; previous = ianjuta_iterable_clone (iter, NULL); ianjuta_iterable_previous (previous, NULL); prev_char = ianjuta_editor_get_text (editor, previous, iter, NULL); /* First iter*/ ianjuta_iterable_next (iter, NULL); /* * If the character is " we have to decide if we need insert * another " or we have to skip the character */ if (ch == '"' || ch == '\'') { /* * Now we have to detect if we want to manage " as a char */ if (*prev_char != '\'' && *prev_char != '\\') { gchar *c; if (ch == '"') c = g_strdup ("\""); else c = g_strdup ("'"); ianjuta_document_begin_undo_action (IANJUTA_DOCUMENT (editor), NULL); insert_editor_blocked (editor, iter, c, plugin); ianjuta_editor_goto_position (editor, iter, NULL); ianjuta_document_end_undo_action (IANJUTA_DOCUMENT (editor), NULL); g_free (c); } g_object_unref (previous); g_object_unref (iter); return; } g_object_unref (previous); } } g_object_unref (iter); }
static void on_glade_drop (IAnjutaEditor* editor, IAnjutaIterable* iterator, const gchar* signal_data, PythonPlugin* lang_plugin) { GSignalQuery query; GType type; guint id; const gchar* widget; const gchar* signal; const gchar* handler; const gchar* user_data; gboolean swapped; GList* names = NULL; GString* str = g_string_new (NULL); int i; IAnjutaIterable* start, * end; GStrv data = g_strsplit(signal_data, ":", 5); widget = data[0]; signal = data[1]; handler = data[2]; user_data = data[3]; swapped = g_str_equal (data[4], "1"); type = g_type_from_name (widget); id = g_signal_lookup (signal, type); g_signal_query (id, &query); g_string_append_printf (str, "\ndef %s (self", handler); for (i = 0; i < query.n_params; i++) { const gchar* type_name = g_type_name (query.param_types[i]); const gchar* param_name = language_support_get_signal_parameter (type_name, &names); g_string_append_printf (str, ", %s", param_name); } g_string_append (str, "):\n"); ianjuta_editor_insert (editor, iterator, str->str, -1, NULL); /* Indent code correctly */ start = iterator; end = ianjuta_iterable_clone (iterator, NULL); ianjuta_iterable_set_position (end, ianjuta_iterable_get_position (iterator, NULL) + g_utf8_strlen (str->str, -1), NULL); ianjuta_indenter_indent (IANJUTA_INDENTER (lang_plugin), start, end, NULL); g_object_unref (end); g_string_free (str, TRUE); anjuta_util_glist_strings_free (names); g_strfreev (data); }
static void iprovider_populate (IAnjutaProvider *obj, IAnjutaIterable* iter, GError **err) { static GList *trash = NULL; JSLang *plugin = (JSLang*)obj; if (plugin->last) { g_object_unref (plugin->last); } plugin->last = ianjuta_iterable_clone(iter, NULL); if (!plugin->current_editor) return; gint depth; GList *suggestions = NULL; gchar *str = code_completion_get_str (IANJUTA_EDITOR (plugin->current_editor), FALSE); if (trash) { g_list_foreach (trash, (GFunc)g_free, NULL); g_list_free (trash); trash = NULL; } if (!str) return; g_assert (plugin->prefs); if (strlen (str) < g_settings_get_int (plugin->prefs, MIN_CODECOMPLETE)) { ianjuta_editor_assist_proposals ( IANJUTA_EDITOR_ASSIST (plugin->current_editor), obj, NULL, TRUE, NULL); return; } gchar *file = file_completion (IANJUTA_EDITOR (plugin->current_editor), &depth); gint i; DEBUG_PRINT ("JSLang: Auto complete for %s (TMFILE=%s)", str, file); for (i = strlen (str) - 1; i; i--) { if (str[i] == '.') break; } if (i > 0) { suggestions = code_completion_get_list (plugin, file, g_strndup (str, i), depth); } else suggestions = code_completion_get_list (plugin, file, NULL, depth); if (suggestions) { GList *nsuggest = NULL; gint k; if (i > 0) { suggestions = filter_list (suggestions, str + i + 1); k = strlen (str + i + 1); } else { suggestions = filter_list (suggestions, str); k = strlen (str); } GList *i; for (; k > 0; k--) ianjuta_iterable_previous (plugin->last, NULL); for (i = suggestions; i; i = g_list_next(i)) { IAnjutaEditorAssistProposal* proposal = g_new0(IAnjutaEditorAssistProposal, 1); if (!i->data) continue; proposal->label = i->data; proposal->data = i->data; nsuggest = g_list_prepend (nsuggest, proposal); } ianjuta_editor_assist_proposals ( IANJUTA_EDITOR_ASSIST (plugin->current_editor), obj, nsuggest, TRUE, NULL); g_list_free (nsuggest); trash = suggestions; return; } ianjuta_editor_assist_proposals ( IANJUTA_EDITOR_ASSIST (plugin->current_editor), obj, NULL, TRUE, NULL); }