void
gb_beautifier_process_launch_async (GbBeautifierWorkbenchAddin *self,
IdeSourceView *source_view,
GtkTextIter *begin,
GtkTextIter *end,
GbBeautifierConfigEntry *entry,
GAsyncReadyCallback callback,
GCancellable *cancellable,
gpointer user_data)
{
GtkTextBuffer *buffer;
ProcessState *state;
g_autoptr(GTask) task = NULL;
const gchar *lang_id;
g_assert (GB_IS_BEAUTIFIER_WORKBENCH_ADDIN (self));
g_assert (IDE_IS_SOURCE_VIEW (source_view));
g_assert (!cancellable || G_IS_CANCELLABLE (cancellable));
g_assert (entry != NULL);
g_assert (callback != NULL);
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (source_view));
lang_id = gb_beautifier_helper_get_lang_id (self, source_view);
if (begin == NULL)
gtk_text_buffer_get_start_iter (buffer, begin);
if (end == NULL)
gtk_text_buffer_get_end_iter (buffer, begin);
g_assert (gtk_text_iter_get_buffer (begin) == buffer);
g_assert (gtk_text_iter_get_buffer (end) == buffer);
state = g_slice_new0 (ProcessState);
state->self = self;
state->source_view = source_view;
gtk_text_iter_order (begin, end);
state->text = gtk_text_buffer_get_text (buffer, begin, end, FALSE);
state->begin_mark = gtk_text_buffer_create_mark (buffer, NULL, begin, TRUE);
state->end_mark = gtk_text_buffer_create_mark (buffer, NULL, end, FALSE);
state->command = entry->command;
state->lang_id = g_strdup (lang_id);
if (G_IS_FILE (entry->config_file))
state->config_file = g_file_dup (entry->config_file);
if (entry->command_args != NULL)
state->command_args = command_args_copy (entry->command_args);
task = g_task_new (self, cancellable, callback, user_data);
g_task_set_source_tag (task, gb_beautifier_process_launch_async);
g_task_set_task_data (task, state, process_state_free);
gb_beautifier_helper_create_tmp_file_async (self,
state->text,
create_tmp_file_cb,
cancellable,
g_steal_pointer (&task));
}
/**
* gstyle_palette_new_from_buffer:
* @buffer: a #GtkTextBUffer
* @begin: (nullable): a begin #GtkTextIter
* @end: (nullable): a end #GtkTextIter
* @cancellable: A #GCancellable
* @error: (nullable): a #GError location or %NULL
*
* Create a new #GstylePalette from a text buffer.
* if @begin is %NULL, the buffer start iter is used.
* if @end is %NULL, the buffer end is used.
*
* Returns: A #GstylePalette or %NULL if an error occur.
*/
GstylePalette *
gstyle_palette_new_from_buffer (GtkTextBuffer *buffer,
GtkTextIter *begin,
GtkTextIter *end,
GCancellable *cancellable,
GError **error)
{
g_autofree gchar *text = NULL;
GstylePalette *palette = NULL;
g_autofree gchar *name = NULL;
GtkTextIter real_begin, real_end;
GtkTextIter buffer_begin, buffer_end;
GstyleColorItem *item;
GstyleColor *color;
GPtrArray *items;
GError *tmp_error = NULL;
g_return_val_if_fail (GTK_IS_TEXT_BUFFER (buffer), NULL);
g_return_val_if_fail (begin == NULL || gtk_text_iter_get_buffer (begin) == buffer, NULL);
g_return_val_if_fail (end == NULL || gtk_text_iter_get_buffer (end) == buffer, NULL);
gtk_text_buffer_get_bounds (buffer, &buffer_begin, &buffer_end);
real_begin = (begin == NULL) ? buffer_begin : *begin;
real_end = (end == NULL) ? buffer_end : *end;
text = gtk_text_buffer_get_slice (buffer, &real_begin, &real_end, FALSE);
items = gstyle_color_parse (text);
if (items == NULL)
{
g_set_error (error, GSTYLE_PALETTE_ERROR, GSTYLE_PALETTE_ERROR_PARSE,
_("failed to parse\n"));
return NULL;
}
if (items->len > 0)
{
/* To translators: always in singular form like in: generated palette number <generated_count> */
name = g_strdup_printf ("%s %i", _("Generated"), ++generated_count);
palette = g_object_new (GSTYLE_TYPE_PALETTE,
"id", NULL,
"name", name,
"file", NULL,
NULL);
for (gint i = 0; i < items->len; ++i)
{
item = g_ptr_array_index (items, i);
color = (GstyleColor *)gstyle_color_item_get_color (item);
gstyle_palette_add (palette, color, &tmp_error);
}
}
g_ptr_array_free (items, TRUE);
return palette;
}
static gchar *
get_word_at_iter (GscProviderDevhelp *devhelp,
GtkTextIter *iter)
{
GtkTextIter start = *iter;
gint line = gtk_text_iter_get_line (iter);
gboolean went_back = TRUE;
GtkTextMark *mark;
if (!gtk_text_iter_backward_char (&start))
{
return NULL;
}
while (went_back &&
line == gtk_text_iter_get_line (&start) &&
is_word_char (gtk_text_iter_get_char (&start)))
{
went_back = gtk_text_iter_backward_char (&start);
}
if (went_back)
{
gtk_text_iter_forward_char (&start);
}
if (gtk_text_iter_equal (iter, &start))
{
return NULL;
}
mark = gtk_text_buffer_get_mark (gtk_text_iter_get_buffer (iter),
MARK_NAME);
if (mark)
{
gtk_text_buffer_move_mark (gtk_text_iter_get_buffer (iter),
mark,
&start);
}
else
{
mark = gtk_text_buffer_create_mark (gtk_text_iter_get_buffer (iter),
MARK_NAME,
&start,
TRUE);
}
return gtk_text_iter_get_text (&start, iter);
}
void
dma_sparse_iter_insert_lines (DmaSparseIter *src, GtkTextIter *dst, guint count)
{
DmaSparseIter iter;
guint line = 0;
GtkTextBuffer *buffer;
buffer = gtk_text_iter_get_buffer (dst);
/* It is possible to get an iterator that doesn't point to any node
* if it has been move to a fixed address without rounding it to
* the nearest line */
dma_sparse_iter_copy (&iter, src);
dma_sparse_iter_refresh (&iter);
/* Fill with data */
for (; line < count; line++)
{
dma_sparse_iter_insert_line (&iter, dst);
if (!dma_sparse_iter_forward_line (&iter))
{
/* no more data */
break;
}
if (line != count - 1) gtk_text_buffer_insert (buffer, dst, "\n", 1);
}
}
/**
* ide_highlight_engine_invalidate:
* @self: An #IdeHighlightEngine.
* @begin: the beginning of the range to invalidate
* @end: the end of the range to invalidate
*
* This function will extend the invalidated range of the buffer to include
* the range of @begin to @end.
*
* The highlighter will be queued to interactively update the invalidated
* region.
*
* Updating the invalidated region of the buffer may take some time, as it is
* important that the highlighter does not block for more than 1-2 milliseconds
* to avoid dropping frames.
*/
void
ide_highlight_engine_invalidate (IdeHighlightEngine *self,
const GtkTextIter *begin,
const GtkTextIter *end)
{
GtkTextBuffer *buffer;
GtkTextIter mark_begin;
GtkTextIter mark_end;
IDE_ENTRY;
g_return_if_fail (IDE_IS_HIGHLIGHT_ENGINE (self));
g_return_if_fail (begin != NULL);
g_return_if_fail (end != NULL);
g_return_if_fail (gtk_text_iter_get_buffer (begin) == GTK_TEXT_BUFFER (self->buffer));
g_return_if_fail (gtk_text_iter_get_buffer (end) == GTK_TEXT_BUFFER (self->buffer));
buffer = GTK_TEXT_BUFFER (self->buffer);
gtk_text_buffer_get_iter_at_mark (buffer, &mark_begin, self->invalid_begin);
gtk_text_buffer_get_iter_at_mark (buffer, &mark_end, self->invalid_end);
if (gtk_text_iter_equal (&mark_begin, &mark_end))
{
gtk_text_buffer_move_mark (buffer, self->invalid_begin, begin);
gtk_text_buffer_move_mark (buffer, self->invalid_end, end);
}
else
{
if (gtk_text_iter_compare (begin, &mark_begin) < 0)
gtk_text_buffer_move_mark (buffer, self->invalid_begin, begin);
if (gtk_text_iter_compare (end, &mark_end) > 0)
gtk_text_buffer_move_mark (buffer, self->invalid_end, end);
}
ide_highlight_engine_queue_work (self);
IDE_EXIT;
}
/**
* gb_color_picker_document_monitor_queue_colorize:
* @self: a #GbColorPickerDocumentMonitor
*
* This queues a region to be recolorized but does so after returning
* to the main loop. This can be useful for situations where you do not
* know if you are in a path that must retain a valid GtkTextIter.
*
* Since: 3.26
*/
static void
gb_color_picker_document_monitor_queue_oper (GbColorPickerDocumentMonitor *self,
const GtkTextIter *begin,
const GtkTextIter *end,
gboolean uncolorize)
{
QueuedColorize queued = { 0 };
GtkTextBuffer *buffer;
GtkTextIter real_begin;
GtkTextIter real_end;
g_return_if_fail (GB_IS_COLOR_PICKER_DOCUMENT_MONITOR (self));
g_return_if_fail (self->buffer != NULL);
g_return_if_fail (begin == NULL || GTK_TEXT_BUFFER (self->buffer) == gtk_text_iter_get_buffer (begin));
g_return_if_fail (end == NULL || GTK_TEXT_BUFFER (self->buffer) == gtk_text_iter_get_buffer (end));
buffer = GTK_TEXT_BUFFER (self->buffer);
gtk_text_buffer_get_bounds (buffer, &real_begin, &real_end);
if (begin)
real_begin = *begin;
if (end)
real_end = *end;
queued.self = g_object_ref (self);
queued.buffer = g_object_ref (buffer);
queued.begin = g_object_ref (gtk_text_buffer_create_mark (buffer, NULL, &real_begin, TRUE));
queued.end = g_object_ref (gtk_text_buffer_create_mark (buffer, NULL, &real_end, FALSE));
queued.uncolorize = !!uncolorize;
gdk_threads_add_idle_full (G_PRIORITY_LOW,
gb_color_picker_document_monitor_queue_oper_cb,
g_slice_dup (QueuedColorize, &queued),
queued_colorize_free);
}
static IdeHighlightResult
ide_highlight_engine_apply_style (const GtkTextIter *begin,
const GtkTextIter *end,
const gchar *style_name)
{
IdeHighlightEngine *self;
GtkTextBuffer *buffer;
GtkTextTag *tag;
buffer = gtk_text_iter_get_buffer (begin);
self = g_object_get_qdata (G_OBJECT (buffer), gEngineQuark);
tag = get_tag_from_style (self, style_name, TRUE);
gtk_text_buffer_apply_tag (buffer, tag, begin, end);
if (g_get_monotonic_time () >= self->quanta_expiration)
return IDE_HIGHLIGHT_STOP;
return IDE_HIGHLIGHT_CONTINUE;
}
gboolean
xed_spell_utils_skip_no_spell_check (GtkTextIter *start,
GtkTextIter *end)
{
GtkSourceBuffer *buffer = GTK_SOURCE_BUFFER (gtk_text_iter_get_buffer (start));
while (gtk_source_buffer_iter_has_context_class (buffer, start, "no-spell-check"))
{
GtkTextIter last = *start;
if (!gtk_source_buffer_iter_forward_to_context_class_toggle (buffer, start, "no-spell-check"))
{
return FALSE;
}
if (gtk_text_iter_compare (start, &last) <= 0)
{
return FALSE;
}
gtk_text_iter_forward_word_end (start);
gtk_text_iter_backward_word_start (start);
if (gtk_text_iter_compare (start, &last) <= 0)
{
return FALSE;
}
if (gtk_text_iter_compare (start, end) >= 0)
{
return FALSE;
}
}
return TRUE;
}
static gboolean
gsc_provider_devhelp_get_start_iter (GtkSourceCompletionProvider *provider,
GtkSourceCompletionContext *context,
GtkSourceCompletionProposal *proposal,
GtkTextIter *iter)
{
GscProviderDevhelp *devhelp = GSC_PROVIDER_DEVHELP (provider);
GtkTextBuffer *buf;
GtkTextMark *mark;
GtkTextIter context_iter;
gtk_source_completion_context_get_iter (context, &context_iter);
buf = gtk_text_iter_get_buffer (&context_iter);
mark = gtk_text_buffer_get_mark (buf, MARK_NAME);
if (!mark)
{
return FALSE;
}
gtk_text_buffer_get_iter_at_mark (buf, iter, mark);
return TRUE;
}
static void
build_indent (IdeXmlIndenter *xml,
guint line_offset,
GtkTextIter *matching_line,
GString *str)
{
GtkTextIter iter;
gunichar ch;
if (!line_offset)
return;
gtk_text_buffer_get_iter_at_line (gtk_text_iter_get_buffer (matching_line),
&iter,
gtk_text_iter_get_line (matching_line));
do {
ch = gtk_text_iter_get_char (&iter);
switch (ch)
{
case '\t':
case ' ':
g_string_append_unichar (str, ch);
break;
default:
g_string_append_c (str, ' ');
break;
}
} while (gtk_text_iter_forward_char (&iter) &&
(gtk_text_iter_compare (&iter, matching_line) <= 0) &&
(str->len < line_offset));
while (str->len < line_offset)
g_string_append_c (str, ' ');
if (xml->use_tabs)
{
GString *translated = g_string_new (NULL);
const gchar *pos = str->str;
const gchar *tab;
gchar *needle;
needle = g_malloc (xml->tab_width + 1);
memset (needle, ' ', xml->tab_width);
needle [xml->tab_width] = '\0';
while (NULL != (tab = strstr (pos, needle)))
{
g_string_append_len (translated, pos, tab - pos);
g_string_append_c (translated, '\t');
pos = tab + xml->tab_width;
}
if (*pos)
g_string_append (translated, pos);
g_string_truncate (str, 0);
g_string_append_len (str, translated->str, translated->len);
g_string_free (translated, TRUE);
g_free (needle);
}
}
static void
ide_langserv_completion_provider_populate (GtkSourceCompletionProvider *provider,
GtkSourceCompletionContext *context)
{
IdeLangservCompletionProvider *self = (IdeLangservCompletionProvider *)provider;
IdeLangservCompletionProviderPrivate *priv = ide_langserv_completion_provider_get_instance_private (self);
g_autoptr(GVariant) params = NULL;
g_autoptr(GCancellable) cancellable = NULL;
g_autoptr(CompletionState) state = NULL;
g_autofree gchar *uri = NULL;
GtkTextIter iter;
IdeBuffer *buffer;
gint line;
gint column;
IDE_ENTRY;
g_assert (IDE_IS_LANGSERV_COMPLETION_PROVIDER (self));
g_assert (GTK_SOURCE_IS_COMPLETION_CONTEXT (context));
if (priv->client == NULL)
{
IDE_TRACE_MSG ("No client set, cannot provide proposals");
gtk_source_completion_context_add_proposals (context, provider, NULL, TRUE);
IDE_EXIT;
}
gtk_source_completion_context_get_iter (context, &iter);
buffer = IDE_BUFFER (gtk_text_iter_get_buffer (&iter));
uri = ide_buffer_get_uri (buffer);
line = gtk_text_iter_get_line (&iter);
column = gtk_text_iter_get_line_offset (&iter);
params = JSONRPC_MESSAGE_NEW (
"textDocument", "{",
"uri", JSONRPC_MESSAGE_PUT_STRING (uri),
"}",
"position", "{",
"line", JSONRPC_MESSAGE_PUT_INT32 (line),
"character", JSONRPC_MESSAGE_PUT_INT32 (column),
"}"
);
cancellable = g_cancellable_new ();
g_signal_connect_data (context,
"cancelled",
G_CALLBACK (g_cancellable_cancel),
g_object_ref (cancellable),
(GClosureNotify)g_object_unref,
G_CONNECT_SWAPPED);
state = completion_state_new (self, context);
ide_langserv_client_call_async (priv->client,
"textDocument/completion",
g_steal_pointer (¶ms),
g_steal_pointer (&cancellable),
ide_langserv_completion_provider_complete_cb,
g_steal_pointer (&state));
IDE_EXIT;
}
static VALUE
rg_buffer(VALUE self)
{
return GOBJ2RVAL(gtk_text_iter_get_buffer(_SELF(self)));
}
/*
* This bad boy was taken from https://bugzilla.gnome.org/show_bug.cgi?id=59390
*/
static void
gtk_text_buffer_real_insert_markup (GtkTextBuffer *buffer,
GtkTextIter *textiter,
const gchar *markup,
GtkTextTag *extratag)
{
PangoAttrIterator *paiter;
PangoAttrList *attrlist;
GtkTextMark *mark;
GError *error = NULL;
gchar *text;
g_return_if_fail (GTK_IS_TEXT_BUFFER (buffer));
g_return_if_fail (textiter != NULL);
g_return_if_fail (markup != NULL);
g_return_if_fail (gtk_text_iter_get_buffer (textiter) == buffer);
if (*markup == '\000')
return;
if (!pango_parse_markup(markup, -1, 0, &attrlist, &text, NULL, &error))
{
g_warning("Invalid markup string: %s", error->message);
g_error_free(error);
return;
}
if (attrlist == NULL)
{
gtk_text_buffer_insert(buffer, textiter, text, -1);
g_free(text);
return;
}
/* create mark with right gravity */
mark = gtk_text_buffer_create_mark(buffer, NULL, textiter, FALSE);
paiter = pango_attr_list_get_iterator(attrlist);
do
{
PangoAttribute *attr;
GtkTextTag *tag;
gint start, end;
pango_attr_iterator_range(paiter, &start, &end);
if (end == G_MAXINT) /* last chunk */
end = start-1; /* resulting in -1 to be passed to _insert */
tag = gtk_text_tag_new(NULL);
if ((attr = pango_attr_iterator_get(paiter, PANGO_ATTR_LANGUAGE)))
g_object_set(tag, "language", pango_language_to_string(((PangoAttrLanguage*)attr)->value), NULL);
if ((attr = pango_attr_iterator_get(paiter, PANGO_ATTR_FAMILY)))
g_object_set(tag, "family", ((PangoAttrString*)attr)->value, NULL);
if ((attr = pango_attr_iterator_get(paiter, PANGO_ATTR_STYLE)))
g_object_set(tag, "style", ((PangoAttrInt*)attr)->value, NULL);
if ((attr = pango_attr_iterator_get(paiter, PANGO_ATTR_WEIGHT)))
g_object_set(tag, "weight", ((PangoAttrInt*)attr)->value, NULL);
if ((attr = pango_attr_iterator_get(paiter, PANGO_ATTR_VARIANT)))
g_object_set(tag, "variant", ((PangoAttrInt*)attr)->value, NULL);
if ((attr = pango_attr_iterator_get(paiter, PANGO_ATTR_STRETCH)))
g_object_set(tag, "stretch", ((PangoAttrInt*)attr)->value, NULL);
if ((attr = pango_attr_iterator_get(paiter, PANGO_ATTR_SIZE)))
g_object_set(tag, "size", ((PangoAttrInt*)attr)->value, NULL);
if ((attr = pango_attr_iterator_get(paiter, PANGO_ATTR_FONT_DESC)))
g_object_set(tag, "font-desc", ((PangoAttrFontDesc*)attr)->desc, NULL);
if ((attr = pango_attr_iterator_get(paiter, PANGO_ATTR_FOREGROUND)))
{
GdkColor col = { 0,
((PangoAttrColor*)attr)->color.red,
((PangoAttrColor*)attr)->color.green,
((PangoAttrColor*)attr)->color.blue
};
g_object_set(tag, "foreground-gdk", &col, NULL);
}
if ((attr = pango_attr_iterator_get(paiter, PANGO_ATTR_BACKGROUND)))
{
GdkColor col = { 0,
((PangoAttrColor*)attr)->color.red,
((PangoAttrColor*)attr)->color.green,
((PangoAttrColor*)attr)->color.blue
};
g_object_set(tag, "background-gdk", &col, NULL);
}
if ((attr = pango_attr_iterator_get(paiter, PANGO_ATTR_UNDERLINE)))
g_object_set(tag, "underline", ((PangoAttrInt*)attr)->value, NULL);
if ((attr = pango_attr_iterator_get(paiter, PANGO_ATTR_STRIKETHROUGH)))
g_object_set(tag, "strikethrough", (gboolean)(((PangoAttrInt*)attr)->value != 0), NULL);
if ((attr = pango_attr_iterator_get(paiter, PANGO_ATTR_RISE)))
g_object_set(tag, "rise", ((PangoAttrInt*)attr)->value, NULL);
/* PANGO_ATTR_SHAPE cannot be defined via markup text */
if ((attr = pango_attr_iterator_get(paiter, PANGO_ATTR_SCALE)))
g_object_set(tag, "scale", ((PangoAttrFloat*)attr)->value, NULL);
gtk_text_tag_table_add(gtk_text_buffer_get_tag_table(buffer), tag);
if (extratag)
{
gtk_text_buffer_insert_with_tags(buffer, textiter, text+start, end - start, tag, extratag, NULL);
}
else
{
gtk_text_buffer_insert_with_tags(buffer, textiter, text+start, end - start, tag, NULL);
}
/* mark had right gravity, so it should be
* at the end of the inserted text now */
gtk_text_buffer_get_iter_at_mark(buffer, textiter, mark);
}
while (pango_attr_iterator_next(paiter));
gtk_text_buffer_delete_mark(buffer, mark);
pango_attr_iterator_destroy(paiter);
pango_attr_list_unref(attrlist);
g_free(text);
}
static void
ide_ctags_completion_provider_populate (GtkSourceCompletionProvider *provider,
GtkSourceCompletionContext *context)
{
IdeCtagsCompletionProvider *self = (IdeCtagsCompletionProvider *)provider;
g_autofree gchar *word = NULL;
const IdeCtagsIndexEntry *entries;
const gchar * const *allowed;
g_autoptr(GPtrArray) ar = NULL;
IdeCtagsIndexEntry *last = NULL;
GtkSourceBuffer *buffer;
gsize n_entries;
GtkTextIter iter;
GList *list = NULL;
gsize i;
gsize j;
IDE_ENTRY;
g_assert (IDE_IS_CTAGS_COMPLETION_PROVIDER (self));
g_assert (GTK_SOURCE_IS_COMPLETION_CONTEXT (context));
if (self->indexes->len == 0)
IDE_GOTO (failure);
if (!g_settings_get_boolean (self->settings, "ctags-autocompletion"))
IDE_GOTO (failure);
if (!gtk_source_completion_context_get_iter (context, &iter))
IDE_GOTO (failure);
buffer = GTK_SOURCE_BUFFER (gtk_text_iter_get_buffer (&iter));
allowed = get_allowed_suffixes (buffer);
word = get_word_to_cursor (&iter);
if (ide_str_empty0 (word) || strlen (word) < self->minimum_word_size)
IDE_GOTO (failure);
if (strlen (word) < 3)
IDE_GOTO (failure);
ar = g_ptr_array_new ();
IDE_TRACE_MSG ("Searching for %s", word);
for (j = 0; j < self->indexes->len; j++)
{
IdeCtagsIndex *index = g_ptr_array_index (self->indexes, j);
entries = ide_ctags_index_lookup_prefix (index, word, &n_entries);
if ((entries == NULL) || (n_entries == 0))
continue;
for (i = 0; i < n_entries; i++)
{
const IdeCtagsIndexEntry *entry = &entries [i];
if (is_allowed (entry, allowed))
g_ptr_array_add (ar, (gpointer)entry);
}
}
g_ptr_array_sort (ar, sort_wrapper);
for (i = ar->len; i > 0; i--)
{
GtkSourceCompletionProposal *item;
IdeCtagsIndexEntry *entry = g_ptr_array_index (ar, i - 1);
/*
* NOTE:
*
* We walk backwards in this ptrarray so that we can use g_list_prepend() for O(1) access.
* I think everyone agrees that using GList for passing completion data around was not
* a great choice, but it is what we have to work with.
*/
/*
* Ignore this item if the previous one looks really similar.
* We take the first item instead of the last since the first item (when walking backwards)
* tends to be more likely to be the one we care about (based on lexicographical
* ordering. For example, something in "gtk-2.0" is less useful than "gtk-3.0".
*
* This is done here instead of during our initial object creation so that
* we can merge items between different indexes. It often happens that the
* same headers are included in multiple tags files.
*/
if ((last != NULL) && too_similar (entry, last))
continue;
/*
* NOTE:
*
* Autocompletion is very performance sensitive code. The smallest amount of
* extra work has a very negative impact on interactivity. We are trying to
* avoid a couple things here based on how completion works.
*
* 1) Avoiding referencing or copying things.
* Since the provider will always outlive the completion item, we use
* borrowed references for as much as we can.
* 2) We delay the work of looking up icons until they are requested.
* No sense in doing that work before hand.
*/
item = ide_ctags_completion_item_new (entry, self, context);
list = g_list_prepend (list, item);
last = entry;
}
failure:
gtk_source_completion_context_add_proposals (context, provider, list, TRUE);
g_list_free_full (list, g_object_unref);
IDE_EXIT;
}
static void
dma_disassembly_buffer_insert_line (DmaSparseIter *iter, GtkTextIter *dst)
{
DmaDisassemblyBuffer * dis = (DmaDisassemblyBuffer *)iter->buffer;
GtkTextBuffer *buffer = gtk_text_iter_get_buffer (dst);
if (dis->debugger != NULL)
{
dma_sparse_iter_refresh (iter);
if (iter->line < DMA_DISASSEMBLY_VALID_ADDRESS)
{
if (iter->buffer->pending == NULL)
{
DmaSparseIter end;
DmaSparseBufferTransport *trans;
gint i, j;
gulong start_adr;
gulong end_adr;
gint margin;
/* If following line is define, get a block stopping here */
dma_sparse_iter_copy (&end, iter);
margin = 0;
for (j = 0; j < DMA_DISASSEMBLY_BUFFER_BLOCK_SIZE / DMA_DISASSEMBLY_DEFAULT_LINE_LENGTH; j++)
{
if (!dma_disassembly_iter_forward_line (&end))
{
end.offset = 0;
end.base = dma_sparse_buffer_get_upper (end.buffer);
break;
}
if (margin > DMA_DISASSEMBLY_SKIP_BEGINNING_LINE) break;
if ((margin != 0) || (end.line >= DMA_DISASSEMBLY_VALID_ADDRESS)) margin++;
}
i = j;
if (iter->line == DMA_DISASSEMBLY_UNKNOWN_ADDRESS)
{
for (i = j; i < DMA_DISASSEMBLY_BUFFER_BLOCK_SIZE / DMA_DISASSEMBLY_DEFAULT_LINE_LENGTH; i++)
{
if (!dma_disassembly_iter_backward_line (iter)) break;
if (iter->line >= DMA_DISASSEMBLY_VALID_ADDRESS) break;
}
}
start_adr = dma_sparse_iter_get_address (iter);
end_adr = dma_sparse_iter_get_address (&end);
trans = dma_sparse_buffer_alloc_transport (DMA_SPARSE_BUFFER (dis), i, 0);
trans->tag = i != j ? DMA_DISASSEMBLY_SKIP_BEGINNING : DMA_DISASSEMBLY_KEEP_ALL;
trans->start = start_adr;
trans->length = end_adr - start_adr;
if (end_adr == dma_sparse_buffer_get_upper (DMA_SPARSE_BUFFER (dis)))
{
trans->length++;
}
DEBUG_PRINT("get disassemble %lx %lx %ld trans %p buffer %p", start_adr, end_adr, trans->length, trans, trans->buffer);
dma_queue_disassemble (dis->debugger, start_adr, end_adr + 1 - start_adr, (IAnjutaDebuggerCallback)on_disassemble, trans);
}
}
else
{
/* Fill with known data */
gtk_text_buffer_insert (buffer, dst, ((DmaDisassemblyBufferNode *)(iter->node))->data[iter->line].text, -1);
return;
}
}
/* Fill with unknow data */
gtk_text_buffer_insert (buffer, dst, "??", 2);
}
