void show_selection_ascii(struct selectRange *srange)
{
g_usleep(1);
GDK_THREADS_ENTER();
int start, end;
start = srange->start;
end = srange->end;
GtkTextView *textview3 =
(GtkTextView *) gtk_builder_get_object(builder, "textview3");
GtkTextBuffer *buffer3 =
gtk_text_view_get_buffer(GTK_TEXT_VIEW(textview3));
int line1, line2;
line1 = start / 16;
start = start - 16 * line1;
line2 = end / 16;
end = end - 16 * line2;
GtkTextIter iter1, iter2;
gtk_text_buffer_get_iter_at_line_offset(buffer3, &iter1, line1, start);
gtk_text_buffer_get_iter_at_line_offset(buffer3, &iter2, line2, end);
gtk_text_buffer_select_range(buffer3, &iter1, &iter2);
GDK_THREADS_LEAVE();
}
/* Always process start and end by init_boudaries before */
static GHashTable *
gbp_spell_navigator_count_words (GbpSpellNavigator *self,
GtkTextIter *start,
GtkTextIter *end)
{
GHashTable *table;
GtkSourceRegion *words_count_region;
WordsCountState *state;
GtkTextIter start_subregion;
GtkTextIter end_subregion;
gint line_start;
gint line_end;
gint nb_subregion;
g_assert (GBP_IS_SPELL_NAVIGATOR (self));
g_assert (start != NULL);
g_assert (end != NULL);
words_count_region = gtk_source_region_new (self->buffer);
line_start = gtk_text_iter_get_line (start);
line_end = gtk_text_iter_get_line (end);
nb_subregion = (line_end - line_start + 1) / SPELLCHECKER_SUBREGION_LENGTH;
if (nb_subregion > 1)
{
for (gint i = 0; i < nb_subregion; ++i)
{
line_end = line_start + SPELLCHECKER_SUBREGION_LENGTH - 1;
gtk_text_buffer_get_iter_at_line_offset (self->buffer, &start_subregion, line_start, 0);
gtk_text_buffer_get_iter_at_line_offset (self->buffer, &end_subregion, line_end, 0);
if (!gtk_text_iter_ends_line (&end_subregion))
gtk_text_iter_forward_to_line_end (&end_subregion);
gtk_source_region_add_subregion (words_count_region, &start_subregion, &end_subregion);
line_start = line_end + 1;
}
}
gtk_text_buffer_get_iter_at_line_offset (self->buffer, &start_subregion, line_start, 0);
gtk_source_region_add_subregion (words_count_region, &start_subregion, end);
table = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);
state = g_slice_new0 (WordsCountState);
state->navigator = g_object_ref (self);
state->words_count_region = words_count_region;
gtk_source_region_get_start_region_iter (words_count_region, &state->iter);
g_idle_add_full (G_PRIORITY_LOW,
(GSourceFunc)gbp_spell_navigator_words_count_cb,
state,
(GDestroyNotify)words_count_state_free);
return table;
}
void update_chat_state_message(LinphoneChatMessageState state,LinphoneChatMessage *msg){
GtkWidget *main_window=linphone_gtk_get_main_window();
GtkWidget *friendlist=linphone_gtk_get_widget(main_window,"contact_list");
GtkWidget *page=(GtkWidget*)g_object_get_data(G_OBJECT(friendlist),"chatview");
GHashTable *table=(GHashTable*)g_object_get_data(G_OBJECT(page),"table");
if(page!=NULL){
GtkTextView *text=GTK_TEXT_VIEW(linphone_gtk_get_widget(page,"textview"));
GtkTextBuffer *b=gtk_text_view_get_buffer(text);
GtkTextIter iter;
GtkTextIter end;
GtkTextIter start;
gchar *result;
gint line;
line=GPOINTER_TO_INT(g_hash_table_lookup(table,msg));
gtk_text_buffer_get_iter_at_line(b,&iter,line);
if(gtk_text_iter_get_chars_in_line(&iter) >0) {
gtk_text_buffer_get_iter_at_line_offset(b,&start,line,
gtk_text_iter_get_chars_in_line(&iter)-1);
}else{
gtk_text_buffer_get_iter_at_line_offset(b,&start,line,0);
}
gtk_text_buffer_get_iter_at_line_offset(b,&end,line,0);
gtk_text_buffer_delete(b,&start,&end);
gtk_text_buffer_get_iter_at_line(b,&iter,line);
switch (state) {
case LinphoneChatMessageStateInProgress:
result="Sending ..";
break;
case LinphoneChatMessageStateDelivered:
{
time_t t=time(NULL);
struct tm *tm=localtime(&t);
char buf[80];
strftime(buf,80,"%H:%M",tm);
result=buf;
g_hash_table_remove(table,msg);
break;
}
case LinphoneChatMessageStateNotDelivered:
{
result="Message not sent";
g_hash_table_remove(table,msg);
break;
}
default : result="Sending ..";
}
gtk_text_buffer_insert_with_tags_by_name(b,&iter,result,-1,
"right","small","italic","font_grey","bg",NULL);
g_object_set_data(G_OBJECT(page),"table",table);
}
}
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;
}
}
}
}
}
}
/****** 'text_tags' function *************************************************/
gint text_tags(GtkTextBuffer *buffer, const gchar *text)
{
GtkTextTag *tag;
GtkTextIter start,
match_end,
match_start;
gtk_text_buffer_get_iter_at_line_offset(buffer, &start,
char_line,
char_line_offset);
if(gtk_text_iter_forward_search(&start, text,
GTK_TEXT_SEARCH_CASE_INSENSITIVE,
&match_start, &match_end, NULL))
{
tag = gtk_text_buffer_create_tag(buffer, NULL,
"font", "italic 12",
"weight", 650, "underline",
PANGO_UNDERLINE_SINGLE,
NULL);
gtk_text_buffer_apply_tag(buffer, tag, &match_start, &match_end);
char_line = gtk_text_iter_get_line(&match_end);
char_line_offset = gtk_text_iter_get_line_offset(&match_end);
return 0;
}
else
{
return -1;
}
}
static void
position_restore (Position *pos,
GtkTextBuffer *buffer,
GtkTextIter *iter)
{
gtk_text_buffer_get_iter_at_line_offset (buffer, iter, pos->line, pos->line_offset);
}
/* Removes indent that is mean to be changes and inserts
* tabs and/or spaces insted */
static void
gbp_retab_editor_page_addin_retab (GtkTextBuffer *buffer,
gint line,
gint tab_width,
gint indent,
gboolean to_spaces)
{
g_autoptr(GString) new_indent = g_string_new (NULL);
GtkTextIter iter;
GtkTextIter begin;
GtkTextIter end;
gint tab_num = 0;
gint space_num = 0;
g_assert (GTK_IS_TEXT_BUFFER (buffer));
g_assert (line >= 0 && line < gtk_text_buffer_get_line_count(buffer));
g_assert (tab_width != 0);
g_assert (new_indent != NULL);
gtk_text_buffer_get_iter_at_line (buffer, &iter, line);
while (!gtk_text_iter_ends_line (&iter) &&
g_unichar_isspace(gtk_text_iter_get_char (&iter)))
{
if (gtk_text_iter_get_char (&iter) == ' ')
++space_num;
else if (gtk_text_iter_get_char (&iter) == '\t')
++tab_num;
gtk_text_iter_forward_char (&iter);
}
if (to_spaces)
{
for (gint tab = 0; tab < tab_num * tab_width; ++tab)
g_string_append_c(new_indent, ' ');
for (gint space = 0; space < space_num; ++space)
g_string_append_c(new_indent, ' ');
}
else
{
for (gint tab = 0; tab < tab_num + (space_num / tab_width); ++tab)
g_string_append_c(new_indent, '\t');
for (gint space = 0; space < space_num % tab_width; ++space)
g_string_append_c(new_indent, ' ');
}
gtk_text_buffer_get_iter_at_line(buffer, &begin, line);
gtk_text_buffer_get_iter_at_line_offset (buffer, &end, line, indent);
gtk_text_buffer_delete (buffer, &begin, &end);
if (new_indent->len)
gtk_text_buffer_insert (buffer, &begin, new_indent->str, new_indent->len);
}
CAMLprim value ml_gtk_text_buffer_get_iter_at_line_index(value tb,
value l,
value c)
{
CAMLparam3(tb,l,c);
GtkTextIter res;
gtk_text_buffer_get_iter_at_line_offset(GtkTextBuffer_val(tb),
&res,
Int_val(l),
Int_val(c));
CAMLreturn(Val_GtkTextIter(&res));
}
static void help_window_scroll(GtkWidget *text, const gchar *key)
{
gchar *needle;
GtkTextBuffer *buffer;
GtkTextIter iter;
GtkTextIter start, end;
if (!text || !key) return;
needle = g_strdup_printf("[section:%s]", key);
buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(text));
gtk_text_buffer_get_iter_at_offset(buffer, &iter, 0);
if (gtk_text_iter_forward_search(&iter, needle, GTK_TEXT_SEARCH_TEXT_ONLY,
&start, &end, NULL))
{
gint line;
GtkTextMark *mark;
line = gtk_text_iter_get_line(&start);
gtk_text_buffer_get_iter_at_line_offset(buffer, &iter, line, 0);
gtk_text_buffer_place_cursor(buffer, &iter);
#if 0
gtk_text_view_scroll_to_iter(GTK_TEXT_VIEW(text), &iter, 0.0, TRUE, 0, 0);
#endif
/* apparently only scroll_to_mark works when the textview is not visible yet */
/* if mark exists, move it instead of creating one for every scroll */
mark = gtk_text_buffer_get_mark(buffer, SCROLL_MARKNAME);
if (mark)
{
gtk_text_buffer_move_mark(buffer, mark, &iter);
}
else
{
mark = gtk_text_buffer_create_mark(buffer, SCROLL_MARKNAME, &iter, FALSE);
}
gtk_text_view_scroll_to_mark(GTK_TEXT_VIEW(text), mark, 0.0, TRUE, 0, 0);
}
g_free(needle);
}
/*---------------------------------------------------------------------*/
void
hop_console_adjust() {
GtkAdjustment *adj = gtk_scrolled_window_get_vadjustment( GTK_SCROLLED_WINDOW( console ) );
int count = gtk_text_buffer_get_line_count( console_buffer );
if( count > HOP_CONSOLE_MAX_LINE ) {
GtkTextIter start_del;
GtkTextIter end_del;
int l = count - HOP_CONSOLE_MAX_LINE;
gtk_text_buffer_get_iter_at_offset( console_buffer, &start_del, 0 );
gtk_text_buffer_get_iter_at_line_offset( console_buffer, &end_del, l, 0 );
gtk_text_buffer_delete( console_buffer, &start_del, &end_del );
}
/* gtk_adjustment_set_value( adj, adj->upper ); */
}
gboolean
gedit_document_goto_line_offset (GeditDocument *doc,
gint line,
gint line_offset)
{
GtkTextIter iter;
g_return_val_if_fail (GEDIT_IS_DOCUMENT (doc), FALSE);
g_return_val_if_fail (line >= -1, FALSE);
g_return_val_if_fail (line_offset >= -1, FALSE);
gtk_text_buffer_get_iter_at_line_offset (GTK_TEXT_BUFFER (doc),
&iter,
line,
line_offset);
gtk_text_buffer_place_cursor (GTK_TEXT_BUFFER (doc), &iter);
return (gtk_text_iter_get_line (&iter) == line &&
gtk_text_iter_get_line_offset (&iter) == line_offset);
}
VISIBLE void removeUserMark(const char *umark,unsigned line)
{
pageStruct *page=getPageStructByIDFromPage(-1);
const gchar *mark_type;
GtkTextMark *mark;
GtkTextIter iter;
if(page==NULL)
return;
mark_type=umark;
if(line<0)
{
mark=gtk_text_buffer_get_insert((GtkTextBuffer*)page->buffer);
gtk_text_buffer_get_iter_at_mark((GtkTextBuffer*)page->buffer,&iter,mark);
}
else
{
gtk_text_buffer_get_iter_at_line_offset((GtkTextBuffer*)page->buffer,&iter,line,0);
}
gtk_source_buffer_remove_source_marks(page->buffer,&iter,&iter,mark_type);
}
VISIBLE void setUserMark(const char *mark,unsigned line)
{
pageStruct *page=getPageStructByIDFromPage(-1);
const gchar *mark_type;
GtkTextMark *tmark;
GtkTextIter iter;
if(page==NULL)
return;
mark_type=mark;
if(line<0)
{
tmark=gtk_text_buffer_get_insert((GtkTextBuffer*)page->buffer);
gtk_text_buffer_get_iter_at_mark((GtkTextBuffer*)page->buffer,&iter,tmark);
}
else
{
gtk_text_buffer_get_iter_at_line_offset((GtkTextBuffer*)page->buffer,&iter,line,0);
}
page->userMark=gtk_source_buffer_create_source_mark(page->buffer,NULL,mark_type,&iter);
}
/********** 'set_chord_position' function ************************************/
gint set_chord_position(GtkWidget *t_view, GtkTextBuffer *buffer)
{
GtkTextTag *tag;
GtkTextMark *end_chord,
*start_chord;
GtkTextIter ch,
chord_S,
chord_E,
match_end,
match_start,
start_of_line;
GtkClipboard *clipboard;
gint line_num_1,
line_num_2,
line_count_V,
line_offset_1,
line_offset_2;
line_count_V = gtk_text_buffer_get_line_count(buffer);
clipboard = gtk_clipboard_get(GDK_SELECTION_CLIPBOARD);
gtk_text_buffer_get_start_iter(buffer, &start_of_line);
if(gtk_text_iter_forward_search(&start_of_line, "[", 1,
&match_start, &match_end, NULL))
{
gtk_text_buffer_create_mark(buffer, "start_chord", &match_start, FALSE);
start_chord = gtk_text_buffer_get_mark(buffer, "start_chord");
}
else
{
return -1;
}
if(gtk_text_iter_forward_search(&start_of_line, "]", 1,
&match_start, &match_end, NULL))
{
gtk_text_buffer_create_mark(buffer, "end_chord", &match_end, FALSE);
end_chord = gtk_text_buffer_get_mark(buffer, "end_chord");
}
else
{
return -1;
}
// Initializes iters at mark.
gtk_text_buffer_get_iter_at_mark(buffer, &chord_S, start_chord);
gtk_text_buffer_get_iter_at_mark(buffer, &chord_E, end_chord);
// Get line and line offset of iter. If we just obtain the offset
// within buffer then chord_S will not format as desired.
line_num_1 = gtk_text_iter_get_line(&chord_S);
line_offset_1 = gtk_text_iter_get_line_index(&chord_S);
line_num_2 = gtk_text_iter_get_line(&chord_E);
line_offset_2 = gtk_text_iter_get_line_index(&chord_E);
// This returns with error if end bracket does not have a
// matching start bracket.
if(line_offset_1 > line_offset_2)
{
return -1;
}
//g_print("Lineoffset of start:end bracket:\n%d\n%d\n", line_offset_1, line_offset_2);
// If chord found is found more than two lines down
// refresh global values of 'line_count_C' and 'line_num_C'.
if(line_num_1 > (line_num_C + 1))
{
line_num_C = line_num_1;
line_count_C = line_count_V;
}
// Copy, cut, and add tags to the section between the marks.
gtk_text_buffer_select_range(buffer, &chord_S, &chord_E);
tag = gtk_text_buffer_create_tag(buffer, NULL, "background", "gold",
"weight", "500",
"foreground-gdk", "black3", NULL);
gtk_text_buffer_apply_tag(buffer, tag, &chord_S, &chord_E);
gtk_text_buffer_cut_clipboard(buffer, clipboard, TRUE);
// This finds first chord of line.
if(line_count_V == line_count_C)
{
gtk_text_buffer_get_iter_at_line(buffer, &start_of_line, line_num_1);
gtk_text_buffer_insert(buffer, &start_of_line, "\n", -1);
}
// This finds the rest of the chord_S on the same line as the first.
if(line_num_1 == (line_num_C + 1))
{
line_num_1 = line_num_1 - 1;
line_num_2 = line_num_2 - 1;
}
gtk_text_buffer_get_iter_at_line(buffer, &ch, line_num_1);
// Insert 110 blank spaces so we can insert chord_S at higher offsets than 0.
// GtkTextBuffer does not allow us to insert past a newline character
// so we move it with spaces to allow us to place chord_S at offsets
// past a newline character.
if(gtk_text_iter_get_char(&ch) == '\n')
{
gtk_text_buffer_insert(buffer, &ch,
" ",
-1);
}
// Place iter at the same offset one line above.
gtk_text_buffer_get_iter_at_line_index(buffer, &ch, line_num_1, line_offset_1);
//g_print("Position after cut: %d\n", line_offset_1);
gtk_text_buffer_paste_clipboard(buffer, clipboard, &ch, TRUE);
gtk_text_buffer_get_iter_at_line_offset(buffer, &ch, line_num_1, line_offset_2);
// Deletes the end bracket.
gtk_text_buffer_backspace(buffer, &ch, FALSE, TRUE);
gtk_text_buffer_get_iter_at_line_offset(buffer, &ch, line_num_1, line_offset_1 +1);
// Deletes the start bracket.
gtk_text_buffer_backspace(buffer, &ch, FALSE, TRUE);
gtk_text_buffer_delete_mark_by_name(buffer, "start_chord");
gtk_text_buffer_delete_mark_by_name(buffer, "end_chord");
return 0;
}
/****** 'display function' ***************************************************/
void display(GtkTextBuffer *buffer, GtkWidget *t_view)
{
GtkTextTag *tag;
GtkTextIter end,
start,
match_end,
match_start;
gint i,
j;
gchar *key,
*body,
*title,
*artist;
const gchar *song_section[] = {"Verse:", "Verse 1", "Verse 2:",
"Verse 3:","Bridge:", "Bridge 1:",
"Bridge 2:", "Bridge 3:", "Intro:",
"End:", "PreChorus:", "Verso:",
"Chorus:", "Coro:", "Puente:",
"Key Shift:", "Instrumental:", "Chorus 1:",
"Chorus 2:", "Chorus 3:", "Verso 1:",
"Verso 2:", "Verso 3:", "Tag:"};
//-----------------------------------------------------------------------------
gtk_text_buffer_get_start_iter(buffer, &start);
gtk_text_buffer_get_end_iter(buffer, &end);
gtk_text_buffer_delete(buffer, &start, &end);
gtk_text_view_set_editable(GTK_TEXT_VIEW(t_view), FALSE);
//-----------------------------------------------------------------------------
// Sets attributes for Title (line 0).
title = gtk_editable_get_chars(GTK_EDITABLE(entry_title), 0, -1);
gtk_text_buffer_get_iter_at_line(buffer, &start, 0);
gtk_text_buffer_place_cursor(buffer, &start);
gtk_text_buffer_insert_at_cursor(buffer, title, -1);
g_free(title);
gtk_text_buffer_get_iter_at_line(buffer, &start, 0);
gtk_text_buffer_get_iter_at_line(buffer, &end, 0);
gtk_text_iter_forward_to_line_end(&end);
tag = gtk_text_buffer_create_tag(buffer, NULL, "weight", 1000,
"font", "monospace 30",
"underline", PANGO_UNDERLINE_SINGLE,
NULL);
gtk_text_buffer_apply_tag(buffer, tag, &start, &end);
//-----------------------------------------------------------------------------
// Inserts text 'by:' before artist with attributes.
tag = gtk_text_buffer_create_tag(buffer, NULL, "font",
"monospace 10",
"weight-set", TRUE,
"weight", 650, NULL);
gtk_text_buffer_get_iter_at_line(buffer, &start, 0);
gtk_text_iter_forward_to_line_end(&start);
gtk_text_buffer_place_cursor(buffer, &start);
// Have to insert '\n' to create next line
gtk_text_buffer_insert_at_cursor(buffer, "\n", -1);
gtk_text_buffer_get_iter_at_line(buffer, &start, 1);
gtk_text_buffer_place_cursor(buffer, &start);
gtk_text_buffer_insert_at_cursor(buffer, "Artist: ", -1);
gtk_text_buffer_get_iter_at_line(buffer, &start, 1);
gtk_text_buffer_get_iter_at_line(buffer, &end, 1);
gtk_text_iter_forward_to_line_end(&end);
gtk_text_buffer_apply_tag(buffer, tag, &start, &end);
//-----------------------------------------------------------------------------
artist = gtk_editable_get_chars(GTK_EDITABLE(entry_artist), 0, -1);
gtk_text_buffer_get_iter_at_line_offset(buffer, &start, 1, 8);
gtk_text_buffer_place_cursor(buffer, &start);
gtk_text_buffer_insert_at_cursor(buffer, artist, -1);
g_free(artist);
// Sets attributes for Artist (line 1).
gtk_text_buffer_get_iter_at_line_offset(buffer, &start, 1, 8);
gtk_text_buffer_get_iter_at_line(buffer, &end, 1);
gtk_text_iter_forward_to_line_end(&end);
tag = gtk_text_buffer_create_tag(buffer, NULL, "weight", 500,
"weight-set", TRUE,
"font", "monospace italic 12", NULL);
gtk_text_buffer_apply_tag(buffer, tag, &start, &end);
//-----------------------------------------------------------------------------
tag = gtk_text_buffer_create_tag(buffer, NULL, "font",
"monospace 10",
"weight", 650, NULL);
gtk_text_buffer_get_iter_at_line(buffer, &start, 1);
gtk_text_iter_forward_to_line_end(&start);
gtk_text_buffer_place_cursor(buffer, &start);
// Have to insert '\n' to create next line
gtk_text_buffer_insert_at_cursor(buffer, "\n", -1);
gtk_text_buffer_get_iter_at_line(buffer, &start, 2);
gtk_text_buffer_place_cursor(buffer, &start);
gtk_text_buffer_insert_at_cursor(buffer, "Key: ", -1);
gtk_text_buffer_get_iter_at_line(buffer, &start, 2);
gtk_text_buffer_get_iter_at_line(buffer, &end, 2);
gtk_text_iter_forward_to_line_end(&end);
gtk_text_buffer_apply_tag(buffer, tag, &start, &end);
//-----------------------------------------------------------------------------
key = gtk_editable_get_chars(GTK_EDITABLE(entry_key), 0, -1);
gtk_text_buffer_get_iter_at_line_offset(buffer, &start, 2, 5);
gtk_text_buffer_place_cursor(buffer, &start);
gtk_text_buffer_insert_at_cursor(buffer, key, -1);
g_free(key);
gtk_text_buffer_get_iter_at_line_offset(buffer, &start, 2, 5);
gtk_text_buffer_get_iter_at_line(buffer, &end, 2);
gtk_text_iter_forward_to_line_end(&end);
tag = gtk_text_buffer_create_tag(buffer, NULL, "weight", 500,
"weight-set", TRUE,
"font", "monospace italic 12", NULL);
gtk_text_buffer_apply_tag(buffer, tag, &start, &end);
//-----------------------------------------------------------------------------
gtk_text_buffer_get_iter_at_line(buffer, &start, 2);
gtk_text_iter_forward_to_line_end(&start);
gtk_text_buffer_place_cursor(buffer, &start);
// Have to insert '\n' to create next line
gtk_text_buffer_insert_at_cursor(buffer, "\n\n", -1);
gtk_text_buffer_get_start_iter(t_buffer_editor, &start);
gtk_text_buffer_get_end_iter(t_buffer_editor, &end);
body = gtk_text_buffer_get_text(t_buffer_editor, &start, &end, FALSE);
gtk_text_buffer_get_iter_at_line(buffer, &start, 4);
gtk_text_buffer_place_cursor(buffer, &start);
gtk_text_buffer_insert_at_cursor(buffer, body, -1);
//-----------------------------------------------------------------------------
gtk_text_buffer_get_iter_at_line(buffer, &start, 4);
gtk_text_buffer_get_end_iter(buffer, &end);
tag = gtk_text_buffer_create_tag(buffer, NULL, "font",
"monospace", NULL);
gtk_text_buffer_apply_tag(buffer, tag, &start, &end);
line_count_C = gtk_text_buffer_get_line_count(buffer);
gtk_text_buffer_get_start_iter(buffer, &start);
if(gtk_text_iter_forward_search(&start, "[", 1,
&match_start, &match_end, NULL))
{
line_num_C = gtk_text_iter_get_line(&match_start);
}
for(i = 0; i == 0;)
{
i = set_chord_position(t_view, buffer);
}
//-----------------------------------------------------------------------------
// This section is for setting the attributes of the text
// 'Verse:', 'Chorus:'etc...
char_line = 0;
char_line_offset = 0;
for(i = 0; i < 24;)
{
for(j = 0; j == 0;)
{
j = text_tags(buffer, song_section[i]);
}
if(j != 0)
{
char_line = 0;
char_line_offset = 0;
i++;
}
}
//-----------------------------------------------------------------------------
//g_print("Function return: %d\n", set_chord_position(t_view, buffer));
//g_print("Line number of chord: %d\n", line_num_C);*/
}
void gif_receive_messages(void *server)
{
int server_sockfd = *(int *)server;
gifhdr_t *gifheader;
int rcv_status;
char *gifdata, *gifbuffer;
char PATHNAME[MAX_PATH_LENGTH];
pthread_t pthd = pthread_self();
while(1)
{
gifbuffer = (char *) malloc(BUFF_SIZE);
rcv_status = recv(server_sockfd, gifbuffer, BUFF_SIZE, 0);
if(rcv_status < 0) //发生错误
{
gdk_threads_enter();
message_dialog(GTK_MESSAGE_INFO, strerror(errno));
gdk_threads_leave();
pthread_cancel(pthd); //非正常退出
}
else if(rcv_status == 0) //断开连接
{
contacts_chat_window_id_t *ptr;
GtkWidget *widget;
gdk_threads_enter();
message_dialog(GTK_MESSAGE_INFO, "Server Disconnected");
gdk_threads_leave();
while(head != NULL) // freeing the allocated spaces for linked list
{
ptr = head;
head = head->next;
free(ptr);
}
gdk_threads_enter();
gtk_container_remove(GTK_CONTAINER(scrolledwindow1), tree);
widget = lookup_widget(gifmain, "butConnect");
gtk_widget_set_sensitive(widget, TRUE);
widget = lookup_widget(gifmain, "mnuConnect");
gtk_widget_set_sensitive(widget, TRUE);
widget = lookup_widget(gifmain, "mnuDisconect");
gtk_widget_set_sensitive(widget, FALSE);
widget = lookup_widget(gifmain, "butAdd");
gtk_widget_set_sensitive(widget, FALSE);
widget = lookup_widget(gifmain, "mnuAdd");
gtk_widget_set_sensitive(widget, FALSE);
widget = lookup_widget(gifmain, "mnuDelete");
gtk_widget_set_sensitive(widget, FALSE);
widget = lookup_widget(gifmain, "butConf");
gtk_widget_set_sensitive(widget, FALSE);
widget = lookup_widget(gifmain, "butOffline");
gtk_widget_set_sensitive(widget, FALSE);
widget = lookup_widget(gifmain, "mnuOffline");
gtk_widget_set_sensitive(widget, FALSE);
gdk_threads_leave();
pthread_cancel(pthd);
}
gifheader = (gifhdr_t *) malloc(sizeof(gifhdr_t));
memcpy(gifheader, gifbuffer, HEADER_LENGTH);
if((gifheader->length) > 0)
{
gifdata = (char *) malloc(gifheader->length);
memcpy(gifdata, (gifbuffer + HEADER_LENGTH), gifheader->length);
}
else
{
gifdata = NULL;
}
switch(gifheader->type)
{
case GIF_ADDRLIST_MSG:
{
contacts_chat_window_id_t *ptr;
user_status_t *usrs;
int i, counter;
gdk_threads_enter();
GtkWidget *widget;
GtkTreeStore *store;
GtkTreeViewColumn *column;
GtkCellRenderer *renderer;
GtkTreeIter parent_iter, child_iter;
GdkPixbuf *img;
GtkTreeSelection *select;
gdk_threads_leave();
if(gifheader->reserved == 1)
{
// removing the tree from the container for refresing
gdk_threads_enter();
gtk_container_remove(GTK_CONTAINER(scrolledwindow1), tree);
gdk_threads_leave();
while(head != NULL) // freeing the allocated spaces for linked list
{
ptr = head;
head = head->next;
free(ptr);
}
}
gdk_threads_enter();
widget = lookup_widget(gifmain, "butConnect");
gtk_widget_set_sensitive(widget, FALSE);
widget = lookup_widget(gifmain, "mnuConnect");
gtk_widget_set_sensitive(widget, FALSE);
widget = lookup_widget(gifmain, "mnuDisconect");
gtk_widget_set_sensitive(widget, TRUE);
widget = lookup_widget(gifmain, "butAdd");
gtk_widget_set_sensitive(widget, TRUE);
widget = lookup_widget(gifmain, "mnuAdd");
gtk_widget_set_sensitive(widget, TRUE);
widget = lookup_widget(gifmain, "mnuDelete");
gtk_widget_set_sensitive(widget, TRUE);
widget = lookup_widget(gifmain, "butConf");
gtk_widget_set_sensitive(widget, TRUE);
widget = lookup_widget(gifmain, "butOffline");
gtk_widget_set_sensitive(widget, TRUE);
widget = lookup_widget(gifmain, "mnuOffline");
gtk_widget_set_sensitive(widget, TRUE);
gdk_threads_leave();
//creating a model
gdk_threads_enter();
store = gtk_tree_store_new(2, G_TYPE_STRING, GDK_TYPE_PIXBUF);
gdk_threads_leave();
//creating a view
gdk_threads_enter();
tree = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store));
gdk_threads_leave();
//adding the view to the scrolledwindow
gdk_threads_enter();
gtk_container_add(GTK_CONTAINER(scrolledwindow1), tree);
gdk_threads_leave();
//creating first column
gdk_threads_enter();
renderer = gtk_cell_renderer_pixbuf_new();
column = gtk_tree_view_column_new_with_attributes("Status", renderer, "pixbuf", STATUS_COLUMN_PIXMAP, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column);
gdk_threads_leave();
//creating second column
gdk_threads_enter();
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes("Contacts", renderer, "text", CONTACTS_COLUMN_TEXT, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column);
gdk_threads_leave();
//Acquire a top-level iterator
gdk_threads_enter();
gtk_tree_store_append(store, &parent_iter, NULL);
if(gifheader->length != 0)
{
gtk_tree_store_set(store, &parent_iter, CONTACTS_COLUMN_TEXT, "Available", -1);
}
else
{
gtk_tree_store_set(store, &parent_iter, CONTACTS_COLUMN_TEXT, "Not Available", -1);
}
gdk_threads_leave();
i = counter = 0;
usrs = (user_status_t *) malloc(sizeof(user_status_t));
while(counter < (gifheader->length))
{
contacts_chat_window_id_t *ptr;
memcpy(usrs, (gifdata + (i * sizeof(user_status_t))), sizeof(user_status_t));
// setting the window id for each contacts and constructing a linked list
ptr = (contacts_chat_window_id_t *) malloc(sizeof(contacts_chat_window_id_t));
strcpy(ptr->contacts_name, usrs->loginid);
ptr->window_id = i;
ptr->window_open = 0;
if(head == NULL)
{
head = ptr;
ptr->next = NULL;
}
else
{
ptr->next = head;
head = ptr;
}
// setting the status image for online clients and offline clients
gdk_threads_enter();
if(usrs->status == 1)
{
get_full_path_name(PATHNAME,"ok.png",1,"client/pixmaps");
img = gdk_pixbuf_new_from_file(PATHNAME, NULL);
}
else
{
get_full_path_name(PATHNAME,"kill.png",1,"client/pixmaps");
img = gdk_pixbuf_new_from_file(PATHNAME, NULL);
}
gdk_threads_leave();
//Acquire a child iterator
gdk_threads_enter();
gtk_tree_store_append(store, &child_iter, &parent_iter);
gtk_tree_store_set(store, &child_iter, CONTACTS_COLUMN_TEXT, usrs->loginid, STATUS_COLUMN_PIXMAP, img, -1);
gdk_threads_leave();
i++;
counter = i * sizeof(user_status_t);
}
free(usrs);
gdk_threads_enter();
gtk_tree_view_expand_all(GTK_TREE_VIEW(tree));
gtk_widget_show(tree);
gdk_threads_leave();
// signal handling for "changed" event
gdk_threads_enter();
select = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree));
gtk_tree_selection_set_mode(select, GTK_SELECTION_SINGLE);
g_signal_connect(G_OBJECT(select), "changed", G_CALLBACK(gif_call_client_for_chat), NULL);
gdk_threads_leave();
if((gifheader->length) != 0)
{
free(gifdata);
}
free(gifheader);
free(gifbuffer);
break;
}
case GIF_CHAT_MSG:
{
contacts_chat_window_id_t *ptr;
GtkWidget *display_text;
GtkTextBuffer *buff;
GtkTextIter start, end;
int line_no;
for(ptr = head; ptr != NULL; ptr = ptr->next)
{
if((strcmp(ptr->contacts_name, gifheader->sender)) == 0)
break;
else
continue;
}
if(ptr->window_open == 0)
{
GtkWidget *widget;
GtkTextBuffer *buff;
ptr->window_open = 1; // since the window is gonna be opened
gdk_threads_enter();
chat_window[ptr->window_id] = create_Chat();
widget =
lookup_widget(chat_window[ptr->window_id], "entInput");
gtk_window_set_focus(GTK_WINDOW
(chat_window[ptr->window_id]), widget);
gtk_window_set_title(GTK_WINDOW
(chat_window[ptr->window_id]),
gifheader->sender);
gtk_widget_show(chat_window[ptr->window_id]);
gdk_threads_leave();
// creating tags(foreground color) for the buffer
gdk_threads_enter();
widget =
lookup_widget(chat_window[ptr->window_id], "txtDisplay");
buff = gtk_text_view_get_buffer(GTK_TEXT_VIEW(widget));
gtk_text_buffer_create_tag(buff, "red_foreground",
"foreground", "red", NULL);
gtk_text_buffer_create_tag(buff, "blue_foreground",
"foreground", "blue", NULL);
gdk_threads_leave();
}
gdk_threads_enter();
display_text =
lookup_widget(chat_window[ptr->window_id], "txtDisplay");
buff = gtk_text_view_get_buffer(GTK_TEXT_VIEW(display_text));
gtk_text_buffer_insert_at_cursor(buff, gifheader->sender, -1);
gtk_text_buffer_insert_at_cursor(buff, " : ", -1);
gtk_text_buffer_insert_at_cursor(buff, gifdata, -1);
gdk_threads_leave();
// setting the color(blue) for client's name in the display text box
gdk_threads_enter();
line_no = gtk_text_buffer_get_line_count(buff);
gtk_text_buffer_get_iter_at_line(buff, &start, line_no);
gtk_text_buffer_get_iter_at_line_offset(buff, &end,
line_no,
strlen
(gifheader->sender));
gtk_text_buffer_apply_tag_by_name(buff,
"blue_foreground",
&start, &end);
gtk_text_buffer_insert_at_cursor(buff, "\n", -1);
gdk_threads_leave();
if((gifheader->length) != 0)
free(gifdata);
free(gifheader);
free(gifbuffer);
break;
}
case GIF_SUCCESS_N_ERROR_MSG:
{
switch(gifheader->reserved)
{
case GIF_ERROR_LOGIN_INCORRECT:
{
gdk_threads_enter();
message_dialog(GTK_MESSAGE_INFO, "Login Incorrect");
gdk_threads_leave();
break;
}
case GIF_SUCCESS_ADD_CONTACTS:
{
gdk_threads_enter();
message_dialog(GTK_MESSAGE_INFO, "Your new contact has been successfully added");
gdk_threads_leave();
break;
}
case GIF_ERROR_ADD_CONTACTS:
{
gdk_threads_enter();
message_dialog(GTK_MESSAGE_INFO,"The contact id you entered does not belong to a gchat user");
gdk_threads_leave();
break;
}
case GIF_SUCCESS_DELETE_CONTACTS:
{
gdk_threads_enter();
message_dialog(GTK_MESSAGE_INFO,"Deleted. See the new list after you re-login");
gdk_threads_leave();
break;
}
case GIF_ERROR_DELETE_CONTACTS_NOT_A_CONTACT:
{
gdk_threads_enter();
message_dialog(GTK_MESSAGE_INFO,"1. The id you entered is not in your contact list");
gdk_threads_leave();
break;
}
case GIF_ERROR_DELETE_CONTACTS_NOT_A_MEMBER:
{
gdk_threads_enter();
message_dialog(GTK_MESSAGE_INFO,"2. The id you entered is not in your contact list");
gdk_threads_leave();
break;
}
}
if((gifheader->length) != 0)
{
free(gifdata);
}
free(gifheader);
free(gifbuffer);
break;
}
case GIF_OFFLINE_MSG:
{
int counter;
char *message;
offline_msgs_send_t *omsgs_se;
gdk_threads_enter();
GtkWidget *widget;
GtkListStore *store;
GtkTreeViewColumn *column;
GtkCellRenderer *renderer;
GtkTreeIter iter;
GdkPixbuf *img;
gdk_threads_leave();
if(gifheader->reserved == 1) //刷新联系人在线状态
{
offline_messages_count = 0;
//creating a model
gdk_threads_enter();
store = gtk_list_store_new(OFFLINE_COLUMNS, GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING);
offline_temp_store = store;
gdk_threads_leave();
//creating a view
gdk_threads_enter();
offline_tree = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store));
gdk_threads_leave();
//adding the view to the scrolledwindow
gdk_threads_enter();
gtk_container_add(GTK_CONTAINER(scrolledwindow4), offline_tree);
gdk_threads_leave();
//creating first column
gdk_threads_enter();
renderer = gtk_cell_renderer_pixbuf_new();
column = gtk_tree_view_column_new_with_attributes("New/Old", renderer, "pixbuf", OFFLINE_NEW_PIXMAP, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(offline_tree), column);
gdk_threads_leave();
//creating second column
gdk_threads_enter();
renderer = gtk_cell_renderer_text_new();
g_object_set(G_OBJECT(renderer), "foreground", "red", NULL);
column = gtk_tree_view_column_new_with_attributes("From", renderer, "text", OFFLINE_SENDER_TEXT, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(offline_tree), column);
gdk_threads_leave();
//creating third column
gdk_threads_enter();
renderer = gtk_cell_renderer_text_new();
g_object_set(G_OBJECT(renderer), "foreground", "dark green", NULL);
column = gtk_tree_view_column_new_with_attributes("Date & Time", renderer, "text",OFFLINE_DATESERIAL_TEXT, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(offline_tree), column);
gdk_threads_leave();
//creating fourth column
gdk_threads_enter();
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes("Message", renderer, "text", OFFLINE_MSG_TEXT, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(offline_tree), column);
gdk_threads_leave();
}
else
{
_DEBUG("error: condition");
pthread_cancel(pthd);
return;
}
counter = 0;
omsgs_se =
(offline_msgs_send_t *) malloc(sizeof(offline_msgs_send_t));
while(counter < (gifheader->length))
{
gdk_threads_enter();
widget = lookup_widget(offline, "butOfflineDelete");
gtk_widget_set_sensitive(widget, TRUE);
gdk_threads_leave();
memcpy(omsgs_se, (gifdata + counter),
sizeof(offline_msgs_send_t));
counter = counter + sizeof(offline_msgs_send_t);
message = (char *) malloc(omsgs_se->length);
strncpy(message, (gifdata + counter), omsgs_se->length);
counter = counter + (omsgs_se->length);
// setting the status image for online clients and offline clients
gdk_threads_enter();
if(omsgs_se->new == 1)
{
get_full_path_name(PATHNAME,"ok.png",1,"client/pixmaps");
img = gdk_pixbuf_new_from_file(PATHNAME, NULL);
}
else
{
get_full_path_name(PATHNAME,"kill.png",1,"client/pixmaps");
img = gdk_pixbuf_new_from_file(PATHNAME, NULL);
}
gdk_threads_leave();
//Acquire a child iterator
gdk_threads_enter();
gtk_list_store_append(store, &iter);
gtk_list_store_set(store, &iter,
OFFLINE_NEW_PIXMAP, img,
OFFLINE_SENDER_TEXT,
omsgs_se->sender,
OFFLINE_DATESERIAL_TEXT,
omsgs_se->dateserial,
OFFLINE_MSG_TEXT, message, -1);
gdk_threads_leave();
offline_messages_count++;
free(message);
}
free(omsgs_se);
gdk_threads_enter();
gtk_widget_show(offline_tree);
gdk_threads_leave();
if(gifheader->reserved == 1)
{
GtkTreeSelection *select;
// signal handling for "changed" event
gdk_threads_enter();
select =
gtk_tree_view_get_selection(GTK_TREE_VIEW(offline_tree));
gtk_tree_selection_set_mode(select, GTK_SELECTION_SINGLE);
g_signal_connect(G_OBJECT(select), "changed",
G_CALLBACK
(gif_select_offline_messages), NULL);
gdk_threads_leave();
}
if((gifheader->length) != 0)
free(gifdata);
free(gifheader);
free(gifbuffer);
break;
}
}
}
/* Called only to display details */
static void detail_action(NotifyNotification __unused *notify,
gchar __unused *action, gpointer __unused user_data)
{
GtkWidget *dialog;
GtkWidget *scrollwindow;
GtkWidget *view;
GtkTextBuffer *buffer;
GtkWidget *button_cancel;
GtkWidget *button_send;
GtkTextTag *fixed;
GtkTextIter iter;
char *detail_data;
struct stat statb;
int detail_fd;
int ret;
/* If anything goes wrong, return as early as possible... */
if (!detail_file_name)
return;
memset(&statb, 0, sizeof(statb));
ret = stat(detail_file_name, &statb);
if (statb.st_size < 1 || ret != 0)
return;
detail_fd = open(detail_file_name, O_RDONLY);
if (detail_fd < 0)
return;
detail_data = malloc(statb.st_size+1);
if (!detail_data)
return;
if (read(detail_fd, detail_data, statb.st_size) != statb.st_size) {
free(detail_data);
return;
}
close(detail_fd);
detail_data[statb.st_size] = '\0';
dialog = gtk_dialog_new();
gtk_window_set_title(GTK_WINDOW(dialog), _("Kernel failure details"));
gtk_widget_set_size_request(dialog, 600, 400);
scrollwindow = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW (scrollwindow),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), scrollwindow,
TRUE, TRUE, 0);
view = gtk_text_view_new();
buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW (view));
fixed = gtk_text_buffer_create_tag (buffer, "font", "font", "monospace", NULL);
gtk_text_buffer_get_iter_at_line_offset(buffer, &iter, 0, 0);
gtk_text_buffer_insert_with_tags(buffer, &iter, detail_data, -1,
fixed, NULL);
free(detail_data);
gtk_container_add (GTK_CONTAINER (scrollwindow), view);
gtk_text_view_set_editable(GTK_TEXT_VIEW(view), FALSE);
button_send = gtk_button_new_with_label (_("Send"));
GTK_WIDGET_SET_FLAGS(button_send, GTK_CAN_DEFAULT);
button_cancel = gtk_button_new_with_label (_("Cancel"));
g_signal_connect(G_OBJECT(dialog), "delete_event",
G_CALLBACK(gtk_widget_destroy), dialog);
g_signal_connect_swapped(G_OBJECT(button_cancel), "clicked",
G_CALLBACK(gtk_widget_destroy),
G_OBJECT(dialog));
g_signal_connect(G_OBJECT(button_send), "clicked",
G_CALLBACK(send_action), dialog);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->action_area),
button_send, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->action_area),
button_cancel, TRUE, TRUE, 0);
gtk_widget_grab_default(button_send);
gtk_widget_show(view);
gtk_widget_show(button_send);
gtk_widget_show(button_cancel);
gtk_widget_show(scrollwindow);
gtk_widget_show(dialog);
}
