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);
}
}
//================================================================
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;
}
//================================================================
int GUI_edi_setLnr (MemObj *mo, long lNr) {
//================================================================
GtkTextIter it1;
// printf("GUI_edi_setLnr %ld\n",lNr);
--lNr; // first line = 1 // 2012-07-13
// set GUI_ed1_view GUI_ed1_buff
if(mo) { // for internal call: mo=NULL
if(GUI_ed1_decode(mo)) return -1;
}
// set iter from lNr
if(lNr == gtk_text_buffer_get_line_count (GUI_ed1_buff)) {
gtk_text_buffer_get_end_iter (GUI_ed1_buff, &it1);
} else {
gtk_text_buffer_get_iter_at_line (GUI_ed1_buff, &it1, lNr);
}
// moves the "insert" and "selection_bound" marks simultaneously
gtk_text_buffer_place_cursor (GUI_ed1_buff, &it1);
// scroll & focus
GUI_edi_scroll_s (NULL);
return 0;
}
void view_command_line(const gchar *text, const gchar *title, const gchar *seek,
gboolean seek_after)
{
GtkTextIter start, end;
gtk_window_set_title(GTK_WINDOW(command_dialog), title ? title : _("GDB Command"));
gtk_widget_grab_focus(command_view);
if (text)
{
const gchar *pos = seek ? strstr(text, seek) : NULL;
GtkTextIter iter;
gtk_text_buffer_set_text(command_text, text, -1);
gtk_text_buffer_get_iter_at_offset(command_text, &iter,
g_utf8_strlen(text, pos ? pos + strlen(seek) * seek_after - text : -1));
gtk_text_buffer_place_cursor(command_text, &iter);
}
on_command_text_changed(command_text, NULL);
command_line_update_state(debug_state());
gtk_text_buffer_get_start_iter(command_text, &start);
gtk_text_buffer_get_end_iter(command_text, &end);
gtk_text_buffer_select_range(command_text, &start, &end);
gtk_combo_box_set_active_iter(command_history, NULL);
gtk_dialog_run(GTK_DIALOG(command_dialog));
}
static void
wrap_line (GtkTextBuffer *buffer,
GtkTextIter *iter,
gchar *text,
gint count,
gpointer data)
{
gint chars = gtk_text_iter_get_chars_in_line (iter);
if ( chars > DOC_LINE_LENGTH )
{
GtkTextIter line_fold = *iter;
GtkTextIter cursor;
gtk_text_iter_set_line_offset (&line_fold, DOC_LINE_LENGTH);
gtk_text_buffer_insert (buffer, &line_fold, "\r\n", 2);
cursor = line_fold;
gtk_text_iter_forward_to_line_end (&cursor);
gtk_text_buffer_place_cursor (buffer, &cursor);
}
}
void ctk_help_set_page(CtkHelp *ctk_help, GtkTextBuffer *buffer)
{
GtkTextBuffer *b;
GtkTextIter iter;
GtkTextView *view;
GtkTextMark *mark;
if (buffer) {
b = buffer;
} else {
b = ctk_help->default_help;
}
view = GTK_TEXT_VIEW(ctk_help->text_viewer);
/* set the buffer in the TextView */
gtk_text_view_set_buffer(view, b);
/* ensure that the top of the buffer is displayed */
gtk_text_buffer_get_start_iter(b, &iter);
mark = gtk_text_buffer_create_mark(b, NULL, &iter, TRUE);
gtk_text_view_scroll_to_mark(view, mark, 0.0, TRUE, 0.0, 0.0);
gtk_text_buffer_place_cursor(b, &iter);
}
static void
lsv_show_message(const char *message, LibBalsaSourceViewerInfo * lsvi,
gboolean escape)
{
GtkTextBuffer *buffer;
GtkTextIter start;
gchar *tmp;
buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(lsvi->text));
gtk_text_buffer_set_text(buffer, "", 0);
if (escape)
tmp = g_strescape(message, "\n“");
else {
tmp = g_strdup(message);
libbalsa_utf8_sanitize(&tmp, FALSE, NULL);
}
if (tmp) {
gtk_text_buffer_insert_at_cursor(buffer, tmp, -1);
g_free(tmp);
}
gtk_text_buffer_get_start_iter(buffer, &start);
gtk_text_buffer_place_cursor(buffer, &start);
}
/**
* \fn void open_file_(BrailleMusicEditor *editor, const gchar *path)
* \brief This function actually opens a file in the editor's textview.
* \param editor The GUI structure.
* \param path the file path.
*/
void open_file_(BrailleMusicEditor *editor, const gchar *path) {
GtkTextBuffer *buffer;
GtkTextIter start;
GtkTextIter end;
FILE *file;
gchar read[1024];
buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(editor->textview));
if(path == NULL)
return;
file = fopen(path,"r");
open_error(editor->window, file, "Can't open the file : \n%s", path);
//save the current file path
editor->filename = (gchar *)path;
gtk_text_buffer_get_start_iter(buffer, &start);
gtk_text_buffer_get_end_iter(buffer, &end);
gtk_text_buffer_delete(buffer, &start, &end);
while(fgets(read, 1024, file)){
gtk_text_buffer_get_end_iter(buffer, &end);
gtk_text_buffer_insert(buffer, &end, read, -1);
}
fclose(file);
gtk_text_buffer_get_start_iter(buffer, &start);
gtk_text_buffer_place_cursor(buffer, &start);
}
//==========================================================================
int GUI_edi_setCpos (MemObj *mo, long cpos) {
//==========================================================================
/// \code
/// set to curPos and view text at curPos
/// cpos -1L is end of file
/// \endcode
GtkTextIter it1;
// printf("GUI_edi_setCpos %ld\n",cpos);
// set GUI_ed1_view GUI_ed1_buff
if(mo) { // for internal call: mo=NULL
if(GUI_ed1_decode(mo)) return -1;
}
// set iter from cpos
gtk_text_buffer_get_iter_at_offset (GUI_ed1_buff, &it1, cpos);
// moves the "insert" and "selection_bound" marks simultaneously
gtk_text_buffer_place_cursor (GUI_ed1_buff, &it1);
// scroll & focus
GUI_edi_scroll_s (NULL);
return 1;
}
/* If @line is bigger than the lines of the document, the cursor is moved
* to the last line and FALSE is returned.
*/
gboolean
gedit_document_goto_line (GeditDocument *doc,
gint line)
{
gboolean ret = TRUE;
guint line_count;
GtkTextIter iter;
gedit_debug (DEBUG_DOCUMENT);
g_return_val_if_fail (GEDIT_IS_DOCUMENT (doc), FALSE);
g_return_val_if_fail (line >= -1, FALSE);
line_count = gtk_text_buffer_get_line_count (GTK_TEXT_BUFFER (doc));
if (line >= line_count)
{
ret = FALSE;
gtk_text_buffer_get_end_iter (GTK_TEXT_BUFFER (doc),
&iter);
}
else
{
gtk_text_buffer_get_iter_at_line (GTK_TEXT_BUFFER (doc),
&iter,
line);
}
gtk_text_buffer_place_cursor (GTK_TEXT_BUFFER (doc), &iter);
return ret;
}
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 ();
}
static void menu_evaluate_modify(const gchar *expr, const char *value, const gchar *title,
gint hb_mode, gint mr_mode, const char *prefix)
{
gchar *display = parse_get_display_from_7bit(value, hb_mode, mr_mode);
gchar *text = g_strdup_printf("%s = %s", expr, display ? display : "");
GtkTextIter iter;
g_free(display);
gtk_window_set_title(GTK_WINDOW(modify_dialog), title);
gtk_widget_grab_focus(modify_value);
gtk_text_buffer_set_text(modify_text, text, -1);
g_free(text);
gtk_text_buffer_get_iter_at_offset(modify_text, &iter, g_utf8_strlen(expr, -1) + 3);
gtk_text_buffer_place_cursor(modify_text, &iter);
modify_dialog_update_state(debug_state());
if (gtk_dialog_run(GTK_DIALOG(modify_dialog)) == GTK_RESPONSE_ACCEPT)
{
text = utils_text_buffer_get_text(modify_text, -1);
utils_strchrepl(text, '\n', ' ');
if (validate_column(text, TRUE))
{
char *locale = utils_get_locale_from_display(text, hb_mode);
debug_send_format(F, "%s-gdb-set var %s", prefix ? prefix : "", locale);
g_free(locale);
}
g_free(text);
}
}
gboolean undo_redo_real(GtkTextBuffer *buffer)
{
GtkTextIter start_iter, end_iter;
UndoInfo *ri;
if (g_list_length(redo_list)) {
// undo_block_signal(buffer);
ri = g_list_last(redo_list)->data;
gtk_text_buffer_get_iter_at_offset(buffer, &start_iter, ri->start);
switch (ri->command) {
case INS:
gtk_text_buffer_insert(buffer, &start_iter, ri->str, -1);
break;
default:
gtk_text_buffer_get_iter_at_offset(buffer, &end_iter, ri->end);
gtk_text_buffer_delete(buffer, &start_iter, &end_iter);
}
undo_list = g_list_append(undo_list, ri);
redo_list = g_list_delete_link(redo_list, g_list_last(redo_list));
DV(g_print("cb_edit_redo: undo left = %d, redo left = %d\n",
g_list_length(undo_list), g_list_length(redo_list)));
// undo_unblock_signal(buffer);
if (ri->seq) {
undo_set_sequency(TRUE);
return TRUE;
}
if (!g_list_length(redo_list))
gtk_widget_set_sensitive(redo_w, FALSE);
gtk_widget_set_sensitive(undo_w, TRUE);
gtk_text_buffer_place_cursor(buffer, &start_iter);
scroll_to_cursor(buffer, 0.05);
}
undo_check_modified_step(buffer);
return FALSE;
}
void SourceView::goToLine (int lineNumber)
{
GtkTextIter iter;
gtk_text_buffer_get_iter_at_line(GTK_TEXT_BUFFER(_buffer), &iter, lineNumber);
gtk_text_buffer_place_cursor(GTK_TEXT_BUFFER(_buffer), &iter);
gtk_text_view_scroll_mark_onscreen(GTK_TEXT_VIEW(_view), gtk_text_buffer_get_insert(GTK_TEXT_BUFFER(_buffer)));
}
/**
* \fn void external_link_catch(GtkWidget *w, GObject *link)
* \brief This function catch the signal when a clic is made on a note.
* \param w The widget which triggered the call.
* \param link ev_link_action.
* \param editor The GUI structure.
*/
void external_link_catch(GtkWidget *widget, GObject *link, BrailleMusicEditor *editor) {
EvLinkAction *l = EV_LINK_ACTION(link);
ev_view_copy_link_address(EV_VIEW(widget), l);
//get line:column link
const gchar * lc = ev_link_action_get_uri(l);
int line, column;
int i = 0;
char c = ' ', temp[2048];
while(c != ':' || i >= strlen(lc)) {
c = lc[i];
temp[i] = c;
i++;
}
temp[i+1]='\0';
line = atoi(temp);
line--;
column = atoi(lc+i);
GtkTextIter it;
GtkTextBuffer *buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(editor->textview));
if(gtk_text_buffer_get_line_count(buffer) < line ) {
line = 0;
column = 0;
}
gtk_text_buffer_get_iter_at_line(buffer, &it, line);
while(column >0 && !gtk_text_iter_ends_line(&it)) {
gtk_text_iter_forward_char(&it);
column--;
}
gtk_widget_grab_focus(editor->textview);
gtk_text_buffer_place_cursor(buffer, &it);
gtk_text_view_scroll_to_iter(GTK_TEXT_VIEW(editor->textview), &it, 0.0, FALSE, 0.5, 0.5);
}
void gTextArea::setPosition(int vl)
{
GtkTextIter *iter = getIterAt();
gtk_text_iter_set_offset(iter, vl);
gtk_text_buffer_place_cursor(_buffer, iter);
ensureVisible();
}
void pTextEdit::setCursorPosition(unsigned position) {
GtkTextMark *mark = gtk_text_buffer_get_mark(textBuffer, "insert");
GtkTextIter iter;
gtk_text_buffer_get_end_iter(textBuffer, &iter);
gtk_text_iter_set_offset(&iter, min(position, gtk_text_iter_get_offset(&iter)));
gtk_text_buffer_place_cursor(textBuffer, &iter);
gtk_text_view_scroll_mark_onscreen(GTK_TEXT_VIEW(subWidget), mark);
}
static void console_insert_prompt (GtkTextBuffer *buf,
GtkTextIter *iter,
const char *prompt)
{
gtk_text_buffer_insert_with_tags_by_name(buf, iter, prompt, -1,
"redtext", NULL);
gtk_text_buffer_place_cursor(buf, iter);
}
static void help_window_load_text(GtkWidget *text, const gchar *path)
{
gchar *pathl;
FILE *f;
gchar s_buf[1024];
GtkTextBuffer *buffer;
GtkTextIter iter;
GtkTextIter start, end;
if (!text || !path) return;
buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(text));
gtk_text_buffer_get_bounds(buffer, &start, &end);
gtk_text_buffer_delete(buffer, &start, &end);
gtk_text_buffer_get_iter_at_offset(buffer, &iter, 0);
pathl = path_from_utf8(path);
f = fopen(pathl, "r");
g_free(pathl);
if (!f)
{
gchar *buf;
buf = g_strdup_printf(_("Unable to load:\n%s"), path);
gtk_text_buffer_insert(buffer, &iter, buf, -1);
g_free(buf);
}
else
{
while (fgets(s_buf, sizeof(s_buf), f))
{
gchar *buf;
gint l;
l = strlen(s_buf);
if (!g_utf8_validate(s_buf, l, NULL))
{
buf = g_locale_to_utf8(s_buf, l, NULL, NULL, NULL);
if (!buf) buf = g_strdup("\n");
}
else
{
buf = NULL;
}
gtk_text_buffer_insert_with_tags_by_name(buffer, &iter,
(buf) ? buf : s_buf, -1,
"monospace", NULL);
g_free(buf);
}
fclose(f);
}
gtk_text_buffer_get_iter_at_offset(buffer, &iter, 0);
gtk_text_buffer_place_cursor(buffer, &iter);
gtk_text_view_scroll_to_iter(GTK_TEXT_VIEW(text), &iter, 0.0, TRUE, 0, 0);
}
void sg_set_cursor(GtkWidget *w, int position)
{
GtkTextIter pos;
GtkTextBuffer *buf;
buf = gtk_text_view_get_buffer(GTK_TEXT_VIEW(w));
gtk_text_buffer_get_iter_at_offset(buf, &pos, position - 1);
gtk_text_buffer_place_cursor(buf, &pos);
gtk_text_view_scroll_mark_onscreen(GTK_TEXT_VIEW(w), gtk_text_buffer_get_insert(buf));
}
void set_buffer(){
gtk_source_buffer_begin_not_undoable_action(GTK_SOURCE_BUFFER(mBuff));
gtk_text_buffer_set_text(GTK_TEXT_BUFFER(mBuff),content,-1);
g_free(content);
gtk_source_buffer_end_not_undoable_action(GTK_SOURCE_BUFFER(mBuff));
gtk_text_buffer_set_modified(GTK_TEXT_BUFFER(mBuff),FALSE);
GtkTextIter iter;
gtk_text_buffer_get_start_iter(GTK_TEXT_BUFFER(mBuff),&iter);
gtk_text_buffer_place_cursor(GTK_TEXT_BUFFER(mBuff),&iter);
}
/**
* gb_view_source_goto_start:
* @buffer: A #GtkTextBuffer.
*
* Moves the cursor to the beginning of @buffer.
*/
static void
gb_view_source_goto_start (GtkTextBuffer *buffer)
{
GtkTextIter iter;
g_return_if_fail(GTK_IS_TEXT_BUFFER(buffer));
gtk_text_buffer_get_start_iter(buffer, &iter);
gtk_text_buffer_place_cursor(buffer, &iter);
}
/* compose_scroll_to_offset */
void compose_scroll_to_offset(Compose * compose, int offset)
{
GtkTextBuffer * buffer;
GtkTextIter iter;
buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(compose->view));
gtk_text_buffer_get_iter_at_offset(buffer, &iter, offset);
gtk_text_buffer_place_cursor(buffer, &iter);
gtk_text_view_place_cursor_onscreen(GTK_TEXT_VIEW(compose->view));
}
/*
* '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 run_dialog_jump_to(GtkWidget *textview)
{
GtkWidget *dialog;
GtkWidget *button;
GtkWidget *table;
GtkWidget *label;
GtkWidget *spinner;
GtkAdjustment *spinner_adj;
GtkTextIter iter;
gint num, max_num;
GtkTextBuffer *textbuffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(textview));
gtk_text_buffer_get_iter_at_mark(textbuffer, &iter,
gtk_text_buffer_get_insert(textbuffer));
num = gtk_text_iter_get_line(&iter) + 1;
gtk_text_buffer_get_end_iter(textbuffer, &iter);
max_num = gtk_text_iter_get_line(&iter) + 1;
dialog = gtk_dialog_new_with_buttons(_("Jump To"),
GTK_WINDOW(gtk_widget_get_toplevel(textview)),
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
NULL);
gtk_dialog_set_has_separator(GTK_DIALOG(dialog), FALSE);
button = create_button_with_stock_image(_("_Jump"), GTK_STOCK_JUMP_TO);
GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
gtk_dialog_add_action_widget(GTK_DIALOG(dialog), button, GTK_RESPONSE_OK);
table = gtk_table_new(1, 2, FALSE);
gtk_table_set_col_spacings(GTK_TABLE(table), 8);
gtk_container_set_border_width (GTK_CONTAINER(table), 8);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), table, FALSE, FALSE, 0);
label = gtk_label_new_with_mnemonic(_("_Line number:"));
spinner_adj = (GtkAdjustment *) gtk_adjustment_new(num, 1, max_num, 1, 1, 0);
spinner = gtk_spin_button_new(spinner_adj, 1, 0);
gtk_entry_set_width_chars(GTK_ENTRY(spinner), 8);
gtk_label_set_mnemonic_widget(GTK_LABEL(label), spinner);
gtk_entry_set_activates_default(GTK_ENTRY(spinner), TRUE);
gtk_table_attach_defaults(GTK_TABLE(table), label, 0, 1, 0, 1);
gtk_table_attach_defaults(GTK_TABLE(table), spinner, 1, 2, 0, 1);
gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_OK);
gtk_window_set_resizable(GTK_WINDOW(dialog), FALSE);
gtk_widget_show_all(dialog);
if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_OK) {
gtk_text_buffer_get_iter_at_line(textbuffer, &iter,
gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(spinner)) - 1);
gtk_text_buffer_place_cursor(textbuffer, &iter);
// gtk_text_view_scroll_to_iter(GTK_TEXT_VIEW(textview), &iter, 0.1, FALSE, 0.5, 0.5);
scroll_to_cursor(textbuffer, 0.25);
}
gtk_widget_destroy (dialog);
}
static void
hide_search_widget (GeditViewFrame *frame,
gboolean cancel)
{
GtkTextBuffer *buffer;
if (frame->priv->disable_popdown)
{
return;
}
g_signal_handler_block (frame->priv->search_entry,
frame->priv->search_entry_focus_out_id);
if (frame->priv->view_scroll_event_id != 0)
{
g_signal_handler_disconnect (frame->priv->view,
frame->priv->view_scroll_event_id);
frame->priv->view_scroll_event_id = 0;
}
if (frame->priv->typeselect_flush_timeout != 0)
{
g_source_remove (frame->priv->typeselect_flush_timeout);
frame->priv->typeselect_flush_timeout = 0;
}
/* To hide the slider we just set the animation-state property */
g_object_set (G_OBJECT (frame->priv->slider),
"animation-state", GEDIT_THEATRICS_ANIMATION_STATE_INTENDING_TO_GO,
NULL);
if (cancel)
{
GtkTextBuffer *buffer;
GtkTextIter iter;
buffer = GTK_TEXT_BUFFER (gtk_text_view_get_buffer (GTK_TEXT_VIEW (frame->priv->view)));
gtk_text_buffer_get_iter_at_mark (buffer, &iter,
frame->priv->start_mark);
gtk_text_buffer_place_cursor (buffer, &iter);
gedit_view_scroll_to_cursor (GEDIT_VIEW (frame->priv->view));
}
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (frame->priv->view));
gtk_text_buffer_delete_mark (buffer, frame->priv->start_mark);
/* Make sure the view is the one who has the focus when we destroy
the search widget */
gtk_widget_grab_focus (frame->priv->view);
g_signal_handler_unblock (frame->priv->search_entry,
frame->priv->search_entry_focus_out_id);
}
void gTextArea::undo()
{
gTextAreaAction *action;
GtkTextIter start, stop;
if (!_undo_stack)
return;
begin();
_undo_in_progress = true;
action = _undo_stack;
_undo_stack = _undo_stack->next;
action->prev = NULL;
action->next = _redo_stack;
if (_redo_stack)
_redo_stack->prev = action;
_redo_stack = action;
if (action->type == ACTION_INSERT)
{
gtk_text_buffer_get_iter_at_offset(_buffer, &start, action->start);
gtk_text_buffer_get_iter_at_offset(_buffer, &stop, action->start + action->length);
gtk_text_buffer_delete(_buffer, &start, &stop);
gtk_text_buffer_place_cursor(_buffer, &start);
}
else if (action->type == ACTION_DELETE)
{
gtk_text_buffer_get_iter_at_offset(_buffer, &start, action->start);
gtk_text_buffer_insert(_buffer, &start, action->text->str, action->text->len);
gtk_text_buffer_get_iter_at_offset(_buffer, &stop, action->end);
if (action->delete_key_used)
gtk_text_buffer_place_cursor(_buffer, &start);
else
gtk_text_buffer_place_cursor(_buffer, &stop);
}
end();
ensureVisible();
_undo_in_progress = false;
}
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);
}
}
/* Set length to a positive number to enable line input; set to 0 to disable */
void gglk_text_line_input_set(GglkText *tb, int length,
const gunichar *text)
{
GtkTextIter b, e;
gchar *line_utf8;
if(tb->line_maxlen != 0) {
gglk_text_line_input_end(tb);
/* Clear out old text there */
gtk_text_buffer_get_iter_at_mark(tb->buffer, &b, tb->startedit);
gtk_text_buffer_get_iter_at_mark(tb->buffer, &e, tb->endedit);
gtk_text_buffer_delete(tb->buffer, &b, &e);
gtk_text_buffer_get_iter_at_mark(tb->buffer, &tb->iter, tb->startedit);
}
tb->line_maxlen = length;
if(length == 0) {
gglk_text_line_input_end(tb);
return;
}
/* Add new text */
gtk_text_buffer_get_end_iter(tb->buffer, &b);
gtk_text_buffer_move_mark(tb->buffer, tb->startedit, &b);
line_utf8 = g_ucs4_to_utf8(text, -1, NULL, NULL, NULL);
gtk_text_buffer_insert(tb->buffer, &b, line_utf8, -1);
g_free(line_utf8);
/* Extra character at end to maintain editability */
gtk_text_buffer_get_end_iter(tb->buffer, &e);
gtk_text_buffer_insert(tb->buffer, &e, " ", -1);
/* Make editable */
gtk_text_buffer_get_iter_at_mark(tb->buffer, &b, tb->startedit);
gtk_text_buffer_apply_tag_by_name(tb->buffer, "Input", &b, &e);
gtk_text_buffer_apply_tag_by_name(tb->buffer, "editable", &b, &e);
/* Set end mark */
gtk_text_iter_backward_char(&e);
gtk_text_buffer_move_mark(tb->buffer, tb->endedit, &e);
gtk_text_buffer_place_cursor(tb->buffer, &e);
gtk_text_view_scroll_to_mark(GTK_TEXT_VIEW(tb), tb->endedit, 0,FALSE,0,0);
/* Add signals to handle user interaction */
tb->cursor_handler = g_signal_connect(
tb->buffer, "mark-set",
GTK_SIGNAL_FUNC(gglk_text_cursor_event), tb);
tb->update_handler = g_signal_connect(
tb->buffer, "end-user-action",
GTK_SIGNAL_FUNC(gglk_text_update_editable_region), tb);
}
