static gint
_gail_combo_button_release (gpointer data)
{
GtkCombo *combo;
GtkWidget *action_widget;
GdkEvent tmp_event;
GDK_THREADS_ENTER ();
combo = GTK_COMBO (data);
if (combo->current_button == 0)
{
GDK_THREADS_LEAVE ();
return FALSE;
}
tmp_event.button.type = GDK_BUTTON_RELEASE;
tmp_event.button.button = 1;
tmp_event.button.window = combo->list->window;
tmp_event.button.time = GDK_CURRENT_TIME;
gdk_window_set_user_data (combo->list->window, combo->button);
action_widget = combo->list;
gtk_widget_event (action_widget, &tmp_event);
GDK_THREADS_LEAVE ();
return FALSE;
}
static gboolean
idle_do_action (gpointer data)
{
GtkWidget *widget;
GailExpander *gail_expander;
GDK_THREADS_ENTER ();
gail_expander = GAIL_EXPANDER (data);
gail_expander->action_idle_handler = 0;
widget = GTK_ACCESSIBLE (gail_expander)->widget;
if (widget == NULL /* State is defunct */ ||
!GTK_WIDGET_IS_SENSITIVE (widget) || !GTK_WIDGET_VISIBLE (widget))
{
GDK_THREADS_LEAVE ();
return FALSE;
}
gtk_widget_activate (widget);
GDK_THREADS_LEAVE ();
return FALSE;
}
/* Scroll function taken/adapted from gtktreeview.c */
static gint
scroll_row_timeout (gpointer data)
{
GtkTreeView *tree_view = data;
GdkRectangle visible_rect;
gint y, x;
gint offset;
gfloat value;
GtkAdjustment* vadj;
RbTreeDndData *priv_data;
GDK_THREADS_ENTER ();
priv_data = g_object_get_data (G_OBJECT (tree_view), RB_TREE_DND_STRING);
g_return_val_if_fail(priv_data != NULL, TRUE);
gdk_window_get_pointer (gtk_tree_view_get_bin_window (tree_view), &x, &y, NULL);
gtk_tree_view_convert_widget_to_bin_window_coords (tree_view, x, y, &x, &y);
gtk_tree_view_convert_bin_window_to_tree_coords (tree_view, x, y, &x, &y);
gtk_tree_view_get_visible_rect (tree_view, &visible_rect);
/* see if we are near the edge. */
if (x < visible_rect.x && x > visible_rect.x + visible_rect.width)
{
GDK_THREADS_LEAVE ();
priv_data->scroll_timeout = 0;
return FALSE;
}
offset = y - (visible_rect.y + 2 * SCROLL_EDGE_SIZE);
if (offset > 0)
{
offset = y - (visible_rect.y + visible_rect.height - 2 * SCROLL_EDGE_SIZE);
if (offset < 0)
{
GDK_THREADS_LEAVE ();
priv_data->scroll_timeout = 0;
return FALSE;
}
}
vadj = gtk_tree_view_get_vadjustment (tree_view);
value = CLAMP (vadj->value + offset, vadj->lower, vadj->upper - vadj->page_size);
gtk_adjustment_set_value (vadj, value);
/* don't remove it if we're on the edge and not scrolling */
if (ABS (vadj->value - value) > 0.0001)
remove_select_on_drag_timeout(tree_view);
GDK_THREADS_LEAVE ();
return TRUE;
}
gboolean populate_files (gpointer data) //TODO:: show an spinner while loading
{
FilebrowserBackend *filebackend= FILEBROWSER_BACKEND(data);
FilebrowserBackendDetails *directory = FILEBROWSER_BACKEND_GET_PRIVATE(filebackend);
GDK_THREADS_ENTER();
if (g_cancellable_is_cancelled (directory->cancellable)){
GDK_THREADS_LEAVE();
return FALSE; /* remove source */
}
GError *error=NULL;
GFileInfo *info = g_file_enumerator_next_file (directory->enumerator, directory->cancellable, &error);
if (info){
const gchar *mime= g_file_info_get_content_type (info);
if (!g_file_info_get_is_hidden (info) && !g_file_info_get_is_backup (info)){
if (MIME_ISDIR(mime)){
//if has dot in name pos 0 don't process
const gchar *folder=g_file_info_get_display_name(info);
if(folder[0]!='.'){
FOLDERFILE *current;
current=new_folderfile();
current->mime=g_strdup(mime);
GIcon *icon =g_file_info_get_icon(info);
current->icon= g_icon_to_string (icon);
current->display_name=g_strdup(folder);
/* add to list */
directory->filesinfolder = g_slist_append(directory->filesinfolder, current);
}
} else {
if (IS_TEXT(mime) && !IS_APPLICATION(mime)){
//files
FOLDERFILE *current;
current=new_folderfile();
current->mime=g_strdup(mime);
GIcon *icon =g_file_info_get_icon(info);
current->icon= g_icon_to_string (icon);
current->display_name=g_strdup(g_file_info_get_display_name(info));
/* add to list */
directory->filesinfolder = g_slist_append(directory->filesinfolder, current);
}
}
}
g_object_unref(info);
} else {
if (error){
g_print(_("Error::%s"),error->message);
g_error_free (error);
}
GDK_THREADS_LEAVE();
return FALSE; /* remove source */
}
GDK_THREADS_LEAVE();
return TRUE;
}
guint
bst_choice_modal (GtkWidget *choice,
guint mouse_button,
guint32 time)
{
gpointer data = GUINT_TO_POINTER (0);
if (GTK_IS_MENU (choice))
{
GtkMenu *menu = GTK_MENU (choice);
gtk_object_set_data (GTK_OBJECT (menu), "BstChoice", data);
if (bst_choice_selectable (choice))
{
modal_loop_quit_on_menu_item_activate = TRUE;
modal_loop_running = TRUE;
current_popup_menu = GTK_WIDGET (menu);
gtk_menu_popup (menu, NULL, NULL, NULL, NULL, mouse_button, time);
while (modal_loop_running)
{
GDK_THREADS_LEAVE ();
g_main_iteration (TRUE);
GDK_THREADS_ENTER ();
}
current_popup_menu = NULL;
modal_loop_quit_on_menu_item_activate = FALSE;
}
data = gtk_object_get_data (GTK_OBJECT (menu), "BstChoice");
}
else if (GXK_IS_DIALOG (choice))
{
gtk_object_set_data (GTK_OBJECT (choice), "BstChoice", data);
if (bst_choice_selectable (choice))
{
gtk_widget_show (choice);
while (GTK_WIDGET_VISIBLE (choice))
{
GDK_THREADS_LEAVE ();
g_main_iteration (TRUE);
GDK_THREADS_ENTER ();
}
}
data = gtk_object_get_data (GTK_OBJECT (choice), "BstChoice");
}
return GPOINTER_TO_UINT (data);
}
int interface_gtk_start(Playlist *playlist, int argc, char **argv)
{
char path[256];
char *home;
the_coreplayer = playlist->GetCorePlayer();
g_thread_init(NULL);
if (!g_thread_supported()) {
alsaplayer_error("Sorry - this interface requires working threads.\n");
return 1;
}
// Scope functions
scopes = new AlsaSubscriber();
scopes->Subscribe(the_coreplayer->GetNode(), POS_END);
scopes->EnterStream(scope_feeder_func, the_coreplayer);
gtk_set_locale();
gtk_init(&argc, &argv);
gdk_rgb_init();
home = getenv("HOME");
if (home) {
snprintf(path, 255, "%s/.gtkrc", home);
gtk_rc_parse(path);
}
if (playlist->Length())
playlist->UnPause();
// Scope addons
gdk_flush();
GDK_THREADS_ENTER();
init_main_window(playlist);
load_scope_addons();
gdk_flush();
gtk_main();
gdk_flush();
GDK_THREADS_LEAVE();
unload_scope_addons();
destroy_scopes_window();
GDK_THREADS_ENTER();
gdk_flush();
GDK_THREADS_LEAVE();
playlist->Pause();
dl_close_scopes();
return 0;
}
static void the_fftscope(void)
{
guchar *loc;
guchar bits [256 * 129];
int i, h;
running = 1;
while (running) {
guint val;
gint j;
gint k;
memset(bits, 0, 256 * 128);
for (i=0; i < BARS; i++) {
val = 0;
for (j = xranges[i]; j < xranges[i + 1]; j++) {
/* k = (guint)(sqrt(fftout[j]) * fftmult); */
k = (fft_buf[j] + fft_buf[256+j]) / 256;
val += k;
}
if(val > 127) val = 127;
if (val > (guint)maxbar[ i ])
maxbar[ i ] = val;
else {
k = maxbar[ i ] - (4 + (8 / (128 - maxbar[ i ])));
val = k > 0 ? k : 0;
maxbar[ i ] = val;
}
loc = bits + 256 * 128;
for (h = val; h > 0; h--) {
for (j = (256 / BARS) * i + 0; j < (256 / BARS) * i + ((256 / BARS) - 1); j++) {
*(loc + j) = val-h;
}
loc -=256;
}
}
GDK_THREADS_ENTER();
gdk_draw_indexed_image(area->window, area->style->white_gc,
0,0,256,128, GDK_RGB_DITHER_NONE, bits, 256, color_map);
gdk_flush();
GDK_THREADS_LEAVE();
dosleep(SCOPE_SLEEP);
}
GDK_THREADS_ENTER();
fftscope_hide();
GDK_THREADS_LEAVE();
}
static gboolean
xt_event_check (GSource* source_data)
{
GDK_THREADS_ENTER ();
if (xt_event_poll_fd.revents & G_IO_IN) {
int mask;
mask = XPending(xtdisplay);
GDK_THREADS_LEAVE ();
return (gboolean)mask;
}
GDK_THREADS_LEAVE ();
return FALSE;
}
static gint draw_func(gpointer data)
{
gint i;
if(!window)
{
timeout_tag = 0;
return FALSE;
}
GDK_THREADS_ENTER();
gdk_draw_rectangle(draw_pixmap,gc,TRUE,0,0,WIDTH,HEIGHT);
for(i = 0; i < NUM_BANDS; i++)
{
/*if(bar_heights[i] > 4)
bar_heights[i] -= 4;
else
bar_heights[i] = 0;*/
gdk_draw_pixmap(draw_pixmap,gc,bar, 0,HEIGHT - 1 - bar_heights[i], i * (WIDTH / NUM_BANDS), HEIGHT - 1 - bar_heights[i], (WIDTH / NUM_BANDS) - 1, bar_heights[i]);
}
gdk_window_clear(area->window);
GDK_THREADS_LEAVE();
return TRUE;
}
static gboolean
select_on_drag_timeout (gpointer data)
{
GtkTreeView *tree_view = data;
GtkTreeSelection *selection;
RbTreeDndData *priv_data;
GDK_THREADS_ENTER ();
priv_data = g_object_get_data (G_OBJECT (tree_view), RB_TREE_DND_STRING);
g_return_val_if_fail(priv_data != NULL, FALSE);
g_return_val_if_fail(priv_data->previous_dest_path != NULL, FALSE);
selection = gtk_tree_view_get_selection(tree_view);
if (!gtk_tree_selection_path_is_selected(selection,priv_data->previous_dest_path)) {
rb_debug("Changing selection because of drag timeout");
gtk_tree_view_set_cursor(tree_view,priv_data->previous_dest_path,NULL,FALSE);
}
priv_data->select_on_drag_timeout = 0;
gtk_tree_path_free(priv_data->previous_dest_path);
priv_data->previous_dest_path = NULL;
GDK_THREADS_LEAVE ();
return FALSE;
}
static gboolean vfs_mime_type_reload( gpointer user_data )
{
GList* l;
/* FIXME: process mime database reloading properly. */
/* Remove all items in the hash table */
GDK_THREADS_ENTER();
g_static_rw_lock_writer_lock( &mime_hash_lock );
g_hash_table_foreach_remove ( mime_hash, ( GHRFunc ) gtk_true, NULL );
g_static_rw_lock_writer_unlock( &mime_hash_lock );
g_source_remove( reload_callback_id );
reload_callback_id = 0;
/* g_debug( "reload mime-types" ); */
/* call all registered callbacks */
for( l = reload_cb; l; l = l->next )
{
VFSMimeReloadCbEnt* ent = (VFSMimeReloadCbEnt*)l->data;
ent->cb( ent->user_data );
}
GDK_THREADS_LEAVE();
return FALSE;
}
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();
}
static gint clock_timer_callback(gpointer data){
Clock *clock = (Clock *)data;
GDK_THREADS_ENTER ();
clock_gen_str(clock);
GDK_THREADS_LEAVE ();
return TRUE;
}
static gboolean
on_pad_buffer (GstPad *pad,
GstBuffer *buf)
{
gint64 timestamp;
GDK_THREADS_ENTER ();
timestamp = GST_BUFFER_TIMESTAMP (buf);
if (buffer)
gst_buffer_unref (buffer);
buffer = buf;
gst_buffer_ref (buf);
GDK_THREADS_LEAVE ();
if (start_time == 0)
start_time = get_time ();
else {
gint64 time_left = (timestamp / 1000) - (get_time () - start_time);
time_left -= 1000000 / 25;
if (time_left > 2000)
usleep (time_left);
}
return TRUE;
}
static void
thunar_uca_provider_child_watch (GPid pid,
gint status,
gpointer user_data)
{
ThunarUcaProvider *uca_provider = THUNAR_UCA_PROVIDER (user_data);
ThunarVfsMonitor *monitor;
ThunarVfsPath *path;
GDK_THREADS_ENTER ();
/* verify that we still have a valid child_watch_path */
if (G_LIKELY (uca_provider->child_watch_path != NULL))
{
/* determine the corresponding ThunarVfsPath */
path = thunar_vfs_path_new (uca_provider->child_watch_path, NULL);
if (G_LIKELY (path != NULL))
{
/* schedule a changed notification on the path */
monitor = thunar_vfs_monitor_get_default ();
thunar_vfs_monitor_feed (monitor, THUNAR_VFS_MONITOR_EVENT_CHANGED, path);
g_object_unref (G_OBJECT (monitor));
/* release the ThunarVfsPath */
thunar_vfs_path_unref (path);
}
}
/* need to cleanup */
g_spawn_close_pid (pid);
GDK_THREADS_LEAVE ();
}
static gboolean
xt_event_dispatch (GSource* source_data,
GSourceFunc call_back,
gpointer user_data)
{
XEvent event;
XtAppContext ac;
int i = 0;
ac = XtDisplayToApplicationContext(xtdisplay);
GDK_THREADS_ENTER ();
/* Process only real X traffic here. We only look for data on the
* pipe, limit it to XTBIN_MAX_EVENTS and only call
* XtAppProcessEvent so that it will look for X events. There's no
* timer processing here since we already have a timer callback that
* does it. */
for (i=0; i < XTBIN_MAX_EVENTS && XPending(xtdisplay); i++) {
XtAppProcessEvent(ac, XtIMXEvent);
}
GDK_THREADS_LEAVE ();
return TRUE;
}
gboolean on_thumbnail_idle( VFSThumbnailLoader* loader )
{
VFSFileInfo* file;
/* g_debug( "ENTER ON_THUMBNAIL_IDLE" ); */
vfs_async_task_lock( loader->task );
while( ( file = (VFSFileInfo*)g_queue_pop_head(loader->update_queue) ) )
{
GDK_THREADS_ENTER();
vfs_dir_emit_thumbnail_loaded( loader->dir, file );
vfs_file_info_unref( file );
GDK_THREADS_LEAVE();
}
loader->idle_handler = 0;
vfs_async_task_unlock( loader->task );
if( vfs_async_task_is_finished( loader->task ) )
{
/* g_debug( "FREE LOADER IN IDLE HANDLER" ); */
loader->dir->thumbnail_loader = NULL;
vfs_thumbnail_loader_free(loader);
}
/* g_debug( "LEAVE ON_THUMBNAIL_IDLE" ); */
return FALSE;
}
static gboolean
idle_move_item (gpointer data)
{
BstCanvasSource *self = data;
GnomeCanvasItem *item = GNOME_CANVAS_ITEM (self);
GDK_THREADS_ENTER ();
if (self->source && item->canvas)
{
SfiReal x, y;
bse_proxy_get (self->source,
"pos-x", &x,
"pos-y", &y,
NULL);
x *= BST_CANVAS_SOURCE_PIXEL_SCALE;
y *= -BST_CANVAS_SOURCE_PIXEL_SCALE;
gnome_canvas_item_w2i (item, &x, &y);
g_object_freeze_notify (G_OBJECT (self));
gnome_canvas_item_move (item, x, y);
/* canvas notification bug workaround */
g_object_notify (self, "x");
g_object_notify (self, "y");
g_object_thaw_notify (G_OBJECT (self));
}
self->idle_reposition = FALSE;
g_object_unref (self);
GDK_THREADS_LEAVE ();
return FALSE;
}
static void
import_complete_cb (RhythmDBImportJob *job, int total, RBGenericPlayerSource *source)
{
RBGenericPlayerSourceClass *klass = RB_GENERIC_PLAYER_SOURCE_GET_CLASS (source);
RBGenericPlayerSourcePrivate *priv = GET_PRIVATE (source);
RBShell *shell;
GDK_THREADS_ENTER ();
g_object_get (source, "shell", &shell, NULL);
rb_shell_append_display_page (shell, RB_DISPLAY_PAGE (priv->import_errors), RB_DISPLAY_PAGE (source));
g_object_unref (shell);
if (klass->impl_load_playlists)
klass->impl_load_playlists (source);
g_object_unref (priv->import_job);
priv->import_job = NULL;
rb_display_page_notify_status_changed (RB_DISPLAY_PAGE (source));
g_object_set (source, "load-status", RB_SOURCE_LOAD_STATUS_LOADED, NULL);
rb_transfer_target_transfer (RB_TRANSFER_TARGET (source), NULL, FALSE);
GDK_THREADS_LEAVE ();
}
/* This callback is called every 3 seconds */
static int update_timout(batt *b) {
GDK_THREADS_ENTER();
++b->state_elapsed_time;
++b->info_elapsed_time;
/* check the existance of batteries every 3 seconds */
check_batteries( b );
/* check the existance of AC adapter every 3 seconds,
* and update charging state of batteries if needed. */
check_ac_adapter( b );
/* check state of batteries every 30 seconds */
if( b->state_elapsed_time == 30/3 ) /* 30 sec */
{
/* update state of batteries */
g_list_foreach( b->batteries, (GFunc)get_batt_state, &b->use_sysfs );
b->state_elapsed_time = 0;
}
/* check the capacity of batteries every 1 hour */
if( b->info_elapsed_time == 3600/3 ) /* 1 hour */
{
/* update info of batteries */
g_list_foreach( b->batteries, (GFunc)get_batt_info, &b->use_sysfs );
b->info_elapsed_time = 0;
}
update_display( b, TRUE );
GDK_THREADS_LEAVE();
return TRUE;
}
/* This is a one-shot idle callback called from the main loop to call
notify_file_changed() for a thumbnail. It frees the uri afterwards.
We do this in an idle callback as I don't think nautilus_file_changed() is
thread-safe. */
static gboolean
thumbnail_thread_notify_file_changed (gpointer image_uri)
{
NautilusFile *file;
GDK_THREADS_ENTER ();
file = nautilus_file_get_by_uri ((char *) image_uri);
#ifdef DEBUG_THUMBNAILS
g_message ("(Thumbnail Thread) Notifying file changed file:%p uri: %s\n", file, (char*) image_uri);
#endif
if (file != NULL) {
nautilus_file_set_is_thumbnailing (file, FALSE);
nautilus_file_invalidate_attributes (file,
NAUTILUS_FILE_ATTRIBUTE_THUMBNAIL |
NAUTILUS_FILE_ATTRIBUTE_INFO);
nautilus_file_unref (file);
}
g_free (image_uri);
GDK_THREADS_LEAVE ();
return FALSE;
}
int
main (int argc, char **argv)
{
GtkWidget *main_window;
GtkTreeModel *main_model;
GtkTreeIter iter;
RBEntryView *view;
RhythmDB *db;
RhythmDBEntry *entry;
gtk_init (&argc, &argv);
gdk_threads_init ();
rb_thread_helpers_init ();
rb_file_helpers_init (TRUE);
rb_stock_icons_init ();
rb_debug_init (TRUE);
GDK_THREADS_ENTER ();
db = rhythmdb_tree_new ("test");
rhythmdb_write_lock (db);
entry = create_entry (db, "file:///sin.mp3",
"Sin", "Pretty Hate Machine", "Nine Inch Nails", "Rock");
rhythmdb_write_unlock (db);
rhythmdb_read_lock (db);
main_model = GTK_TREE_MODEL (rhythmdb_query_model_new_empty (db));
rhythmdb_do_full_query (db, main_model,
RHYTHMDB_QUERY_PROP_EQUALS,
RHYTHMDB_PROP_TYPE, RHYTHMDB_ENTRY_TYPE_IGNORE,
RHYTHMDB_QUERY_END);
wait_for_model_completion (RHYTHMDB_QUERY_MODEL (main_model));
g_assert (gtk_tree_model_get_iter_first (main_model, &iter));
main_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
view = rb_entry_view_new (db, rb_file ("rb-entry-view-library.xml"));
rb_entry_view_set_query_model (view, RHYTHMDB_QUERY_MODEL (main_model));
gtk_container_add (GTK_CONTAINER (main_window), GTK_WIDGET (view));
g_signal_connect (G_OBJECT (main_window), "destroy",
G_CALLBACK (gtk_main_quit), NULL);
gtk_widget_show_all (GTK_WIDGET (main_window));
gtk_main ();
rhythmdb_shutdown (db);
g_object_unref (G_OBJECT (db));
GDK_THREADS_LEAVE ();
exit (0);
}
static void
thunar_uca_provider_child_watch (ThunarUcaProvider *uca_provider,
gint exit_status)
{
GFileMonitor *monitor;
GFile *file;
g_return_if_fail (THUNAR_UCA_IS_PROVIDER (uca_provider));
GDK_THREADS_ENTER ();
/* verify that we still have a valid child_watch_path */
if (G_LIKELY (uca_provider->child_watch_path != NULL))
{
/* determine the corresponding file */
file = g_file_new_for_path (uca_provider->child_watch_path);
/* schedule a changed notification on the path */
monitor = g_file_monitor (file, G_FILE_MONITOR_NONE, NULL, NULL);
if (monitor != NULL)
{
g_file_monitor_emit_event (monitor, file, file, G_FILE_MONITOR_EVENT_CHANGED);
g_object_unref (monitor);
}
/* release the file */
g_object_unref (file);
}
thunar_uca_provider_child_watch_destroy (uca_provider, NULL);
GDK_THREADS_LEAVE ();
}
static int timeout_func(gpointer data)
{
int pos;
gboolean playing;
static char *previous_file = NULL;
static gboolean cmd_after_already_run = FALSE;
char *current_file;
GDK_THREADS_ENTER();
playing = xmms_remote_is_playing(sc_gp.xmms_session);
pos = xmms_remote_get_playlist_pos(sc_gp.xmms_session);
current_file = xmms_remote_get_playlist_file(sc_gp.xmms_session, pos);
if ((pos != previous_song ||
(!previous_file && current_file) ||
(previous_file && !current_file) ||
(previous_file && current_file &&
strcmp(previous_file, current_file))) &&
xmms_remote_get_output_time(sc_gp.xmms_session) > 0)
{
do_command(cmd_line, current_file, pos);
g_free(previous_file);
previous_file = g_strdup(current_file);
previous_song = pos;
cmd_after_already_run = FALSE;
}
if (!cmd_after_already_run &&
((xmms_remote_get_playlist_time(sc_gp.xmms_session,pos) -
xmms_remote_get_output_time(sc_gp.xmms_session)) < 100))
{
do_command(cmd_line_after, current_file, pos);
cmd_after_already_run = TRUE;
}
if (playing)
{
int playlist_length = xmms_remote_get_playlist_length(sc_gp.xmms_session);
if (pos + 1 == playlist_length)
possible_pl_end = TRUE;
else
possible_pl_end = FALSE;
}
else if (possible_pl_end)
{
if (pos == 0)
do_command(cmd_line_end, current_file, pos);
possible_pl_end = FALSE;
g_free(previous_file);
previous_file = NULL;
}
g_free(current_file);
current_file = NULL;
GDK_THREADS_LEAVE();
return TRUE;
}
static gpointer find_thread_entry( gpointer arg ) {
find_context_t* fc = ( find_context_t* )arg;
find_result_t result;
pdf_tab_t* pdf_tab;
pdf_tab = document_storage_get_tab_by_doc( fc->doc );
if ( pdf_tab == NULL ) {
return NULL;
}
while ( fc->running ) {
g_mutex_lock( &fc->find_lock );
if ( !fc->pending_request ) {
g_cond_wait( &fc->find_cond, &fc->find_lock );
}
fc->pending_request = 0;
g_mutex_unlock( &fc->find_lock );
if ( !fc->running ) {
break;
}
result = find_next( fc );
if ( !fc->running ) {
break;
}
GDK_THREADS_ENTER();
if ( result == FIND_NONE ) {
doctab_set_search_status( pdf_tab, SEARCH_STATUS_NONE );
} else {
if ( result == FIND_OK ) {
doctab_set_search_status( pdf_tab, SEARCH_STATUS_CLEAR );
}
if ( result == FIND_OK_WRAPPED ) {
doctab_set_search_status( pdf_tab, SEARCH_STATUS_WRAPPED );
}
gtk_pdfview_set_highlight(
pdf_tab->pdf_view,
fc->page_index,
( PopplerRectangle* )fc->match->data
);
}
GDK_THREADS_LEAVE();
}
find_context_destroy( fc );
return NULL;
}
static gboolean close_fftscope_window(GtkWidget *widget, GdkEvent *event, gpointer data)
{
GDK_THREADS_LEAVE();
stop_fftscope();
GDK_THREADS_ENTER();
return TRUE;
}
static gboolean
xfce_panel_image_load (gpointer data)
{
XfcePanelImagePrivate *priv = XFCE_PANEL_IMAGE (data)->priv;
GdkPixbuf *pixbuf;
GdkScreen *screen;
GtkIconTheme *icon_theme = NULL;
gint dest_w, dest_h;
GDK_THREADS_ENTER ();
dest_w = priv->width;
dest_h = priv->height;
if (G_UNLIKELY (priv->force_icon_sizes
&& dest_w < 32
&& dest_w == dest_h))
{
/* we use some hardcoded values here for convienence,
* above 32 pixels svg icons will kick in */
if (dest_w > 16 && dest_w < 22)
dest_w = 16;
else if (dest_w > 22 && dest_w < 24)
dest_w = 22;
else if (dest_w > 24 && dest_w < 32)
dest_w = 24;
dest_h = dest_w;
}
if (priv->pixbuf != NULL)
{
/* use the pixbuf set by the user */
pixbuf = g_object_ref (G_OBJECT (priv->pixbuf));
if (G_LIKELY (pixbuf != NULL))
{
/* scale the icon to the correct size */
priv->cache = xfce_panel_image_scale_pixbuf (pixbuf, dest_w, dest_h);
g_object_unref (G_OBJECT (pixbuf));
}
}
else
{
screen = gtk_widget_get_screen (GTK_WIDGET (data));
if (G_LIKELY (screen != NULL))
icon_theme = gtk_icon_theme_get_for_screen (screen);
priv->cache = xfce_panel_pixbuf_from_source_at_size (priv->source, icon_theme, dest_w, dest_h);
}
if (G_LIKELY (priv->cache != NULL))
gtk_widget_queue_draw (GTK_WIDGET (data));
GDK_THREADS_LEAVE ();
return FALSE;
}
static void
canvas_source_set_position (BstCanvasSource *self)
{
gboolean idle_reposition = self->idle_reposition;
GDK_THREADS_LEAVE ();
idle_move_item (g_object_ref (self));
GDK_THREADS_ENTER ();
self->idle_reposition = idle_reposition;
}
static void
nsp_app_feeds_search(void* user_data)
{
NspApp *app = nsp_app_get();
NspFeed *feed = nsp_feed_new();
GtkTreeIter iter;
GRegex *regex;
char *new_feed_title = "Search results";
char *search_exp;
char *tmp;
feed->title = malloc(sizeof(char)*(strlen(new_feed_title) + 1));
memcpy(feed->title, new_feed_title, sizeof(char)*(strlen(new_feed_title)+1));
/* Build search term and load results */
regex = g_regex_new ("(%|_)", 0, 0, NULL);
tmp = g_regex_replace(regex, (char*)user_data, -1, 0, "\\\\\\0", 0, NULL);
g_regex_unref(regex);
regex = g_regex_new ("[ \t]+", 0, 0, NULL);
search_exp = g_regex_replace(regex, tmp, -1, 0, "%", 0, NULL);
g_regex_unref(regex);
g_free(tmp);
feed->items = nsp_feed_items_search(search_exp);
/* Update front-end */
GDK_THREADS_ENTER();
nsp_feed_update_model(feed);
gtk_tree_view_set_model(GTK_TREE_VIEW(app->window->feed_item_list), nsp_feed_get_items_model(feed));
GDK_THREADS_LEAVE();
GDK_THREADS_ENTER();
iter = nsp_feed_list_add(app->window->feed_list, feed, true);
gtk_tree_store_set (GTK_TREE_STORE(app->window->feed_list->list_model), &iter,
LIST_COL_ICON, app->window->feed_list->icon_search,
-1);
app->feeds = g_list_append(app->feeds, feed);
gtk_tree_view_set_cursor(GTK_TREE_VIEW(app->window->feed_list->list_view), gtk_tree_model_get_path(app->window->feed_list->list_model, &iter), NULL, FALSE);
GDK_THREADS_LEAVE();
}
static void on_stop_search( GtkWidget* btn, FindFile* data )
{
if( data->task && ! vfs_async_task_is_finished( data->task ) )
{
// see note in vfs-async-task.c: vfs_async_task_real_cancel()
GDK_THREADS_LEAVE();
vfs_async_task_cancel( data->task );
GDK_THREADS_ENTER();
}
}