void
dma_sparse_view_refresh (DmaSparseView *view)
{
gint offset;
GtkTextIter cur;
GtkTextMark *mark;
GtkTextIter start, end;
GtkTextBuffer *buffer;
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (view));
/* Save all cursor offset */
mark = gtk_text_buffer_get_insert (buffer);
gtk_text_buffer_get_iter_at_mark (buffer, &cur, mark);
offset = gtk_text_iter_get_offset (&cur);
/* Remove old data */
view->priv->stamp++;
gtk_text_buffer_get_bounds (buffer, &start, &end);
gtk_text_buffer_delete (buffer, &start, &end);
gtk_text_buffer_get_iter_at_offset (buffer, &end, 0);
/* Get data */
dma_sparse_iter_insert_lines (&view->priv->start, &end, view->priv->line_by_page);
/* Restore cursor */
mark = gtk_text_buffer_get_insert (buffer);
gtk_text_buffer_get_iter_at_mark(buffer, &cur, mark);
gtk_text_iter_set_offset (&cur, offset);
gtk_text_buffer_move_mark_by_name (buffer, "insert", &cur);
gtk_text_buffer_move_mark_by_name (buffer, "selection_bound", &cur);
}
void indent_multi_line_indent(GtkTextBuffer *buffer)
{
GtkTextIter start_iter, end_iter, iter;
gint start_line, end_line, i;
gboolean pos;
gtk_text_buffer_get_selection_bounds(buffer, &start_iter, &end_iter);
start_line = gtk_text_iter_get_line(&start_iter);
end_line = gtk_text_iter_get_line(&end_iter);
gtk_text_buffer_get_iter_at_mark(buffer, &iter, gtk_text_buffer_get_insert(buffer));
pos = gtk_text_iter_equal(&iter, &start_iter);
for (i = start_line; i < end_line; i++) {
gtk_text_buffer_get_iter_at_line(buffer, &iter, i);
gtk_text_buffer_place_cursor(buffer, &iter);
g_signal_emit_by_name(G_OBJECT(buffer), "begin-user-action");
gtk_text_buffer_insert(buffer, &iter, "\t", 1);
g_signal_emit_by_name(G_OBJECT(buffer), "end-user-action");
undo_set_sequency(TRUE);
}
undo_set_sequency(FALSE);
gtk_text_buffer_get_iter_at_line(buffer, &start_iter, start_line);
gtk_text_buffer_get_iter_at_line(buffer, &end_iter, end_line);
if (pos) {
gtk_text_buffer_place_cursor(buffer, &end_iter);
gtk_text_buffer_move_mark_by_name(buffer, "insert", &start_iter);
} else {
gtk_text_buffer_place_cursor(buffer, &start_iter);
gtk_text_buffer_move_mark_by_name(buffer, "insert", &end_iter);
}
}
static void
lsv_select_activated(GSimpleAction * action,
GVariant * parameter,
gpointer user_data)
{
LibBalsaSourceViewerInfo *lsvi =
g_object_get_data(G_OBJECT(user_data), "lsvi");
GtkTextView *text = GTK_TEXT_VIEW(lsvi->text);
GtkTextBuffer *buffer = gtk_text_view_get_buffer(text);
GtkTextIter start, end;
gtk_text_buffer_get_bounds(buffer, &start, &end);
gtk_text_buffer_move_mark_by_name(buffer, "insert", &start);
gtk_text_buffer_move_mark_by_name(buffer, "selection_bound", &end);
}
void moveBMsForPage(pageStruct *page,unsigned dowhat)
{
unsigned thisid;
unsigned len;
bookMarksNew *bookmarkdata;
GtkTextIter newiter;
if(page!=NULL)
{
thisid=page->pageID;
if(newBookMarksList!=NULL)
{
len=g_list_length(newBookMarksList);
for(unsigned j=0;j<len;j++)
{
bookmarkdata=(bookMarksNew*)g_list_nth_data (newBookMarksList,j);
if(bookmarkdata->pageID==thisid)
{
switch(dowhat)
{
case 0:
gtk_text_buffer_get_iter_at_line_offset((GtkTextBuffer*)page->buffer,&newiter,bookmarkdata->line,0);
gtk_text_buffer_move_mark_by_name((GtkTextBuffer*)page->buffer,bookmarkdata->markName,&newiter);
break;
case 1:
gtk_text_buffer_get_iter_at_mark((GtkTextBuffer*)page->buffer,&newiter,(GtkTextMark*)bookmarkdata->mark);
bookmarkdata->line=gtk_text_iter_get_line(&newiter);
break;
}
}
}
}
}
}
static void
gimp_text_tool_select_all (GimpTextTool *text_tool,
gboolean select)
{
GtkTextBuffer *buffer = GTK_TEXT_BUFFER (text_tool->buffer);
gimp_draw_tool_pause (GIMP_DRAW_TOOL (text_tool));
if (select)
{
GtkTextIter start, end;
gtk_text_buffer_get_bounds (buffer, &start, &end);
gtk_text_buffer_select_range (buffer, &start, &end);
}
else
{
GtkTextIter cursor;
gtk_text_buffer_get_iter_at_mark (buffer, &cursor,
gtk_text_buffer_get_insert (buffer));
gtk_text_buffer_move_mark_by_name (buffer, "selection_bound", &cursor);
}
gimp_draw_tool_resume (GIMP_DRAW_TOOL (text_tool));
}
JNIEXPORT void JNICALL
Java_gnu_java_awt_peer_gtk_GtkTextAreaPeer_select
(JNIEnv *env, jobject obj, jint start, jint end)
{
void *ptr;
GtkWidget *text = NULL;
GtkTextBuffer *buf;
GtkTextIter iter;
gdk_threads_enter ();
ptr = NSA_GET_PTR (env, obj);
text = gtk_bin_get_child (GTK_BIN (ptr));
buf = gtk_text_view_get_buffer (GTK_TEXT_VIEW (text));
gtk_text_buffer_get_iter_at_offset (buf, &iter, start);
/* quickly move both 'insert' and 'selection_bound' to the
same position */
gtk_text_buffer_place_cursor (buf, &iter);
gtk_text_buffer_get_iter_at_offset (buf, &iter, end);
gtk_text_buffer_move_mark_by_name (buf, "selection_bound", &iter);
gdk_threads_leave ();
}
//================================================================
int GUI_edi_InsFile (MemObj *mo, char *fnam) {
//================================================================
/// GUI_edi_InsFile insert file at curPos, make text selected
// see also ED_add_File
// was GUI_Ed_Ins_f
GtkTextMark *mk1;
GtkTextIter it1, it2;
long fSiz, cPos1;
void *fBuf;
// set GUI_ed1_view GUI_ed1_buff
if(mo) { // for internal call: mo=NULL
if(GUI_ed1_decode(mo)) return -1;
}
// get file -> fBuf
MEM_alloc_file (&fBuf, &fSiz, fnam);
UTX_str_file (fBuf, &fSiz, fnam);
if(fSiz < 1) {
TX_Print("GUI_Ed_Ins_f E001 |%s|",fnam);
return -1;
}
// printf("fBuf=|%s|\n",(char*)fBuf);
// // get get iters for "insert" & "selection_bound"
// gtk_text_buffer_get_selection_bounds (wTx->text, &it1, &it2);
// // insert at iterPos
// gtk_text_buffer_insert (wTx->text, &it1, txbuf, -1);
// get iter it1 at CurPos
mk1 = gtk_text_buffer_get_mark (GUI_ed1_buff, "insert");
// iter at CurPos
gtk_text_buffer_get_iter_at_mark (GUI_ed1_buff, &it1, mk1);
cPos1 = gtk_text_iter_get_offset (&it1);
// insert text txbuf at curpos;
gtk_text_buffer_insert_at_cursor (GUI_ed1_buff, fBuf, fSiz);
// get iter it2 at new CurPos
mk1 = gtk_text_buffer_get_mark (GUI_ed1_buff, "insert");
gtk_text_buffer_get_iter_at_mark (GUI_ed1_buff, &it2, mk1);
// set to old curPos it1
gtk_text_buffer_get_iter_at_offset (GUI_ed1_buff, &it1, cPos1);
gtk_text_buffer_place_cursor (GUI_ed1_buff, &it1);
// select region curPos - it2
gtk_text_buffer_move_mark_by_name (GUI_ed1_buff, "selection_bound", &it2);
return 0;
}
//================================================================
int GUI_edi_sel__ (MemObj *mo, long von, long bis) {
//================================================================
/// \code
/// select_region from-curPos to-curPos
/// if(from-curPos < 0) - unsect all !
/// \endcode
GtkTextIter it1;
GtkTextMark *mk1;
// printf("GUI_edi_sel__ %d %d\n",von,bis);
if(mo) { // for internal call: mo=NULL
if(GUI_ed1_decode(mo)) return -1;
}
// get iter from offset
gtk_text_buffer_get_iter_at_offset (GUI_ed1_buff, &it1, von);
// move "insert" & "selection_bound"-marks
gtk_text_buffer_place_cursor (GUI_ed1_buff, &it1);
// get iter from offset
gtk_text_buffer_get_iter_at_offset (GUI_ed1_buff, &it1, bis);
// set end - mark
gtk_text_buffer_move_mark_by_name (GUI_ed1_buff, "selection_bound", &it1);
return 0;
}
/*
* 'Search Backward'
*/
void av_editor_search_backward(const av_editor *editor)
{
GtkTextIter iter_search_start, iter_search_end;
GtkTextIter iter_match_start, iter_match_end;
GtkTextIter iter_end;
GtkTextSearchFlags flags_search;
gchar *text_search = NULL;
gboolean found = FALSE;
gboolean status = FALSE;
g_return_if_fail(editor != NULL && editor->textbuf != NULL);
status = gtk_text_buffer_get_selection_bounds(GTK_TEXT_BUFFER(editor->textbuf),
&iter_search_start,
&iter_search_end);
g_return_if_fail(status == TRUE);
text_search = gtk_text_buffer_get_text(GTK_TEXT_BUFFER(editor->textbuf),
&iter_search_start,
&iter_search_end,
FALSE);
g_return_if_fail(text_search != NULL);
iter_end = iter_search_start;
flags_search = GTK_TEXT_SEARCH_VISIBLE_ONLY | GTK_TEXT_SEARCH_TEXT_ONLY;
found = editor_search_backward(editor,
text_search,
flags_search,
NULL,
&iter_end,
&iter_match_start,
&iter_match_end);
if (found)
{
gtk_text_buffer_place_cursor(GTK_TEXT_BUFFER(editor->textbuf), &iter_match_start);
gtk_text_buffer_move_mark_by_name (GTK_TEXT_BUFFER(editor->textbuf),
AV_EDITOR_MARK_NAME_SELECTION_BOUND,
&iter_match_end);
gtk_text_view_scroll_to_mark(GTK_TEXT_VIEW(editor->textview),
gtk_text_buffer_get_insert(editor->textbuf),
AV_EDITOR_VIEW_SCROLL_MARGIN,
FALSE,
AV_EDITOR_VIEW_SCROLL_XALIGN,
AV_EDITOR_VIEW_SCROLL_YALIGN);
}
else
{
// Do nothing here
AV_DBG("%s: search text backward: %s: not found\n", __func__, text_search);
}
}
void indent_multi_line_unindent(GtkTextBuffer *buffer)
{
GtkTextIter start_iter, end_iter, iter;
gint start_line, end_line, i, len;
gboolean pos;
gchar *ind;
gtk_text_buffer_get_selection_bounds(buffer, &start_iter, &end_iter);
start_line = gtk_text_iter_get_line(&start_iter);
end_line = gtk_text_iter_get_line(&end_iter);
gtk_text_buffer_get_iter_at_mark(buffer, &iter, gtk_text_buffer_get_insert(buffer));
pos = gtk_text_iter_equal(&iter, &start_iter);
i = start_line;
do {
ind = compute_indentation(buffer, NULL, i);
if (ind && strlen(ind)) {
len = compute_indent_offset_length(ind);
gtk_text_buffer_get_iter_at_line(buffer, &start_iter, i);
gtk_text_buffer_place_cursor(buffer, &start_iter);
end_iter = start_iter;
gtk_text_iter_forward_chars(&end_iter, len);
gtk_text_buffer_move_mark_by_name(buffer, "insert", &end_iter);
g_signal_emit_by_name(G_OBJECT(buffer), "begin-user-action");
gtk_text_buffer_delete(buffer, &start_iter, &end_iter);
g_signal_emit_by_name(G_OBJECT(buffer), "end-user-action");
undo_set_sequency(TRUE);
g_free(ind);
}
i++;
} while (i < end_line);
undo_set_sequency(FALSE);
gtk_text_buffer_get_iter_at_line(buffer, &start_iter, start_line);
gtk_text_buffer_get_iter_at_line(buffer, &end_iter, end_line);
if (pos) {
gtk_text_buffer_place_cursor(buffer, &end_iter);
gtk_text_buffer_move_mark_by_name(buffer, "insert", &start_iter);
} else {
gtk_text_buffer_place_cursor(buffer, &start_iter);
gtk_text_buffer_move_mark_by_name(buffer, "insert", &end_iter);
}
}
void
peacock_file_set_selection (PeacockFile *file, GtkTextIter *start,
GtkTextIter *end)
{
g_return_if_fail (file != NULL);
g_return_if_fail (PEACOCK_IS_FILE (file));
gtk_text_buffer_place_cursor (GTK_TEXT_BUFFER (file), end);
gtk_text_buffer_move_mark_by_name (GTK_TEXT_BUFFER (file),
"selection_bound", start);
}
static void menu_select_all (GtkMenuItem *menuitem, gpointer data) {
GtkTextIter p;
// Get the starting point of the buffer
gtk_text_buffer_get_start_iter(editor_buf, &p);
// Ignore the selection made by the mouse
gtk_text_buffer_place_cursor(editor_buf, &p);
// Get the ending point of the buffer
gtk_text_buffer_get_end_iter(editor_buf, &p);
gtk_text_buffer_move_mark_by_name(editor_buf, "selection_bound", &p);
}
static void set_selection_bound(GtkTextBuffer *buffer, gint start, gint end)
{
GtkTextIter start_iter, end_iter;
gtk_text_buffer_get_iter_at_offset(buffer, &start_iter, start);
if (end < 0)
gtk_text_buffer_get_end_iter(buffer, &end_iter);
else
gtk_text_buffer_get_iter_at_offset(buffer, &end_iter, end);
gtk_text_buffer_place_cursor(buffer, &end_iter);
gtk_text_buffer_move_mark_by_name(buffer, "selection_bound", &start_iter);
}
static gboolean
ev_view_accessible_add_selection (AtkText *text,
gint start_pos,
gint end_pos)
{
GtkWidget *widget;
GtkTextBuffer *buffer;
GtkTextIter pos_itr;
GtkTextIter start, end;
gint select_start, select_end;
gboolean retval = FALSE;
widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (text));
if (widget == NULL)
/* State is defunct */
return FALSE;
buffer = ev_view_accessible_get_text_buffer (EV_VIEW_ACCESSIBLE (text), EV_VIEW (widget));
if (!buffer)
return FALSE;
gtk_text_buffer_get_selection_bounds (buffer, &start, &end);
select_start = gtk_text_iter_get_offset (&start);
select_end = gtk_text_iter_get_offset (&end);
/* If there is already a selection, then don't allow
* another to be added
*/
if (select_start == select_end) {
gtk_text_buffer_get_iter_at_offset (buffer, &pos_itr, start_pos);
gtk_text_buffer_move_mark_by_name (buffer, "selection_bound", &pos_itr);
gtk_text_buffer_get_iter_at_offset (buffer, &pos_itr, end_pos);
gtk_text_buffer_move_mark_by_name (buffer, "insert", &pos_itr);
retval = TRUE;
}
return retval;
}
void
dma_data_view_refresh (DmaDataView *view)
{
gchar *data = "";
gint offset;
GtkTextIter cur;
GtkTextMark *mark;
GtkTextBuffer *buffer;
/* Save all cursor offset */
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (view->address));
mark = gtk_text_buffer_get_insert (buffer);
gtk_text_buffer_get_iter_at_mark (buffer, &cur, mark);
offset = gtk_text_iter_get_offset (&cur);
data = dma_data_buffer_get_address (view->buffer, view->start, view->line_by_page * view->bytes_by_line, view->bytes_by_line, sizeof(view->start) * 2);
gtk_text_buffer_set_text (buffer, data, -1);
g_free (data);
mark = gtk_text_buffer_get_insert (buffer);
gtk_text_buffer_get_iter_at_mark (buffer, &cur, mark);
gtk_text_iter_set_offset (&cur, offset);
gtk_text_buffer_move_mark_by_name (buffer, "insert", &cur);
gtk_text_buffer_move_mark_by_name (buffer, "selection_bound", &cur);
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (view->data));
mark = gtk_text_buffer_get_insert (buffer);
gtk_text_buffer_get_iter_at_mark (buffer, &cur, mark);
offset = gtk_text_iter_get_offset (&cur);
data = dma_data_buffer_get_data (view->buffer, view->start, view->line_by_page * view->bytes_by_line, view->bytes_by_line, DMA_HEXADECIMAL_BASE);
gtk_text_buffer_set_text (buffer, data, -1);
g_free (data);
mark = gtk_text_buffer_get_insert (buffer);
gtk_text_buffer_get_iter_at_mark (buffer, &cur, mark);
gtk_text_iter_set_offset (&cur, offset);
gtk_text_buffer_move_mark_by_name (buffer, "insert", &cur);
gtk_text_buffer_move_mark_by_name (buffer, "selection_bound", &cur);
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (view->ascii));
mark = gtk_text_buffer_get_insert (buffer);
gtk_text_buffer_get_iter_at_mark (buffer, &cur, mark);
offset = gtk_text_iter_get_offset (&cur);
data = dma_data_buffer_get_data (view->buffer, view->start, view->line_by_page * view->bytes_by_line, view->bytes_by_line, DMA_ASCII_BASE);
gtk_text_buffer_set_text (buffer, data, -1);
g_free (data);
mark = gtk_text_buffer_get_insert (buffer);
gtk_text_buffer_get_iter_at_mark (buffer, &cur, mark);
gtk_text_iter_set_offset (&cur, offset);
gtk_text_buffer_move_mark_by_name (buffer, "insert", &cur);
gtk_text_buffer_move_mark_by_name (buffer, "selection_bound", &cur);
}
static gboolean
t_text_tail_print (GIOChannel *source, GIOCondition condition, gpointer data)
{
GtkTextView *text_view;
GtkTextBuffer *buffer;
GtkTextIter iter;
gchar *line;
gsize len;
GError *err = NULL;
if (G_IO_STATUS_NORMAL != g_io_channel_read_line (source, &line, &len, NULL, &err)) {
if (len > 0)
g_free (line);
T_ERR_WARN (err);
return FALSE;
}
T_ERR_WARN (err);
if (!len) {
g_warning ("Empty line");
return TRUE;
}
text_view = GTK_TEXT_VIEW (data);
/* append text */
buffer = gtk_text_view_get_buffer (text_view);
gtk_text_buffer_get_end_iter (buffer, &iter);
gtk_text_buffer_insert (buffer, &iter, line, -1);
g_free (line);
/* move carret to the end */
gtk_text_buffer_get_end_iter (buffer, &iter);
gtk_text_buffer_move_mark_by_name (buffer, "insert", &iter);
/* scroll to carret */
gtk_text_view_scroll_to_mark (
text_view,
gtk_text_buffer_get_mark (buffer, "insert"),
0.0,
FALSE,
0.0,
0.0
);
return TRUE;
}
static gboolean
ev_view_accessible_remove_selection (AtkText *text,
gint selection_num)
{
GtkWidget *widget;
GtkTextBuffer *buffer;
GtkTextMark *cursor_mark;
GtkTextIter cursor_itr;
GtkTextIter start, end;
gint select_start, select_end;
gboolean retval = FALSE;
widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (text));
if (widget == NULL)
/* State is defunct */
return FALSE;
buffer = ev_view_accessible_get_text_buffer (EV_VIEW_ACCESSIBLE (text), EV_VIEW (widget));
if (!buffer)
return FALSE;
gtk_text_buffer_get_selection_bounds(buffer, &start, &end);
select_start = gtk_text_iter_get_offset(&start);
select_end = gtk_text_iter_get_offset(&end);
if (select_start != select_end) {
/* Setting the start & end of the selected region
* to the caret position turns off the selection.
*/
cursor_mark = gtk_text_buffer_get_insert (buffer);
gtk_text_buffer_get_iter_at_mark (buffer, &cursor_itr, cursor_mark);
gtk_text_buffer_move_mark_by_name (buffer, "selection_bound", &cursor_itr);
retval = TRUE;
}
return retval;
}
static gboolean
chat_text_view_find_previous (EmpathyChatView *view,
const gchar *search_criteria,
gboolean new_search,
gboolean match_case)
{
EmpathyChatTextViewPriv *priv;
GtkTextBuffer *buffer;
GtkTextIter iter_at_mark;
GtkTextIter iter_match_start;
GtkTextIter iter_match_end;
gboolean found;
gboolean from_start = FALSE;
g_return_val_if_fail (EMPATHY_IS_CHAT_TEXT_VIEW (view), FALSE);
g_return_val_if_fail (search_criteria != NULL, FALSE);
priv = GET_PRIV (view);
buffer = priv->buffer;
if (EMP_STR_EMPTY (search_criteria)) {
if (priv->find_mark_previous) {
gtk_text_buffer_get_start_iter (buffer, &iter_at_mark);
gtk_text_buffer_move_mark (buffer,
priv->find_mark_previous,
&iter_at_mark);
gtk_text_view_scroll_to_mark (GTK_TEXT_VIEW (view),
priv->find_mark_previous,
0.0,
TRUE,
0.0,
0.0);
gtk_text_buffer_select_range (buffer,
&iter_at_mark,
&iter_at_mark);
}
return FALSE;
}
if (new_search) {
from_start = TRUE;
}
if (!new_search && priv->find_mark_previous) {
gtk_text_buffer_get_iter_at_mark (buffer,
&iter_at_mark,
priv->find_mark_previous);
} else {
gtk_text_buffer_get_end_iter (buffer, &iter_at_mark);
from_start = TRUE;
}
priv->find_last_direction = FALSE;
/* Use the standard GTK+ method for case sensitive searches. It can't do
* case insensitive searches (see bug #61852), so keep the custom method
* around for case insensitive searches. */
if (match_case) {
found = gtk_text_iter_backward_search (&iter_at_mark,
search_criteria,
0, /* no text search flags, we want exact matches */
&iter_match_start,
&iter_match_end,
NULL);
} else {
found = empathy_text_iter_backward_search (&iter_at_mark,
search_criteria,
&iter_match_start,
&iter_match_end,
NULL);
}
if (!found) {
gboolean result = FALSE;
if (from_start) {
return result;
}
/* Here we wrap around. */
if (!new_search && !priv->find_wrapped) {
priv->find_wrapped = TRUE;
result = chat_text_view_find_previous (view,
search_criteria,
FALSE,
match_case);
priv->find_wrapped = FALSE;
}
return result;
}
/* Set new mark and show on screen */
if (!priv->find_mark_previous) {
priv->find_mark_previous = gtk_text_buffer_create_mark (buffer, NULL,
&iter_match_start,
TRUE);
} else {
gtk_text_buffer_move_mark (buffer,
priv->find_mark_previous,
&iter_match_start);
}
if (!priv->find_mark_next) {
priv->find_mark_next = gtk_text_buffer_create_mark (buffer, NULL,
&iter_match_end,
TRUE);
} else {
gtk_text_buffer_move_mark (buffer,
priv->find_mark_next,
&iter_match_end);
}
gtk_text_view_scroll_to_mark (GTK_TEXT_VIEW (view),
priv->find_mark_previous,
0.0,
TRUE,
0.5,
0.5);
gtk_text_buffer_move_mark_by_name (buffer, "selection_bound", &iter_match_start);
gtk_text_buffer_move_mark_by_name (buffer, "insert", &iter_match_end);
return TRUE;
}
static gboolean
run_search (GeditViewFrame *frame,
const gchar *entry_text,
gboolean search_backward,
gboolean wrap_around,
gboolean typing)
{
GtkTextIter start_iter;
GtkTextIter match_start;
GtkTextIter match_end;
gboolean found = FALSE;
GeditDocument *doc;
g_return_val_if_fail (frame->priv->search_mode == SEARCH, FALSE);
doc = gedit_view_frame_get_document (frame);
gtk_text_buffer_get_iter_at_mark (GTK_TEXT_BUFFER (doc),
&start_iter,
frame->priv->start_mark);
if (*entry_text != '\0')
{
if (!search_backward)
{
if (!typing)
{
/* forward and _NOT_ typing */
gtk_text_buffer_get_selection_bounds (GTK_TEXT_BUFFER (doc),
&start_iter,
&match_end);
gtk_text_iter_order (&match_end, &start_iter);
}
/* run search */
found = gedit_document_search_forward (doc,
&start_iter,
NULL,
&match_start,
&match_end);
}
else if (!typing)
{
/* backward and not typing */
gtk_text_buffer_get_selection_bounds (GTK_TEXT_BUFFER (doc),
&start_iter,
&match_end);
/* run search */
found = gedit_document_search_backward (doc,
NULL,
&start_iter,
&match_start,
&match_end);
}
else
{
/* backward (while typing) */
g_return_val_if_reached (FALSE);
}
if (!found && wrap_around)
{
if (!search_backward)
{
found = gedit_document_search_forward (doc,
NULL,
NULL, /* FIXME: set the end_inter */
&match_start,
&match_end);
}
else
{
found = gedit_document_search_backward (doc,
NULL, /* FIXME: set the start_inter */
NULL,
&match_start,
&match_end);
}
}
}
else
{
gtk_text_buffer_get_selection_bounds (GTK_TEXT_BUFFER (doc),
&start_iter,
NULL);
}
if (found)
{
gtk_text_buffer_place_cursor (GTK_TEXT_BUFFER (doc),
&match_start);
gtk_text_buffer_move_mark_by_name (GTK_TEXT_BUFFER (doc),
"selection_bound", &match_end);
}
else if (typing)
{
gtk_text_buffer_get_iter_at_mark (GTK_TEXT_BUFFER (doc),
&start_iter,
frame->priv->start_mark);
gtk_text_buffer_place_cursor (GTK_TEXT_BUFFER (doc),
&start_iter);
}
if (found || (*entry_text == '\0'))
{
gedit_view_scroll_to_cursor (GEDIT_VIEW (frame->priv->view));
set_entry_background (frame, frame->priv->search_entry,
GEDIT_SEARCH_ENTRY_NORMAL);
}
else
{
set_entry_background (frame, frame->priv->search_entry,
GEDIT_SEARCH_ENTRY_NOT_FOUND);
}
return found;
}
static gboolean
run_search (PlumaView *view,
gboolean wrap_around,
gboolean search_backwards)
{
PlumaDocument *doc;
GtkTextIter start_iter;
GtkTextIter match_start;
GtkTextIter match_end;
gboolean found = FALSE;
doc = PLUMA_DOCUMENT (gtk_text_view_get_buffer (GTK_TEXT_VIEW (view)));
if (!search_backwards)
{
gtk_text_buffer_get_selection_bounds (GTK_TEXT_BUFFER (doc),
NULL,
&start_iter);
found = pluma_document_search_forward (doc,
&start_iter,
NULL,
&match_start,
&match_end);
}
else
{
gtk_text_buffer_get_selection_bounds (GTK_TEXT_BUFFER (doc),
&start_iter,
NULL);
found = pluma_document_search_backward (doc,
NULL,
&start_iter,
&match_start,
&match_end);
}
if (!found && wrap_around)
{
if (!search_backwards)
found = pluma_document_search_forward (doc,
NULL,
NULL, /* FIXME: set the end_inter */
&match_start,
&match_end);
else
found = pluma_document_search_backward (doc,
NULL, /* FIXME: set the start_inter */
NULL,
&match_start,
&match_end);
}
if (found)
{
gtk_text_buffer_place_cursor (GTK_TEXT_BUFFER (doc),
&match_start);
gtk_text_buffer_move_mark_by_name (GTK_TEXT_BUFFER (doc),
"selection_bound",
&match_end);
pluma_view_scroll_to_cursor (view);
}
else
{
gtk_text_buffer_place_cursor (GTK_TEXT_BUFFER (doc),
&start_iter);
}
return found;
}
static gboolean
chat_text_view_find_next (EmpathyChatView *view,
const gchar *search_criteria,
gboolean new_search)
{
EmpathyChatTextViewPriv *priv;
GtkTextBuffer *buffer;
GtkTextIter iter_at_mark;
GtkTextIter iter_match_start;
GtkTextIter iter_match_end;
gboolean found;
gboolean from_start = FALSE;
g_return_val_if_fail (EMPATHY_IS_CHAT_TEXT_VIEW (view), FALSE);
g_return_val_if_fail (search_criteria != NULL, FALSE);
priv = GET_PRIV (view);
buffer = priv->buffer;
if (EMP_STR_EMPTY (search_criteria)) {
if (priv->find_mark_next) {
gtk_text_buffer_get_start_iter (buffer, &iter_at_mark);
gtk_text_buffer_move_mark (buffer,
priv->find_mark_next,
&iter_at_mark);
gtk_text_view_scroll_to_mark (GTK_TEXT_VIEW (view),
priv->find_mark_next,
0.0,
TRUE,
0.0,
0.0);
gtk_text_buffer_select_range (buffer,
&iter_at_mark,
&iter_at_mark);
}
return FALSE;
}
if (new_search) {
from_start = TRUE;
}
if (priv->find_mark_next) {
gtk_text_buffer_get_iter_at_mark (buffer,
&iter_at_mark,
priv->find_mark_next);
} else {
gtk_text_buffer_get_start_iter (buffer, &iter_at_mark);
from_start = TRUE;
}
priv->find_last_direction = TRUE;
found = empathy_text_iter_forward_search (&iter_at_mark,
search_criteria,
&iter_match_start,
&iter_match_end,
NULL);
if (!found) {
gboolean result = FALSE;
if (from_start) {
return result;
}
/* Here we wrap around. */
if (!new_search && !priv->find_wrapped) {
priv->find_wrapped = TRUE;
result = chat_text_view_find_next (view,
search_criteria,
FALSE);
priv->find_wrapped = FALSE;
}
return result;
}
/* Set new mark and show on screen */
if (!priv->find_mark_next) {
priv->find_mark_next = gtk_text_buffer_create_mark (buffer, NULL,
&iter_match_end,
TRUE);
} else {
gtk_text_buffer_move_mark (buffer,
priv->find_mark_next,
&iter_match_end);
}
if (!priv->find_mark_previous) {
priv->find_mark_previous = gtk_text_buffer_create_mark (buffer, NULL,
&iter_match_start,
TRUE);
} else {
gtk_text_buffer_move_mark (buffer,
priv->find_mark_previous,
&iter_match_start);
}
gtk_text_view_scroll_to_mark (GTK_TEXT_VIEW (view),
priv->find_mark_next,
0.0,
TRUE,
0.5,
0.5);
gtk_text_buffer_move_mark_by_name (buffer, "selection_bound", &iter_match_start);
gtk_text_buffer_move_mark_by_name (buffer, "insert", &iter_match_end);
return TRUE;
}
static void menu_show(gpointer data, guint action, GtkWidget *widget)
{
GtkTextIter p;
switch(action)
{
case MENU_NEW:
if(save_if_modified()) /* call save if modified wen user opens a new file */
{
/* get all the current tag table n put them in the new buffer */
buf = gtk_text_buffer_new(gtk_text_buffer_get_tag_table(buf));
gtk_text_view_set_buffer(GTK_TEXT_VIEW(view), buf);
g_object_unref(G_OBJECT(buf));
/* needed for freeing memory by the buffer wen a new buffer is created */
}
break;
case MENU_OPEN:
if(save_if_modified())
{
/* call save if modified wen user opens a new file */
buf = gtk_text_buffer_new(gtk_text_buffer_get_tag_table(buf));
gtk_text_view_set_buffer(GTK_TEXT_VIEW(view), buf);
/* needed for freeing memory by the buffer wen a new buffer is created */
g_object_unref(G_OBJECT(buf));
load_file(NULL);
}
break;
case MENU_SAVE:
save_file(filename);
break;
case MENU_SAVE_AS:
save_file(NULL);
break;
case MENU_QUIT:
if(save_if_modified()) /* call save if modified wen user opens a new file */
gtk_widget_destroy(window);
break;
case MENU_CUT:
gtk_text_buffer_cut_clipboard(buf,gtk_clipboard_get(sel_atom), TRUE);
break;
case MENU_COPY:
gtk_text_buffer_copy_clipboard(buf,gtk_clipboard_get(sel_atom));
break;
case MENU_PASTE:
/* if null text is inserted at the current cursor position */
gtk_text_buffer_paste_clipboard(buf,gtk_clipboard_get(sel_atom), NULL, TRUE);
break;
case MENU_FIND:
textfind();
break;
case MENU_REPLACE:
text_find_replace();
break;
case MENU_SELECT_ALL:
gtk_text_buffer_get_start_iter(buf, &p); /* get the starting pt of the buffer */
gtk_text_buffer_place_cursor(buf, &p); /* ignore the selection made by the mouse */
gtk_text_buffer_get_end_iter(buf, &p); /* get the ending pt of the buffer */
gtk_text_buffer_move_mark_by_name(buf, "selection_bound", &p);
break;
case MENU_HELP:
show_help();
break;
case MENU_ABOUT:
show_about();
break;
default: /* error checking */
g_printerr("Menu action not defined : %u\n", action);
break;
}
}
gboolean document_search_real(GtkWidget *textview, gint direction)
{
GtkTextIter iter, match_start, match_end;
gboolean res;
GtkSourceSearchFlags search_flags = GTK_SOURCE_SEARCH_VISIBLE_ONLY | GTK_SOURCE_SEARCH_TEXT_ONLY;
GtkTextBuffer *textbuffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(textview));
if (!string_find)
return FALSE;
if (!match_case)
search_flags = search_flags | GTK_SOURCE_SEARCH_CASE_INSENSITIVE;
// if (direction == 0 || !hlight_check_searched())
if (direction == 0 || (direction != 2 && !hlight_check_searched()))
hlight_searched_strings(GTK_TEXT_VIEW(textview)->buffer, string_find);
gtk_text_mark_set_visible(
gtk_text_buffer_get_selection_bound(
GTK_TEXT_VIEW(textview)->buffer), FALSE);
gtk_text_buffer_get_iter_at_mark(textbuffer, &iter, gtk_text_buffer_get_insert(textbuffer));
if (direction < 0) {
res = gtk_source_iter_backward_search(
&iter, string_find, search_flags, &match_start, &match_end, NULL);
if (gtk_text_iter_equal(&iter, &match_end)) {
res = gtk_source_iter_backward_search(
&match_start, string_find, search_flags, &match_start, &match_end, NULL);
}
} else {
res = gtk_source_iter_forward_search(
&iter, string_find, search_flags, &match_start, &match_end, NULL);
}
/* TODO: both gtk_(text/source)_iter_backward_search works not fine for multi-byte */
/* wrap */
/* TODO: define limit NULL -> proper value */
if (!res) {
if (direction < 0) {
gtk_text_buffer_get_end_iter(textbuffer, &iter);
res = gtk_source_iter_backward_search(
&iter, string_find, search_flags, &match_start, &match_end, NULL);
} else {
gtk_text_buffer_get_start_iter(textbuffer, &iter);
res = gtk_source_iter_forward_search(
&iter, string_find, search_flags, &match_start, &match_end, NULL);
}
}
if (res) {
gtk_text_buffer_place_cursor(textbuffer, &match_start);
gtk_text_buffer_move_mark_by_name(textbuffer, "insert", &match_end);
// gtk_text_view_scroll_to_iter(GTK_TEXT_VIEW(textview), &match_start, 0.1, FALSE, 0.5, 0.5);
scroll_to_cursor(textbuffer, 0.05);
}
else if (direction == 0)
run_dialog_message(gtk_widget_get_toplevel(textview), GTK_MESSAGE_WARNING,
_("Search string not found"));
return res;
}
static gint document_replace_real(GtkWidget *textview)
{
GtkTextIter iter, match_start, match_end, rep_start;
GtkTextMark *mark_init = NULL;
gboolean res;
gint num = 0, offset;
GtkWidget *q_dialog = NULL;
GtkSourceSearchFlags search_flags = GTK_SOURCE_SEARCH_VISIBLE_ONLY | GTK_SOURCE_SEARCH_TEXT_ONLY;
GtkTextBuffer *textbuffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(textview));
if (!match_case)
search_flags = search_flags | GTK_SOURCE_SEARCH_CASE_INSENSITIVE;
if (replace_all) {
gtk_text_buffer_get_iter_at_mark(textbuffer,
&iter, gtk_text_buffer_get_insert(textbuffer));
mark_init = gtk_text_buffer_create_mark(textbuffer, NULL, &iter, FALSE);
gtk_text_buffer_get_start_iter(textbuffer, &iter);
gtk_text_buffer_get_end_iter(textbuffer, &match_end);
// gtk_text_buffer_remove_tag_by_name(textbuffer,
// "replaced", &iter, &match_end);
gtk_text_buffer_remove_all_tags(textbuffer,
&iter, &match_end);
} else {
hlight_searched_strings(textbuffer, string_find);
hlight_toggle_searched(textbuffer);
}
do {
if (replace_all) {
res = gtk_source_iter_forward_search(
&iter, string_find, search_flags, &match_start, &match_end, NULL);
if (res) {
gtk_text_buffer_place_cursor(textbuffer, &match_start);
gtk_text_buffer_move_mark_by_name(textbuffer, "insert", &match_end);
gtk_text_buffer_get_iter_at_mark(
textbuffer, &iter, gtk_text_buffer_get_insert(textbuffer));
}
}
else
// res = document_search_real(textview, 0);
res = document_search_real(textview, 2);
if (res) {
if (!replace_all) {
if (num == 0 && q_dialog == NULL)
q_dialog = create_dialog_message_question(
gtk_widget_get_toplevel(textview), _("Replace?"));
#if GTK_CHECK_VERSION(2, 10, 0)
GtkTextIter ins,bou;
gtk_text_buffer_get_selection_bounds(textbuffer, &ins, &bou);
#endif
switch (gtk_dialog_run(GTK_DIALOG(q_dialog))) {
case GTK_RESPONSE_YES:
#if GTK_CHECK_VERSION(2, 10, 0)
gtk_text_buffer_select_range(textbuffer, &ins, &bou);
#endif
break;
case GTK_RESPONSE_NO:
continue;
// case GTK_RESPONSE_CANCEL:
default:
res = 0;
if (num == 0)
num = -1;
continue;
}
}
gtk_text_buffer_delete_selection(textbuffer, TRUE, TRUE);
if (strlen(string_replace)) {
gtk_text_buffer_get_iter_at_mark(
textbuffer, &rep_start,
gtk_text_buffer_get_insert(textbuffer));
offset = gtk_text_iter_get_offset(&rep_start);
undo_set_sequency(TRUE);
g_signal_emit_by_name(G_OBJECT(textbuffer),
"begin-user-action");
gtk_text_buffer_insert_at_cursor(textbuffer,
string_replace, strlen(string_replace));
g_signal_emit_by_name(G_OBJECT(textbuffer),
"end-user-action");
gtk_text_buffer_get_iter_at_mark(
textbuffer, &iter,
gtk_text_buffer_get_insert(textbuffer));
gtk_text_buffer_get_iter_at_offset(textbuffer,
&rep_start, offset);
gtk_text_buffer_apply_tag_by_name(textbuffer,
"replaced", &rep_start, &iter);
} else
gtk_text_buffer_get_iter_at_mark(
textbuffer, &iter,
gtk_text_buffer_get_insert(textbuffer));
num++;
/* if (replace_all)
undo_set_sequency(TRUE);
else
undo_set_sequency(FALSE);*/
undo_set_sequency(replace_all);
}
} while (res);
if (!hlight_check_searched())
hlight_toggle_searched(textbuffer);
if (q_dialog)
gtk_widget_destroy(q_dialog);
/* if (strlen(string_replace)) {
replace_mode = TRUE;
hlight_searched_strings(textbuffer, string_replace);
} */
if (replace_all) {
gtk_text_buffer_get_iter_at_mark(textbuffer, &iter, mark_init);
gtk_text_buffer_place_cursor(textbuffer, &iter);
run_dialog_message(gtk_widget_get_toplevel(textview), GTK_MESSAGE_INFO,
_("%d strings replaced"), num);
undo_set_sequency(FALSE);
}
return num;
}
//================================================================
int GUI_edi_sel_ln (MemObj *mo, long lNr) {
//================================================================
/// \code
/// GUI_edi_sel_ln select Line, set Curpos to Line.
/// Erste Zeile ist 1
/// rc -1: lNr does not exist
/// ACHTUNG: die ZeilenStart/Endposition wird aus dem mem gelesen !!!!
/// \endcode
int i1, irc=0, cNr;
GtkTextIter it1, it2;
// printf("GUI_edi_sel_ln %ld\n",lNr);
// set GUI_ed1_view GUI_ed1_buff
if(mo) { // for internal call: mo=NULL
if(GUI_ed1_decode(mo)) return -1;
}
GUI_ed1_stat = 1;
// g_signal_handlers_block_by_func ( // geht ned ..
// G_OBJECT (GUI_ed1_buff),
// G_CALLBACK (GUI_ed1_cb2), GUI_ed1_ActObj->uFunc);
--lNr;
// get Iter at Linestart
// DOES NOT WORK FOR LAST LINE !
if(lNr == gtk_text_buffer_get_line_count (GUI_ed1_buff)) {
irc = -2;
goto L_exit;
} else {
gtk_text_buffer_get_iter_at_line (GUI_ed1_buff, &it1, lNr);
}
// move "insert" & "selection_bound"-marks
gtk_text_buffer_place_cursor (GUI_ed1_buff, &it1);
// get Iter at start of next Line
// ++lNr;
if(lNr == gtk_text_buffer_get_line_count (GUI_ed1_buff)) {
gtk_text_buffer_get_end_iter (GUI_ed1_buff, &it2);
} else {
// gtk_text_buffer_get_iter_at_line (GUI_ed1_buff, &it2, lNr);
cNr = gtk_text_iter_get_bytes_in_line (&it1);
// printf(" cNr = %d\n",cNr);
--cNr; // LF
gtk_text_iter_forward_chars (&it1, cNr);
}
// set mark
gtk_text_buffer_move_mark_by_name (GUI_ed1_buff, "selection_bound", &it1);
// scroll & focus
GUI_edi_scroll_s (NULL);
L_exit:
GUI_ed1_stat = 0;
// g_signal_handlers_unblock_by_func ( // geht ned ..
// G_OBJECT (GUI_ed1_buff),
// G_CALLBACK (GUI_ed1_cb2), GUI_ed1_ActObj->uFunc);
// printf("ex GUI_edi_sel_ln\n");
return irc;
}
