/* this function will simply add the bookmark as defined in the arguments
*
* will use offset if itoffset is NULL
* will use itoffset if not NULL
*/
static void bmark_add_backend(Tdocument *doc, GtkTextIter *itoffset, gint offset, const gchar *name, const gchar *text, gboolean is_temp) {
Tbmark *m;
gchar *displaytext = NULL;
GtkTextIter it;
m = g_new0(Tbmark, 1);
m->doc = doc;
if (itoffset) {
it = *itoffset;
m->offset = gtk_text_iter_get_offset(&it);
} else {
gtk_text_buffer_get_iter_at_offset(doc->buffer,&it,offset);
m->offset = offset;
}
m->mark = gtk_text_buffer_create_mark(doc->buffer, NULL, &it, TRUE);
m->filepath = g_strdup(doc->filename);
m->is_temp = is_temp;
m->text = g_strdup(text);
m->name = (name) ? g_strdup(name) : g_strdup("");
m->description = g_strdup("");
/* insert into tree */
bmark_get_iter_at_tree_position(doc->bfwin, m);
displaytext = bmark_display_text(m->name, m->text);
gtk_tree_store_set(BFWIN(doc->bfwin)->bookmarkstore, &m->iter, NAME_COLUMN, displaytext, PTR_COLUMN, m, -1);
g_free (displaytext);
/* and store */
if (!m->is_temp) {
bmark_store(BFWIN(doc->bfwin), m);
}
}
void bmark_clean_for_doc(Tdocument * doc) {
GtkTreeIter tmpiter;
gboolean cont;
if (doc->bmark_parent == NULL)
return;
DEBUG_MSG("bmark_clean_for_doc, getting children for parent_iter=%p\n",doc->bmark_parent);
cont =
gtk_tree_model_iter_children(GTK_TREE_MODEL(BFWIN(doc->bfwin)->bookmarkstore), &tmpiter,
doc->bmark_parent);
while (cont) {
Tbmark *b = NULL;
DEBUG_MSG("bmark_clean_for_doc, getting bookmark for first child\n");
gtk_tree_model_get(GTK_TREE_MODEL(BFWIN(doc->bfwin)->bookmarkstore), &tmpiter, PTR_COLUMN,
&b, -1);
if (b) {
bmark_update_offset_from_textmark(b);
DEBUG_MSG("bmark_clean_for_doc, bookmark=%p, new offset=%d, now deleting GtkTextMark from TextBuffer\n",b,b->offset);
gtk_text_buffer_delete_mark(doc->buffer, b->mark);
b->mark = NULL;
b->doc = NULL;
if (!b->is_temp) {
bmark_store(doc->bfwin, b);
}
}
cont = gtk_tree_model_iter_next(GTK_TREE_MODEL(BFWIN(doc->bfwin)->bookmarkstore), &tmpiter);
} /* cont */
/* now unset the Tdocument* in the second column */
DEBUG_MSG("bmark_clean_for_doc, unsetting and freeing parent_iter %p for doc %p\n",doc->bmark_parent,doc);
gtk_tree_store_set(GTK_TREE_STORE(BFWIN(doc->bfwin)->bookmarkstore), doc->bmark_parent, PTR_COLUMN, NULL, -1);
/* remove the pointer from the hastable */
g_hash_table_remove(BFWIN(doc->bfwin)->bmark_files,doc->filename);
g_free(doc->bmark_parent);
doc->bmark_parent = NULL;
}
void bmark_del_at_bevent(Tdocument *doc) {
if (BMARKDATA(main_v->bmarkdata)->bevent_doc == doc) {
Tbmark *b = bmark_get_bmark_at_line(doc, BMARKDATA(main_v->bmarkdata)->bevent_charoffset);
if (b) {
DEBUG_MSG("bmark_del_at_bevent, deleting bookmark %p\n",b);
bmark_check_remove(BFWIN(doc->bfwin),b); /* check if we should remove a filename too */
bmark_unstore(BFWIN(doc->bfwin), b);
bmark_free(b);
}
}
}
/* TODO:
can we make this function faster? when adding bookmarks from a search this function uses
a lot of time, perhaps that can be improved
*/
static Tbmark *bmark_get_bmark_at_line(Tdocument *doc, gint offset) {
GtkTextIter sit, eit;
GtkTreeIter tmpiter;
gint linenum;
gtk_text_buffer_get_iter_at_offset(doc->buffer,&sit,offset);
linenum = gtk_text_iter_get_line(&sit);
eit = sit;
gtk_text_iter_set_line_offset(&sit, 0);
gtk_text_iter_forward_to_line_end(&eit);
#ifdef DEBUG
{
gchar *tmp = gtk_text_buffer_get_text(doc->buffer, &sit,&eit,FALSE);
DEBUG_MSG("bmark_get_bmark_at_line, searching bookmarks at line %d between offsets %d - %d --> '%s'\n",linenum,gtk_text_iter_get_offset(&sit),gtk_text_iter_get_offset(&eit),tmp);
g_free(tmp);
}
#endif
/* check for existing bookmark in this place */
if (DOCUMENT(doc)->bmark_parent) {
GtkTextIter testit;
Tbmark *m, *m2;
m = bmark_find_bookmark_before_offset(BFWIN(doc->bfwin), offset, doc->bmark_parent);
if (m == NULL) {
DEBUG_MSG("bmark_get_bmark_at_line, m=NULL, get first child\n");
if (gtk_tree_model_iter_children(GTK_TREE_MODEL(BFWIN(doc->bfwin)->bookmarkstore), &tmpiter,doc->bmark_parent)) {
gtk_tree_model_get(GTK_TREE_MODEL(BFWIN(doc->bfwin)->bookmarkstore), &tmpiter, PTR_COLUMN, &m2, -1);
gtk_text_buffer_get_iter_at_mark(doc->buffer, &testit,m2->mark);
if (gtk_text_iter_get_line(&testit) == linenum) {
return m2;
}
}
} else {
gtk_text_buffer_get_iter_at_mark(doc->buffer, &testit,m->mark);
DEBUG_MSG("bmark_get_bmark_at_line, m=%p, has linenum=%d\n",m,gtk_text_iter_get_line(&testit));
if (gtk_text_iter_get_line(&testit) == linenum) {
return m;
}
tmpiter = m->iter;
if (gtk_tree_model_iter_next(GTK_TREE_MODEL(BFWIN(doc->bfwin)->bookmarkstore),&tmpiter)) {
gtk_tree_model_get(GTK_TREE_MODEL(BFWIN(doc->bfwin)->bookmarkstore), &tmpiter, PTR_COLUMN, &m2, -1);
gtk_text_buffer_get_iter_at_mark(doc->buffer, &testit,m2->mark);
if (gtk_text_iter_get_line(&testit) == linenum) {
return m2;
}
}
}
DEBUG_MSG("bmark_get_bmark_at_line, nothing found at this line, return NULL\n");
return NULL;
}
DEBUG_MSG("bmark_get_bmark_at_line, no existing bookmark found, return NULL\n");
return NULL;
}
static void bmark_popup_menu_goto_lcb(GtkWidget * widget, gpointer user_data)
{
Tbmark *b;
GtkTextIter it;
if (!user_data)
return;
b = get_current_bmark(BFWIN(user_data));
if (!b)
return;
if (b->filepath && !b->doc) {
/* check if that document _is_ open */
Tdocument *tmpdoc;
GList *doclist = return_allwindows_documentlist();
tmpdoc = documentlist_return_document_from_filename(doclist, b->filepath);
g_list_free(doclist);
if (tmpdoc == NULL) {
if (!g_file_test(b->filepath, G_FILE_TEST_EXISTS)) {
gchar *string = g_strdup_printf(_("Could not find the file \"%s\"."), b->filepath);
error_dialog(BFWIN(user_data)->main_window, string,
_("This bookmark is set in a file that no longer exists."));
g_free(string);
return;
}
tmpdoc = doc_new_with_file(BFWIN(user_data), b->filepath, FALSE, TRUE);
}
/* now I have to check all bookmarks */
bmark_set_for_doc(tmpdoc);
}
if (b->doc) {
GdkRectangle visirect;
GtkTextIter visi_so, visi_eo;
gtk_text_view_get_visible_rect(GTK_TEXT_VIEW(b->doc->view),&visirect);
gtk_text_view_get_iter_at_location(GTK_TEXT_VIEW(b->doc->view), &visi_so, visirect.x, visirect.y);
gtk_text_view_get_iter_at_location(GTK_TEXT_VIEW(b->doc->view), &visi_eo, visirect.x + visirect.width, visirect.y + visirect.height);
gtk_text_buffer_get_iter_at_mark(b->doc->buffer, &it, b->mark);
gtk_text_buffer_place_cursor(b->doc->buffer, &it);
if (!gtk_text_iter_in_range(&it,&visi_so,&visi_eo)) {
DEBUG_MSG("bmark_popup_menu_goto_lcb, cursor NOT visible!\n");
/* gtk_text_view_scroll_mark_onscreen(GTK_TEXT_VIEW(b->doc->view), b->mark); */
gtk_text_view_scroll_to_mark(GTK_TEXT_VIEW(b->doc->view),b->mark,0.0,
TRUE,0.5,0.5);
}
if (b->doc != BFWIN(user_data)->current_document)
switch_to_document_by_pointer(BFWIN(user_data), b->doc);
gtk_widget_grab_focus(b->doc->view);
}
}
void
filter_delete(Tfilter * filter)
{
GList *tmplist;
gchar **strarr;
/* delete from config */
tmplist = g_list_first(main_v->globses.filefilters);
while (tmplist) {
strarr = (gchar **) tmplist->data;
if (strarr && strcmp(strarr[0], filter->name) == 0) {
/* config string found */
main_v->globses.filefilters = g_list_remove(main_v->globses.filefilters, strarr);
break;
}
tmplist = g_list_next(tmplist);
}
/* delete from current list of filters, but we need to
make sure no window is actually using this filter! */
tmplist = g_list_first(main_v->bfwinlist);
while (tmplist) {
Tbfwin *bfwin = BFWIN(tmplist->data);
/* test if the filter is named in the current session */
if (bfwin->session->last_filefilter && strcmp(bfwin->session->last_filefilter, filter->name) == 0) {
g_free(bfwin->session->last_filefilter);
bfwin->session->last_filefilter = NULL;
}
if (bfwin->fb2) {
fb2_unset_filter(bfwin, filter);
}
tmplist = g_list_next(tmplist);
}
/* now really remove the filter */
main_v->filefilters = g_list_remove(main_v->filefilters, filter);
filter_unref(filter);
}
static void
about_options_dialog_create(GtkAction * action, gpointer user_data)
{
GtkWidget *dialog;
gchar *sec_text;
dialog =
gtk_message_dialog_new(GTK_WINDOW(BFWIN(user_data)->main_window), GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_MESSAGE_INFO, GTK_BUTTONS_CLOSE,
#ifdef SVN_REVISION
PACKAGE_STRING " rev" SVN_REVISION);
#else /* SVN_REVISION */
PACKAGE_STRING);
#endif /* SVN_REVISION */
sec_text = g_strconcat(_("This version of Bluefish was built with:\n"), CONFIGURE_OPTIONS, NULL);
gtk_message_dialog_format_secondary_text(GTK_MESSAGE_DIALOG(dialog),
"%s\ngtk %d.%d.%d (runtime gtk %d.%d.%d)\nglib %d.%d.%d (runtime %d.%d.%d)\n"
"with libenchant... %s\nwith libenchant >= 1.4... %s\n"
"with libgucharmap... %s\nwith libgucharmap_2... %s\n"
"with python... %s"
, sec_text
, GTK_MAJOR_VERSION, GTK_MINOR_VERSION, GTK_MICRO_VERSION
, gtk_major_version, gtk_minor_version, gtk_micro_version
, GLIB_MAJOR_VERSION, GLIB_MINOR_VERSION, GLIB_MICRO_VERSION
, glib_major_version, glib_minor_version, glib_micro_version
#ifdef HAVE_LIBENCHANT
, "yes"
#else
, "no"
#endif
#ifdef HAVE_LIBENCHANT_1_4
, "yes"
#else
, "no"
#endif
#ifdef HAVE_LIBGUCHARMAP
, "yes"
#else
, "no"
#endif
#ifdef HAVE_LIBGUCHARMAP_2
, "yes"
#else
, "no"
#endif
#ifdef HAVE_PYTHON
, "yes"
#else
, "no"
#endif
);
g_free(sec_text);
gtk_dialog_run(GTK_DIALOG(dialog));
gtk_widget_destroy(dialog);
}
static void
entity_entity_to_char (GtkAction *action, gpointer user_data)
{
Tbfwin *bfwin = BFWIN(user_data);
Tentitiessession *es;
es = g_hash_table_lookup(entities_v.lookup, bfwin->session);
entity_dialog(bfwin, mode_ent2char, &es->e2c);
}
/**
* bmark_get_bookmarked_lines:
* @doc: Tdocument *
* @ fromit: GtkTextIter *
* @ toit: GtkTextIter *
*
* this function returns a hash table with all bookmarks between fromit and toit
*
* this function is called VERY OFTEN (might be 20X per second!!!!) by document.c
* to redraw the bookmarks at the sides
* so we obviously need to keep this function VERY FAST
*
* the function will return NULL if no bookmarks for this document are
* known (this is faster then looking in an empty hash table)
*
* Return value: #GHashTable * pointer or NULL
*/
GHashTable *bmark_get_bookmarked_lines(Tdocument * doc, GtkTextIter *fromit, GtkTextIter *toit) {
if (doc->bmark_parent) {
gboolean cont = TRUE;
guint offset;
Tbmark *mark;
GtkTreeIter tmpiter;
GHashTable *ret = g_hash_table_new_full(g_int_hash, g_int_equal, g_free, g_free);
/* because the bookmarks are sorted by line number, we don't have to scan trough all
bookmarks, we can start at the bookmark *before* fromit, and continue until the
first bookmark > toit */
offset = gtk_text_iter_get_offset(fromit);
mark = bmark_find_bookmark_before_offset(BFWIN(doc->bfwin), offset, doc->bmark_parent);
if (mark) {
tmpiter = mark->iter;
} else {
cont = gtk_tree_model_iter_children(GTK_TREE_MODEL(BFWIN(doc->bfwin)->bookmarkstore),
&tmpiter, doc->bmark_parent);
}
while (cont) {
Tbmark *mark;
gtk_tree_model_get(GTK_TREE_MODEL(BFWIN(doc->bfwin)->bookmarkstore), &tmpiter, PTR_COLUMN,
&mark, -1);
if (mark && mark->mark) {
GtkTextIter it;
gint *iaux;
gtk_text_buffer_get_iter_at_mark(doc->buffer, &it, mark->mark);
if (gtk_text_iter_compare(toit,&it) < 0) {
break;
} else if (gtk_text_iter_compare(fromit,&it) < 0) {
iaux = g_new(gint, 1);
*iaux = gtk_text_iter_get_line(&it);
g_hash_table_insert(ret, iaux, g_strdup(mark->is_temp ? "1" : "0"));
}
}
cont = gtk_tree_model_iter_next(GTK_TREE_MODEL(BFWIN(doc->bfwin)->bookmarkstore), &tmpiter);
} /* cont */
return ret;
}
return NULL;
}
static void bmark_popup_menu_del_lcb(GtkWidget * widget, gpointer user_data)
{
Tbmark *b;
gint ret;
gchar *pstr;
gchar *btns[] = { GTK_STOCK_NO, GTK_STOCK_YES, NULL };
if (!user_data)
return;
b = get_current_bmark(BFWIN(user_data));
if (!b)
return;
/* check if it is temp mark */
if (b->is_temp) {
/* gtk_tree_store_remove(BFWIN(user_data)->bookmarkstore, &(b->iter)); */
bmark_check_remove(BFWIN(user_data),b); /* check if we should remove a filename too */
/* bmark_unstore(BFWIN(user_data), b); */
bmark_free(b);
} else {
pstr = g_strdup_printf(_("Do you really want to delete %s?"), b->name);
ret =
multi_query_dialog(BFWIN(user_data)->main_window, _("Delete permanent bookmark."), pstr,
0, 0, btns);
g_free(pstr);
if (ret == 0)
return;
bmark_check_remove(BFWIN(user_data),b); /* check if we should remove a filename too */
bmark_unstore(BFWIN(user_data), b);
bmark_free(b);
}
gtk_widget_grab_focus(BFWIN(user_data)->current_document->view);
}
/* when a users want to save the project, it's good to have updated bookmarks
so this function will update all arrays (strarr**)
*/
void bmark_store_all(Tbfwin *bfwin) {
/* we loop over all filename iters, and only for the ones that are opened
we loop over the children (the ones that are not open cannot be changed) */
GtkTreeIter fileit;
gboolean cont;
cont = gtk_tree_model_iter_children(GTK_TREE_MODEL(BFWIN(bfwin)->bookmarkstore), &fileit,NULL);
while (cont) {
Tdocument *doc = NULL;
gtk_tree_model_get(GTK_TREE_MODEL(BFWIN(bfwin)->bookmarkstore), &fileit, PTR_COLUMN,&doc, -1);
if (doc) {
/* the document is open, so the offsets could be changed, store all permanent */
GtkTreeIter bmit;
gboolean cont2 = gtk_tree_model_iter_children(GTK_TREE_MODEL(BFWIN(bfwin)->bookmarkstore), &bmit,&fileit);
DEBUG_MSG("bmark_store_all, storing bookmarks for %s\n",doc->filename);
while (cont2) {
Tbmark *bmark;
gtk_tree_model_get(GTK_TREE_MODEL(BFWIN(bfwin)->bookmarkstore), &bmit, PTR_COLUMN,&bmark, -1);
if (!bmark->is_temp) {
bmark_update_offset_from_textmark(bmark);
bmark_store(bfwin, bmark);
}
cont2 = gtk_tree_model_iter_next(GTK_TREE_MODEL(BFWIN(bfwin)->bookmarkstore), &bmit);
}
} else {
DEBUG_MSG("doc not set, so not open...\n");
}
cont = gtk_tree_model_iter_next(GTK_TREE_MODEL(BFWIN(bfwin)->bookmarkstore), &fileit);
} /* cont */
}
void bmark_add_at_bevent(Tdocument *doc) {
/* check for unnamed document */
if (!doc->filename) {
error_dialog(BFWIN(doc->bfwin)->main_window, _("Add bookmark"),
_("Cannot add bookmarks in unnamed files."));
return;
}
if (BMARKDATA(main_v->bmarkdata)->bevent_doc == doc) {
gint offset = BMARKDATA(main_v->bmarkdata)->bevent_charoffset;
/* we have the location */
/*if (BFWIN(doc->bfwin)->bmark == NULL) {
DEBUG_MSG("adding bookmarks without left panel is not implemented yet\n");
} else */ {
bmark_add_current_doc_backend(doc->bfwin, "", offset, !main_v->props.bookmarks_default_store);
}
}
}
void bmark_check_length(Tbfwin * bfwin, Tdocument * doc) {
GtkTreeIter tmpiter;
gboolean cont;
if (!doc || !doc->bmark_parent) {
DEBUG_MSG("bmark_check_length, no bmark_parent iter => no bookmarks, returning\n");
return;
}
DEBUG_MSG("bmark_check_length, doc %p, filename %s\n\n", doc, doc->filename);
cont =
gtk_tree_model_iter_children(GTK_TREE_MODEL(bfwin->bookmarkstore), &tmpiter,
doc->bmark_parent);
while (cont) {
Tbmark *mark = NULL;
gtk_tree_model_get(GTK_TREE_MODEL(BFWIN(doc->bfwin)->bookmarkstore), &tmpiter, PTR_COLUMN,
&mark, -1);
if (mark) {
glong size;
size = doc->statbuf.st_size;
DEBUG_MSG("bmark_check_length, bmark has %d, file has %ld\n",mark->len, size);
if (mark->len != size) {
gint ret;
gchar *btns[]={GTK_STOCK_NO,GTK_STOCK_YES,NULL};
gchar *str;
str = g_strconcat(_("File size changed in file\n"),doc->filename,NULL);
ret = multi_query_dialog(bfwin->main_window,_("Bookmarks positions could be incorrect. Delete bookmarks?"), str, 0, 0, btns);
if (ret==1) {
bmark_del_for_document(bfwin, doc);
}
return;
}
} else {
DEBUG_MSG("bmark_check_length, NOT GOOD no mark in the treestore??\n");
}
cont = gtk_tree_model_iter_next(GTK_TREE_MODEL(bfwin->bookmarkstore), &tmpiter);
}
DEBUG_MSG("bmark_check_length, all bookmarks OK, returning\n");
}
void bluefish_exit_request() {
GList *tmplist;
gboolean tmpb;
DEBUG_MSG("winefish_exit_request, started\n");
/* if we have modified documents we have to do something, file_close_all_cb()
does exactly want we want to do */
tmplist = return_allwindows_documentlist();
tmpb = (tmplist && test_docs_modified(tmplist));
g_list_free(tmplist);
tmplist = g_list_first(main_v->bfwinlist);
while (tmplist) {
/* if there is a project, we anyway want to save & close the project */
if (BFWIN(tmplist->data)->project) {
if (!project_save_and_close(BFWIN(tmplist->data))) {
/* cancelled or error! */
DEBUG_MSG("winefish_exit_request, project_save_and_close returned FALSE\n");
return;
}
}
if (tmpb) {
file_close_all_cb(NULL, BFWIN(tmplist->data));
}
tmplist = g_list_next(tmplist);
}
/* if we still have modified documents we don't do a thing,
if we don't have them we can quit */
if (tmpb) {
tmplist = return_allwindows_documentlist();
tmpb = (tmplist && test_docs_modified(tmplist));
g_list_free(tmplist);
if (tmpb) {
return;
}
}
/* gtk_widget_hide(main_v->main_window);*/
tmplist = g_list_first(gtk_window_list_toplevels());
gchar *role=NULL;
while (tmplist) {
/* BUG#38 */
if (GTK_IS_WIDGET(tmplist->data)) {
role = g_strdup(gtk_window_get_role ((GtkWindow*)tmplist->data));
gtk_widget_hide(GTK_WIDGET(tmplist->data));
if (role && strncmp(role,"html_dialog",11) ==0) {
window_destroy(GTK_WIDGET(tmplist->data));
}
}
/* g_print("type = %s, role=%s\n", GTK_OBJECT_TYPE_NAME((GtkObject*) tmplist->data), role); */
tmplist = g_list_next(tmplist);
}
g_free(role);
flush_queue();
rcfile_save_all();
{
gchar *filename = g_strconcat(g_get_home_dir(), "/.winefish/dir_history", NULL);
put_stringlist_limited(filename, main_v->recent_directories, main_v->props.max_dir_history);
g_free(filename);
}
gtk_main_quit();
}
static void
lorem_ipsum_command_callback(const gchar * output, gpointer bfwin)
{
if (output)
doc_insert_two_strings(BFWIN(bfwin)->current_document, output, NULL);
}
static void
entity_url_encode (GtkAction *action, gpointer user_data)
{
doc_code_selection(BFWIN(user_data)->current_document, mode_urlencode);
}
/**
* msg_queue_check:
*
* checks the queue for any messages
* this is called by the master program, usually by gtk_timeout_add()
* the messages it will listen to are the types:
* - MSG_QUEUE_ASK_ALIVE - we should respond with a type MSG_QUEUE_SEND_ALIVE
* - MSG_QUEUE_OPENFILE - open a filename
* - MSG_QUEUE_OPENPROJECT - open a filename as project
* - MSG_QUEUE_OPENNEWWIN - open a new window
*/
static gboolean msg_queue_check(gint started_by_gtk_timeout)
{
struct msgbuf {
long mtype;
char mtext[MSQ_QUEUE_SIZE];
} msgp;
gint retval;
if (main_v->bfwinlist == NULL || BFWIN(main_v->bfwinlist->data)->documentlist == NULL) {
DEBUG_MSG("msg_queue_check, no documentlist yet, so we do not continue\n");
return TRUE;
}
if (msg_queue.msgid == -1) {
return FALSE;
}
retval = msgrcv(msg_queue.msgid, &msgp, MSQ_QUEUE_SIZE, -MSG_QUEUE_OPENFILE, IPC_NOWAIT);
if (retval != -1) {
DEBUG_MSG("msg_queue_check, found type %ld\n", msgp.mtype);
if (msgp.mtype == MSG_QUEUE_ASK_ALIVE) {
struct small_msgbuf {
long mtype;
char mtext[MSQ_QUEUE_SMALL_SIZE];
} small_msgp;
DEBUG_MSG("msg_queue_check, a keepalive is asked from %s, sending!\n", msgp.mtext);
small_msgp.mtype = MSG_QUEUE_SEND_ALIVE;
strncpy(small_msgp.mtext, msgp.mtext, MSQ_QUEUE_SMALL_SIZE - 1);
msgsnd(msg_queue.msgid, (void *) &small_msgp, MSQ_QUEUE_SMALL_SIZE * sizeof(char),
IPC_NOWAIT);
} else if (msgp.mtype == MSG_QUEUE_OPENFILE) {
GList *lastlist = g_list_last(main_v->bfwinlist);
gboolean delay_activate = TRUE;
if (g_list_length(BFWIN(lastlist->data)->documentlist) < 2 &&
doc_is_empty_non_modified_and_nameless(BFWIN(lastlist->data)->current_document)) {
delay_activate = FALSE;
}
DEBUG_MSG("msg_queue_check, a filename %s is received\n", msgp.mtext);
if (!doc_new_with_file(BFWIN(lastlist->data),msgp.mtext, delay_activate, FALSE)) {
msg_queue.file_error_list = g_list_append(msg_queue.file_error_list, g_strdup(msgp.mtext));
}
msg_queue_check(0); /* call myself again, there may have been multiple files */
if (started_by_gtk_timeout) {
if (msg_queue.file_error_list) {
gchar *message, *tmp;
tmp = stringlist_to_string(msg_queue.file_error_list, "\n");
free_stringlist(msg_queue.file_error_list);
msg_queue.file_error_list = NULL;
message = g_strconcat(_("These files were not opened:\n"), tmp, NULL);
g_free(tmp);
warning_dialog(BFWIN(main_v->bfwinlist->data)->main_window,_("Unable to open file(s)\n"), message);
g_free(message);
}
/* gtk_notebook_set_page(GTK_NOTEBOOK(main_v->notebook),g_list_length(main_v->documentlist) - 1);
notebook_changed(-1);*/
}
} else if (msgp.mtype == MSG_QUEUE_OPENPROJECT) {
GList *lastlist = g_list_last(main_v->bfwinlist);
DEBUG_MSG("msg_queue_check, a project %s is received\n", msgp.mtext);
project_open_from_file(BFWIN(lastlist->data), msgp.mtext);
msg_queue_check(0); /* call myself again, there may have been multiple projects */
} else if (msgp.mtype == MSG_QUEUE_OPENNEWWIN) {
/* now check if this is indeed send by another process
if the message queue was dead during the startup of this process,
it might be started by this very process */
int otherpid = atoi(msgp.mtext);
DEBUG_MSG("msg_queue_check, a new window is requested by PID=%d\n",otherpid);
if (otherpid != (int) getpid()) {
DEBUG_MSG("msg_queue_check, the PID is not ours, opening new window\n");
gui_new_window(NULL, NULL);
}
}
#ifdef DEBUG
else {
DEBUG_MSG("msg_queue_check, unknown message queue type %ld\n", msgp.mtype);
}
#endif
} else {
#ifdef MSG_QUEUE_DEBUG
DEBUG_MSG("msg_queue_check, found errno(%d)=%s\n", errno, g_strerror(errno));
#endif
/*
43 = Identifier removed
*/
if (errno == 22 || errno == 43) {
DEBUG_MSG("msg_queue_check, re-opening message queue ?!?!?\n");
/* the msg_queue was removed !?!?! */
if (msg_queue_open()) {
DEBUG_MSG("msg_queue_check, another process has opened the message_queue, stopping server\n");
msg_queue.server = FALSE;
return FALSE;
}
}
}
return TRUE;
}
static void
about_dialog_create(GtkAction * action, gpointer user_data)
{
Tbfwin *bfwin = BFWIN(user_data);
GdkPixbuf *logo;
const gchar *artists[] = {
"Dave Lyon",
NULL
};
const gchar *authors[] = {
"Olivier Sessink <*****@*****.**> (Project leader)",
"Andrius <*****@*****.**>",
"Jim Hayward <*****@*****.**>",
"Daniel Leidert <*****@*****.**>",
"Shawn Novak <*****@*****.**>",
"Frédéric Falsetti <*****@*****.**>",
_("\nDevelopers of previous releases:"),
"Alastair Porter <*****@*****.**>",
"Antti-Juhani Kaijanaho",
"Bo Forslund",
"Chris Mazuc",
"Christian Tellefsen <*****@*****.**>",
"David Arno",
"Eugene Morenko <*****@*****.**>",
"Gero Takke",
"Neil Millar",
"Oskar Świda <*****@*****.**>",
"Pablo De Napoli",
"Rasmus Toftdahl Olesen <*****@*****.**>",
"Roland Steinbach <*****@*****.**>",
"Santiago Capel Torres",
"Yanike Mann <*****@*****.**>",
_("\nPackage maintainers:"),
"Debian: Daniel Leidert <*****@*****.**>",
"Fink: Michèle Garoche <*****@*****.**>, Kevin Horton <*****@*****.**>",
"Gentoo: Hanno Böck <*****@*****.**>",
"Mandrake: Todd Lyons <*****@*****.**>",
"Redhat: Matthias Haase <*****@*****.**>",
"Windows: Shawn Novak <*****@*****.**>, Daniel Leidert <*****@*****.**>",
_("\nIf you know of anyone missing from this list,\nplease let us know at:"),
_("[email protected] <*****@*****.**>"),
_("\nThanks to all who helped make this software available.\n"),
NULL
};
const gchar *documenters[] = {
"Scott White <*****@*****.**>",
"Michèle Garoche <*****@*****.**>",
"Anita Lewis <*****@*****.**>",
"Alastair Porter <*****@*****.**>",
"Daniel Blair <*****@*****.**>",
"Olivier Sessink <*****@*****.**>",
"Denny Reeh\n",
NULL
};
const gchar *copyright = "Copyright \xc2\xa9 1998-2015 Olivier Sessink and others.\n";
/* wrap the license here,
* the "wrap-license" property is only available with GTK >= 2.8
*/
const gchar *license =
"This program is free software; you can redistribute it and/or modify it "
"under the terms of the GNU General Public License as published by "
"the Free Software Foundation; either version 3 of the License, or "
"(at your option) any later version.\n"
"\n"
"This program is distributed in the hope that it will be useful, "
"but WITHOUT ANY WARRANTY; without even the implied warranty of "
"MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the "
"GNU General Public License for more details.\n"
"\n"
"You should have received a copy of the GNU General Public License "
"along with this program. If not, see http://www.gnu.org/licenses/ .";
const gchar *comments =
_
("An open-source editor for experienced web designers and programmers, supporting many programming and markup languages, but focusing on creating dynamic and interactive websites.");
/* Translators: This is a special message that shouldn't be translated
* literally. It is used in the about box to give credits to
* the translators.
* Thus, you should translate it to your name and email address and
* the name and email address of all translator who have contributed
* to this translation (in general: this special locale). Please
* use a separate line for every translator ending with a newlines (\n).
*/
const gchar *translator_credits = _("translator-credits");
{
GError *error = NULL;
logo = gdk_pixbuf_new_from_file(BLUEFISH_SPLASH_FILENAME, &error);
if (error) {
g_print("ERROR while loading splash screen: %s\n", error->message);
g_error_free(error);
}
}
#if !GTK_CHECK_VERSION(3, 0, 0)
gtk_about_dialog_set_url_hook(about_activate_url, NULL, NULL);
#endif /* gtk3 */
#ifndef MAC_INTEGRATION
gtk_show_about_dialog(GTK_WINDOW(bfwin->main_window), "logo", logo, "name", PACKAGE,
#ifdef SVN_REVISION
"version", VERSION " rev" SVN_REVISION,
#else /* SVN_REVISION */
"version", VERSION,
#endif /* SVN_REVISION */
"comments", comments,
"copyright", copyright,
"license", license,
"website", "http://bluefish.openoffice.nl",
"authors", authors,
"artists", artists,
"documenters", documenters,
"translator_credits", translator_credits,
"wrap-license", TRUE,
NULL);
if (logo)
g_object_unref(logo);
#else
/* gtk_show_about_dialog hides window when it is closed (no other choices). On OSX this hidden dead window can be accessed from WIndow menu, so we have
to construct about dialog manually and destroy it after use */
GtkWidget *dialog;
dialog = gtk_about_dialog_new();
gtk_window_set_transient_for(GTK_WINDOW( dialog ), GTK_WINDOW(bfwin->main_window));
gtk_window_set_destroy_with_parent (GTK_WINDOW(dialog), TRUE);
g_signal_connect (dialog, "activate-link", G_CALLBACK (activate_link_lcb), NULL);
/* Set it's properties */
gtk_about_dialog_set_program_name(GTK_ABOUT_DIALOG(dialog), "Bluefish" );
gtk_about_dialog_set_version(GTK_ABOUT_DIALOG(dialog),
#ifdef SVN_REVISION
VERSION " rev" SVN_REVISION
#else /* SVN_REVISION */
VERSION
#endif /* SVN_REVISION */
);
gtk_about_dialog_set_copyright(GTK_ABOUT_DIALOG(dialog), copyright);
gtk_about_dialog_set_website(GTK_ABOUT_DIALOG(dialog), "http://bluefish.openoffice.nl" );
gtk_about_dialog_set_authors(GTK_ABOUT_DIALOG(dialog), authors);
gtk_about_dialog_set_artists(GTK_ABOUT_DIALOG(dialog), artists);
gtk_about_dialog_set_documenters(GTK_ABOUT_DIALOG(dialog), documenters);
gtk_about_dialog_set_license(GTK_ABOUT_DIALOG(dialog), license);
gtk_about_dialog_set_comments(GTK_ABOUT_DIALOG(dialog), comments);
gtk_about_dialog_set_translator_credits(GTK_ABOUT_DIALOG(dialog), translator_credits);
gtk_about_dialog_set_wrap_license(GTK_ABOUT_DIALOG(dialog), TRUE);
gtk_about_dialog_set_logo(GTK_ABOUT_DIALOG(dialog), logo);
g_object_unref(logo), logo=NULL;
/* Run dialog and destroy it after it returns. */
gtk_dialog_run( GTK_DIALOG(dialog) );
gtk_widget_destroy(GTK_WIDGET(dialog));
#endif /* MAC_INTEGRATION */
}
/*
* this function will check is this document needs any bookmarks, and set the
* doc->bmark_parent if needed
*/
void bmark_set_for_doc(Tdocument * doc) {
GtkTreeIter tmpiter;
GtkTextIter it;
gboolean cont;
if (!doc->filename) {
DEBUG_MSG("bmark_set_for_doc, document %p does not have a filename, returning\n", doc);
return;
}
DEBUG_MSG("bmark_set_for_doc, doc=%p, filename=%s\n",doc,doc->filename);
/* if (!BFWIN(doc->bfwin)->bmark) {
DEBUG_MSG("bmark_set_for_doc, no leftpanel, not implemented yet!!\n");
return;
}*/
if (doc->bmark_parent) {
DEBUG_MSG("this document (%p) already has a bmark_parent (%p) why is this function called?\n",doc,doc->bmark_parent);
return;
}
cont =
gtk_tree_model_iter_children(GTK_TREE_MODEL(BFWIN(doc->bfwin)->bookmarkstore), &tmpiter,
NULL);
while (cont) {
GtkTreeIter child;
if (gtk_tree_model_iter_children
(GTK_TREE_MODEL(BFWIN(doc->bfwin)->bookmarkstore), &child, &tmpiter)) {
Tbmark *mark = NULL;
gtk_tree_model_get(GTK_TREE_MODEL(BFWIN(doc->bfwin)->bookmarkstore), &child, PTR_COLUMN,
&mark, -1);
if (mark) {
if (strcmp(mark->filepath, doc->filename) == 0) { /* this is it */
gboolean cont2;
DEBUG_MSG("bmark_set_for_doc, we found a bookmark for document %s at offset=%d!\n",doc->filename,mark->offset);
/* we will now first set the Tdocument * into the second column of the parent */
gtk_tree_store_set(GTK_TREE_STORE(BFWIN(doc->bfwin)->bookmarkstore), &tmpiter, PTR_COLUMN, doc, -1);
mark->doc = doc;
gtk_text_buffer_get_iter_at_offset(doc->buffer, &it, mark->offset);
mark->mark = gtk_text_buffer_create_mark(doc->buffer, NULL, &it, TRUE);
cont2 =
gtk_tree_model_iter_next(GTK_TREE_MODEL(BFWIN(doc->bfwin)->bookmarkstore),
&child);
while (cont2) {
mark = NULL;
gtk_tree_model_get(GTK_TREE_MODEL(BFWIN(doc->bfwin)->bookmarkstore), &child,
PTR_COLUMN, &mark, -1);
if (mark) {
mark->doc = doc;
DEBUG_MSG("bmark_set_for_doc, next bookmark at offset=%d!\n",mark->offset);
gtk_text_buffer_get_iter_at_offset(doc->buffer, &it, mark->offset);
mark->mark =
gtk_text_buffer_create_mark(doc->buffer, NULL, &it, TRUE);
}
cont2 =
gtk_tree_model_iter_next(GTK_TREE_MODEL
(BFWIN(doc->bfwin)->bookmarkstore), &child);
}
doc->bmark_parent = g_memdup(&tmpiter, sizeof(GtkTreeIter));
DEBUG_MSG("bmark_set_for_doc, added parent_iter %p to doc %p\n",doc->bmark_parent,doc);
return;
}
}
}
cont = gtk_tree_model_iter_next(GTK_TREE_MODEL(BFWIN(doc->bfwin)->bookmarkstore), &tmpiter);
} /* cont */
DEBUG_MSG("bmark_set_for_doc, no bookmarks found for document %s\n", doc->filename);
}
static void
entity_to_uppercase (GtkAction *action, gpointer user_data)
{
doc_code_selection(BFWIN(user_data)->current_document, mode_touppercase);
}
