gboolean xfce_xsettings_helper_register (XfceXSettingsHelper *helper, GdkDisplay *gdkdisplay, gboolean force_replace) { Display *xdisplay; Window root_window; Window window; gchar atom_name[64]; Atom selection_atom; gint n_screens, n; XfceXSettingsScreen *screen; Time timestamp; XClientMessageEvent xev; gboolean succeed; g_return_val_if_fail (GDK_IS_DISPLAY (gdkdisplay), FALSE); g_return_val_if_fail (XFCE_IS_XSETTINGS_HELPER (helper), FALSE); g_return_val_if_fail (helper->screens == NULL, FALSE); xdisplay = GDK_DISPLAY_XDISPLAY (gdkdisplay); helper->xsettings_atom = XInternAtom (xdisplay, "_XSETTINGS_SETTINGS", False); gdk_error_trap_push (); n_screens = gdk_display_get_n_screens (gdkdisplay); for (n = 0; n < n_screens; n++) { g_snprintf (atom_name, sizeof (atom_name), "_XSETTINGS_S%d", n); selection_atom = XInternAtom (xdisplay, atom_name, False); if (!force_replace && XGetSelectionOwner (xdisplay, selection_atom) != None) { g_message ("Skipping screen %d, it already has an xsettings manager...", n); continue; } succeed = FALSE; /* create new window */ root_window = RootWindow (xdisplay, n); window = XCreateSimpleWindow (xdisplay, root_window, -1, -1, 1, 1, 0, 0, 0); g_assert (window != 0); XSelectInput (xdisplay, window, PropertyChangeMask); /* get the current xserver timestamp */ timestamp = xfce_xsettings_get_server_time (xdisplay, window); /* request ownership of the xsettings selection on this screen */ XSetSelectionOwner (xdisplay, selection_atom, window, timestamp); /* check if the have the selection */ if (G_LIKELY (XGetSelectionOwner (xdisplay, selection_atom) == window)) { /* register this xsettings window for this screen */ xev.type = ClientMessage; xev.window = root_window; xev.message_type = XInternAtom (xdisplay, "MANAGER", True); xev.format = 32; xev.data.l[0] = timestamp; xev.data.l[1] = selection_atom; xev.data.l[2] = window; xev.data.l[3] = 0; /* manager specific data */ xev.data.l[4] = 0; /* manager specific data */ if (XSendEvent (xdisplay, root_window, False, StructureNotifyMask, (XEvent *)&xev) != 0) { /* the window was successfully registered as the new * xsettings window for this screen */ succeed = TRUE; } else { g_warning ("Failed to register the xsettings window for screen %d", n); } } else { g_warning ("Unable to get the xsettings selection for screen %d", n); } if (G_LIKELY (succeed)) { /* add the window to the internal list */ screen = g_slice_new0 (XfceXSettingsScreen); screen->window = window; screen->selection_atom = selection_atom; screen->xdisplay = xdisplay; screen->screen_num = n; xfsettings_dbg (XFSD_DEBUG_XSETTINGS, "%s registered on screen %d", atom_name, n); helper->screens = g_slist_prepend (helper->screens, screen); } else { XDestroyWindow (xdisplay, window); } } if (gdk_error_trap_pop () != 0) g_critical ("Failed to initialize screens"); if (helper->screens != NULL) { /* watch for selection changes */ gdk_window_add_filter (NULL, xfce_xsettings_helper_event_filter, helper); /* send notifications */ xfce_xsettings_helper_notify (helper); xfce_xsettings_helper_notify_xft (helper); /* startup fontconfig monitoring */ helper->fc_init_id = g_idle_add (xfce_xsettings_helper_fc_init, helper); return TRUE; } return FALSE; }
/** * add/register the wire to the nodestore * * @param store * @param wire * @returns TRUE if the wire was added or merged, else FALSE */ gboolean node_store_add_wire (NodeStore *store, Wire *wire) { GList *list; Node *node; int i = 0; g_return_val_if_fail (store, FALSE); g_return_val_if_fail (IS_NODE_STORE (store), FALSE); g_return_val_if_fail (wire, FALSE); g_return_val_if_fail (IS_WIRE (wire), FALSE); // Check for intersection with other wires. for (list = store->wires; list; list = list->next) { g_assert (list->data != NULL); g_assert (IS_WIRE (list->data)); Coords where = {-77.77, -77.77}; Wire *other = list->data; if (do_wires_intersect (wire, other, &where)) { if (is_t_crossing (wire, other, &where) || is_t_crossing (other, wire, &where)) { node = node_store_get_or_create_node (store, where); node_add_wire (node, wire); node_add_wire (node, other); wire_add_node (wire, node); wire_add_node (other, node); NG_DEBUG ("Add wire %p to wire %p @ %lf,%lf.\n", wire, other, where.x, where.y); } else { // magic node removal if a x crossing is overlapped with another wire node = node_store_get_node (store, where); NG_DEBUG ("Nuke that node [ %p ] at coords inbetween", node); if (node) { Coords c[4]; wire_get_start_and_end_pos (other, c + 0, c + 1); wire_get_start_and_end_pos (wire, c + 2, c + 3); if (!coords_equal (&where, c + 0) && !coords_equal (&where, c + 1) && !coords_equal (&where, c + 2) && !coords_equal (&where, c + 3)) { wire_remove_node (wire, node); wire_remove_node (other, node); node_remove_wire (node, wire); node_remove_wire (node, other); } } } } } // Check for overlapping with other wires. do { for (list = store->wires; list; list = list->next) { g_assert (list->data != NULL); g_assert (IS_WIRE (list->data)); Wire *other = list->data; Coords so, eo; const gboolean overlap = do_wires_overlap (wire, other, &so, &eo); NG_DEBUG ("overlap [ %p] and [ %p ] -- %s", wire, other, overlap == TRUE ? "YES" : "NO"); if (overlap) { Node *sn = node_store_get_node (store, eo); Node *en = node_store_get_node (store, so); #if 1 wire = vulcanize_wire (store, wire, other, &so, &eo); node_store_remove_wire (store, g_object_ref (other)); // equiv // wire_unregister // XXX FIXME this // modifies the list // we iterate over! // delay this until idle, so all handlers like adding view // representation are completed so existing wire-items can be deleted // properly // this is not fancy nor nice but seems to work fairly nicly g_idle_add (delayed_wire_delete, other); break; NG_DEBUG ("overlapping of %p with %p ", wire, other); #else if (!sn && !en) { wire = vulcanize_wire (store, wire, other, &so, &eo); } else if (!sn) { NG_DEBUG ("do_something(TM) : %p sn==NULL ", other); } else if (!en) { NG_DEBUG ("do_something(TM) : %p en==NULL ", other); } else { NG_DEBUG ("do_something(TM) : %p else ", other); } #endif } else { NG_DEBUG ("not of %p with %p ", wire, other); } } } while (list); // Check for intersection with parts (pins). for (list = store->parts; list; list = list->next) { g_assert (list->data != NULL); g_assert (IS_PART (list->data)); Coords part_pos; gint num_pins = -1; Part *part = list->data; num_pins = part_get_num_pins (part); item_data_get_pos (ITEM_DATA (part), &part_pos); // Go through all the parts and see which of their // pins that intersect the wire. for (i = 0; i < num_pins; i++) { Pin *pins; Coords lookup_pos; pins = part_get_pins (part); lookup_pos.x = part_pos.x + pins[i].offset.x; lookup_pos.y = part_pos.y + pins[i].offset.y; // If there is a wire at this pin's position, // add it to the return list. if (is_point_on_wire (wire, &lookup_pos)) { Node *node; node = node_store_get_node (store, lookup_pos); if (node != NULL) { // Add the wire to the node (pin) that it intersected. node_add_wire (node, wire); wire_add_node (wire, node); NG_DEBUG ("Add wire %p to pin (node) %p.\n", wire, node); } else { g_warning ("Bug: Found no node at pin at (%g %g).\n", lookup_pos.x, lookup_pos.y); } } } } g_object_set (G_OBJECT (wire), "store", store, NULL); store->wires = g_list_prepend (store->wires, wire); store->items = g_list_prepend (store->items, wire); return TRUE; }
/** * should only be done by VikLayersPanel (hence never used from the background) * need to redraw and record trigger when we make a layer invisible. */ void vik_layer_emit_update_although_invisible ( VikLayer *vl ) { vik_window_set_redraw_trigger(vl); g_idle_add ( (GSourceFunc) idle_draw, vl ); }
static gpointer brasero_dvdcss_write_image_thread (gpointer data) { guchar buf [DVDCSS_BLOCK_SIZE * BRASERO_DVDCSS_I_BLOCKS]; BraseroScrambledSectorRange *range = NULL; BraseroMedium *medium = NULL; BraseroVolFile *files = NULL; dvdcss_handle *handle = NULL; BraseroDrive *drive = NULL; BraseroDvdcssPrivate *priv; gint64 written_sectors = 0; BraseroDvdcss *self = data; BraseroTrack *track = NULL; guint64 remaining_sectors; FILE *output_fd = NULL; BraseroVolSrc *vol; gint64 volume_size; GQueue *map = NULL; brasero_job_set_use_average_rate (BRASERO_JOB (self), TRUE); brasero_job_set_current_action (BRASERO_JOB (self), BRASERO_BURN_ACTION_ANALYSING, _("Retrieving DVD keys"), FALSE); brasero_job_start_progress (BRASERO_JOB (self), FALSE); priv = BRASERO_DVDCSS_PRIVATE (self); /* get the contents of the DVD */ brasero_job_get_current_track (BRASERO_JOB (self), &track); drive = brasero_track_disc_get_drive (BRASERO_TRACK_DISC (track)); vol = brasero_volume_source_open_file (brasero_drive_get_device (drive), &priv->error); files = brasero_volume_get_files (vol, 0, NULL, NULL, NULL, &priv->error); brasero_volume_source_close (vol); if (!files) goto end; medium = brasero_drive_get_medium (drive); brasero_medium_get_data_size (medium, NULL, &volume_size); if (volume_size == -1) { priv->error = g_error_new (BRASERO_BURN_ERROR, BRASERO_BURN_ERROR_GENERAL, _("The size of the volume could not be retrieved")); goto end; } /* create a handle/open DVD */ handle = dvdcss_open (brasero_drive_get_device (drive)); if (!handle) { priv->error = g_error_new (BRASERO_BURN_ERROR, BRASERO_BURN_ERROR_GENERAL, _("Video DVD could not be opened")); goto end; } /* look through the files to get the ranges of encrypted sectors * and cache the CSS keys while at it. */ map = g_queue_new (); if (!brasero_dvdcss_create_scrambled_sectors_map (self, drive, map, handle, files, &priv->error)) goto end; BRASERO_JOB_LOG (self, "DVD map created (keys retrieved)"); g_queue_sort (map, brasero_dvdcss_sort_ranges, NULL); brasero_volume_file_free (files); files = NULL; if (dvdcss_seek (handle, 0, DVDCSS_NOFLAGS) < 0) { BRASERO_JOB_LOG (self, "Error initial seeking"); priv->error = g_error_new (BRASERO_BURN_ERROR, BRASERO_BURN_ERROR_GENERAL, _("Error while reading video DVD (%s)"), dvdcss_error (handle)); goto end; } brasero_job_set_current_action (BRASERO_JOB (self), BRASERO_BURN_ACTION_DRIVE_COPY, _("Copying video DVD"), FALSE); brasero_job_start_progress (BRASERO_JOB (self), TRUE); remaining_sectors = volume_size; range = g_queue_pop_head (map); if (brasero_job_get_fd_out (BRASERO_JOB (self), NULL) != BRASERO_BURN_OK) { gchar *output = NULL; brasero_job_get_image_output (BRASERO_JOB (self), &output, NULL); output_fd = fopen (output, "w"); if (!output_fd) { priv->error = g_error_new_literal (BRASERO_BURN_ERROR, BRASERO_BURN_ERROR_GENERAL, g_strerror (errno)); g_free (output); goto end; } g_free (output); } while (remaining_sectors) { gint flag; guint64 num_blocks, data_size; if (priv->cancel) break; num_blocks = BRASERO_DVDCSS_I_BLOCKS; /* see if we are approaching the end of the dvd */ if (num_blocks > remaining_sectors) num_blocks = remaining_sectors; /* see if we need to update the key */ if (!range || written_sectors < range->start) { /* this is in a non scrambled sectors range */ flag = DVDCSS_NOFLAGS; /* we don't want to mix scrambled and non scrambled sectors */ if (range && written_sectors + num_blocks > range->start) num_blocks = range->start - written_sectors; } else { /* this is in a scrambled sectors range */ flag = DVDCSS_READ_DECRYPT; /* see if we need to update the key */ if (written_sectors == range->start) { int pos; pos = dvdcss_seek (handle, written_sectors, DVDCSS_SEEK_KEY); if (pos < 0) { BRASERO_JOB_LOG (self, "Error seeking"); priv->error = g_error_new (BRASERO_BURN_ERROR, BRASERO_BURN_ERROR_GENERAL, _("Error while reading video DVD (%s)"), dvdcss_error (handle)); break; } } /* we don't want to mix scrambled and non scrambled sectors * NOTE: range->end address is the next non scrambled sector */ if (written_sectors + num_blocks > range->end) num_blocks = range->end - written_sectors; if (written_sectors + num_blocks == range->end) { /* update to get the next range of scrambled sectors */ g_free (range); range = g_queue_pop_head (map); } } num_blocks = dvdcss_read (handle, buf, num_blocks, flag); if (num_blocks < 0) { BRASERO_JOB_LOG (self, "Error reading"); priv->error = g_error_new (BRASERO_BURN_ERROR, BRASERO_BURN_ERROR_GENERAL, _("Error while reading video DVD (%s)"), dvdcss_error (handle)); break; } data_size = num_blocks * DVDCSS_BLOCK_SIZE; if (output_fd) { if (fwrite (buf, 1, data_size, output_fd) != data_size) { int errsv = errno; priv->error = g_error_new (BRASERO_BURN_ERROR, BRASERO_BURN_ERROR_GENERAL, _("Data could not be written (%s)"), g_strerror (errsv)); break; } } else { BraseroBurnResult result; result = brasero_dvdcss_write_sector_to_fd (self, buf, data_size); if (result != BRASERO_BURN_OK) break; } written_sectors += num_blocks; remaining_sectors -= num_blocks; brasero_job_set_written_track (BRASERO_JOB (self), written_sectors * DVDCSS_BLOCK_SIZE); } end: if (range) g_free (range); if (handle) dvdcss_close (handle); if (files) brasero_volume_file_free (files); if (output_fd) fclose (output_fd); if (map) { g_queue_foreach (map, (GFunc) g_free, NULL); g_queue_free (map); } if (!priv->cancel) priv->thread_id = g_idle_add (brasero_dvdcss_thread_finished, self); /* End thread */ g_mutex_lock (priv->mutex); priv->thread = NULL; g_cond_signal (priv->cond); g_mutex_unlock (priv->mutex); g_thread_exit (NULL); return NULL; }
static gpointer dropbox_command_client_thread(DropboxCommandClient *dcc) { struct sockaddr_un addr; socklen_t addr_len; int connection_attempts = 1; /* intialize address structure */ addr.sun_family = AF_UNIX; g_snprintf(addr.sun_path, sizeof(addr.sun_path), "%s/.dropbox/command_socket", g_get_home_dir()); addr_len = sizeof(addr) - sizeof(addr.sun_path) + strlen(addr.sun_path); while (1) { GIOChannel *chan = NULL; GError *gerr = NULL; int sock; gboolean failflag = TRUE; do { int flags; if (0 > (sock = socket(PF_UNIX, SOCK_STREAM, 0))) { /* WTF */ break; } /* set timeout on socket, to protect against bad servers */ { struct timeval tv = {3, 0}; if (0 > setsockopt(sock, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(struct timeval)) || 0 > setsockopt(sock, SOL_SOCKET, SO_SNDTIMEO, &tv, sizeof(struct timeval))) { /* debug("setsockopt failed"); */ break; } } /* set native non-blocking, for connect timeout */ { if ((flags = fcntl(sock, F_GETFL, 0)) < 0 || fcntl(sock, F_SETFL, flags | O_NONBLOCK) < 0) { /* debug("fcntl failed"); */ break; } } /* if there was an error we have to try again later */ if (connect(sock, (struct sockaddr *) &addr, addr_len) < 0) { if (errno == EINPROGRESS) { fd_set writers; struct timeval tv = {1, 0}; FD_ZERO(&writers); FD_SET(sock, &writers); /* if nothing was ready after 3 seconds, fail out homie */ if (select(sock+1, NULL, &writers, NULL, &tv) == 0) { /* debug("connection timeout"); */ break; } if (connect(sock, (struct sockaddr *) &addr, addr_len) < 0) { /* debug("couldn't connect to command server after 1 second"); */ break; } } /* errno != EINPROGRESS */ else { /* debug("bad connection"); */ break; } } /* set back to blocking */ if (fcntl(sock, F_SETFL, flags) < 0) { /* debug("fcntl2 failed"); */ break; } failflag = FALSE; } while (0); if (failflag) { ConnectionAttempt *ca = g_new(ConnectionAttempt, 1); ca->dcc = dcc; ca->connect_attempt = connection_attempts; g_idle_add((GSourceFunc) on_connection_attempt, ca); if (sock >= 0) { close(sock); } g_usleep(G_USEC_PER_SEC); connection_attempts++; continue; } else { connection_attempts = 0; } /* connected */ debug("command client connected"); chan = g_io_channel_unix_new(sock); g_io_channel_set_close_on_unref(chan, TRUE); g_io_channel_set_line_term(chan, "\n", -1); #define SET_CONNECTED_STATE(s) { \ g_mutex_lock(dcc->command_connected_mutex); \ dcc->command_connected = s; \ g_mutex_unlock(dcc->command_connected_mutex); \ } SET_CONNECTED_STATE(TRUE); g_idle_add((GSourceFunc) on_connect, dcc); while (1) { DropboxCommand *dc; while (1) { GTimeVal gtv; g_get_current_time(>v); g_time_val_add(>v, G_USEC_PER_SEC / 10); /* get a request from caja */ dc = g_async_queue_timed_pop(dcc->command_queue, >v); if (dc != NULL) { break; } else { if (check_connection(chan) == FALSE) { goto BADCONNECTION; } } } /* this pointer should be unique */ if ((gpointer (*)(DropboxCommandClient *data)) dc == &dropbox_command_client_thread) { debug("got a reset request"); goto BADCONNECTION; } switch (dc->request_type) { case GET_FILE_INFO: { debug("doing file info command"); do_file_info_command(chan, (DropboxFileInfoCommand *) dc, &gerr); } break; case GENERAL_COMMAND: { debug("doing general command"); do_general_command(chan, (DropboxGeneralCommand *) dc, &gerr); } break; default: g_assert_not_reached(); break; } debug("done."); if (gerr != NULL) { // debug("COMMAND ERROR*****************************"); /* mark this request as never to be completed */ end_request(dc); debug("command error: %s", gerr->message); g_error_free(gerr); BADCONNECTION: /* grab all the rest of the data off the async queue and mark it never to be completed, who knows how long we'll be disconnected */ while ((dc = g_async_queue_try_pop(dcc->command_queue)) != NULL) { end_request(dc); } g_io_channel_unref(chan); SET_CONNECTED_STATE(FALSE); /* call the disconnect handler */ g_idle_add((GSourceFunc) on_disconnect, dcc); break; } } #undef SET_CONNECTED_STATE } return NULL; }
void quit() { g_idle_add(do_quit, NULL); }
/* video_start */ static void _video_start(VideoPhonePlugin * video) { if(video->source != 0) return; video->source = g_idle_add(_video_on_open, video); }
static void cpufreq_applet_update_visibility (CPUFreqApplet *applet) { CPUFreqShowMode show_mode; CPUFreqShowTextMode show_text_mode; gboolean show_freq = FALSE; gboolean show_perc = FALSE; gboolean show_unit = FALSE; gboolean show_icon = FALSE; gboolean changed = FALSE; gboolean need_update = FALSE; show_mode = cpufreq_prefs_get_show_mode (applet->prefs); show_text_mode = cpufreq_prefs_get_show_text_mode (applet->prefs); if (show_mode != CPUFREQ_MODE_GRAPHIC) { show_icon = (show_mode == CPUFREQ_MODE_BOTH); switch (show_text_mode) { case CPUFREQ_MODE_TEXT_FREQUENCY: show_freq = TRUE; break; case CPUFREQ_MODE_TEXT_PERCENTAGE: show_perc = TRUE; break; case CPUFREQ_MODE_TEXT_FREQUENCY_UNIT: show_freq = TRUE; show_unit = TRUE; break; } } else { show_icon = TRUE; } if (applet->show_mode != show_mode) { applet->show_mode = show_mode; need_update = TRUE; } if (applet->show_text_mode != show_text_mode) { applet->show_text_mode = show_text_mode; need_update = TRUE; } if (show_freq != applet->show_freq) { applet->show_freq = show_freq; changed = TRUE; } if (show_perc != applet->show_perc) { applet->show_perc = show_perc; changed = TRUE; } if (changed) { g_object_set (G_OBJECT (applet->label), "visible", applet->show_freq || applet->show_perc, NULL); } if (show_unit != applet->show_unit) { applet->show_unit = show_unit; changed = TRUE; g_object_set (G_OBJECT (applet->unit_label), "visible", applet->show_unit, NULL); } if (show_icon != applet->show_icon) { applet->show_icon = show_icon; changed = TRUE; g_object_set (G_OBJECT (applet->icon), "visible", applet->show_icon, NULL); } if (changed) g_idle_add ((GSourceFunc)refresh_cb, applet); if (need_update) cpufreq_applet_update (applet, applet->monitor); }
static void port_event(LV2UI_Handle handle, uint32_t port_index, uint32_t buffer_size, uint32_t format, const void* buffer) { DrMrPortIndex index = (DrMrPortIndex)port_index; DrMrUi* ui = (DrMrUi*)handle; if (index == DRMR_KITNUM) { if (format != 0) fprintf(stderr,"Invalid format for kitnum: %i\n",format); else { int kit = (int)(*((float*)buffer)); ui->kitReq = kit; if (!idle) { idle = TRUE; g_idle_add(kit_callback,ui); } } } else if (index == DRMR_BASENOTE) { int base = (int)(*((float*)buffer)); if (base >= 21 && base <= 107) { setBaseLabel((int)base); gtk_spin_button_set_value(ui->base_spin,base); gtk_label_set_markup(ui->base_label,baseLabelBuf); } } else if (index == DRMR_IGNORE_VELOCITY) { int ig = (int)(*((float*)buffer)); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(ui->velocity_checkbox), ig?TRUE:FALSE); } else if (index == DRMR_IGNORE_NOTE_OFF) { int ig = (int)(*((float*)buffer)); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(ui->note_off_checkbox), ig?TRUE:FALSE); } else if (index >= DRMR_GAIN_ONE && index <= DRMR_GAIN_THIRTYTWO) { float gain = *(float*)buffer; int idx = index-DRMR_GAIN_ONE; ui->gain_vals[idx] = gain; if (idx < ui->samples && ui->gain_sliders) { struct slider_callback_data* data = malloc(sizeof(struct slider_callback_data)); data->range = GTK_RANGE(ui->gain_sliders[idx]); data->val = gain; g_idle_add(slider_callback,data); //GtkRange* range = GTK_RANGE(ui->gain_sliders[idx]); //gtk_range_set_value(range,gain); } } else if (index >= DRMR_PAN_ONE && index <= DRMR_PAN_THIRTYTWO) { float pan = *(float*)buffer; int idx = index-DRMR_PAN_ONE; ui->pan_vals[idx] = pan; if (idx < ui->samples && ui->pan_sliders) { struct slider_callback_data* data = malloc(sizeof(struct slider_callback_data)); data->range = GTK_RANGE(ui->pan_sliders[idx]); data->val = pan; g_idle_add(slider_callback,data); } } }
/** * Initializes libnotify if it's not already * initialized. */ void init_libnotify() { if (!notify_is_initted()) if (!notify_init(PACKAGE)) g_idle_add(idle_report_error, NULL); }
static inline void queue_dispatch(DBusConnection *conn, DBusDispatchStatus status) { if (status == DBUS_DISPATCH_DATA_REMAINS) g_idle_add(message_dispatch, dbus_connection_ref(conn)); }
static void transfer_batch_complete_cb (RBTrackTransferBatch *batch, RBMediaPlayerSource *source) { rb_debug ("finished transferring files to the device"); g_idle_add ((GSourceFunc) sync_idle_cb_playlists, source); }
/* coroutine context */ static void *spice_channel_coroutine(void *data) { SpiceChannel *channel = SPICE_CHANNEL(data); spice_channel *c = channel->priv; int ret; guint verify; SPICE_DEBUG("Started background coroutine %p", &c->coroutine); if (spice_session_get_client_provided_socket(c->session)) { if (c->fd < 0) { g_critical("fd not provided!"); goto cleanup; } if (!(c->sock = g_socket_new_from_fd(c->fd, NULL))) { SPICE_DEBUG("Failed to open socket from fd %d", c->fd); return FALSE; } g_socket_set_blocking(c->sock, FALSE); goto connected; } reconnect: c->sock = spice_session_channel_open_host(c->session, c->tls); if (c->sock == NULL) { if (!c->tls) { SPICE_DEBUG("connection failed, trying with TLS port"); c->tls = true; /* FIXME: does that really work with provided fd */ goto reconnect; } else { SPICE_DEBUG("Connect error"); emit_main_context(channel, SPICE_CHANNEL_EVENT, SPICE_CHANNEL_ERROR_CONNECT); goto cleanup; } } c->has_error = FALSE; if (c->tls) { int rc; c->ctx = SSL_CTX_new(TLSv1_method()); if (c->ctx == NULL) { g_critical("SSL_CTX_new failed"); goto cleanup; } verify = spice_session_get_verify(c->session); if (verify & (SPICE_SESSION_VERIFY_PUBKEY | SPICE_SESSION_VERIFY_HOSTNAME)) { gchar *ca_file; g_object_get(c->session, "ca-file", &ca_file, NULL); if (ca_file) { rc = SSL_CTX_load_verify_locations(c->ctx, ca_file, NULL); if (rc != 1) g_warning("loading ca certs from %s failed", ca_file); g_free(ca_file); if (rc != 1) { if (verify & SPICE_SESSION_VERIFY_PUBKEY) { g_warning("only pubkey active"); verify = SPICE_SESSION_VERIFY_PUBKEY; } else goto cleanup; } } } c->ssl = SSL_new(c->ctx); if (c->ssl == NULL) { g_critical("SSL_new failed"); goto cleanup; } rc = SSL_set_fd(c->ssl, g_socket_get_fd(c->sock)); if (rc <= 0) { g_critical("SSL_set_fd failed"); goto cleanup; } { gchar *hostname, *subject; guint8 *pubkey; guint pubkey_len; g_object_get(c->session, "host", &hostname, "cert-subject", &subject, NULL); spice_session_get_pubkey(c->session, &pubkey, &pubkey_len); c->sslverify = spice_openssl_verify_new(c->ssl, verify, hostname, (char*)pubkey, pubkey_len, subject); g_free(hostname); g_free(subject); } ssl_reconnect: rc = SSL_connect(c->ssl); if (rc <= 0) { rc = SSL_get_error(c->ssl, rc); if (rc == SSL_ERROR_WANT_READ || rc == SSL_ERROR_WANT_WRITE) { g_io_wait(c->sock, G_IO_OUT|G_IO_ERR|G_IO_HUP); goto ssl_reconnect; } else { g_warning("%s: SSL_connect: %s", c->name, ERR_error_string(rc, NULL)); emit_main_context(channel, SPICE_CHANNEL_EVENT, SPICE_CHANNEL_ERROR_TLS); goto cleanup; } } } connected: c->state = SPICE_CHANNEL_STATE_LINK_HDR; spice_channel_send_link(channel); while ((ret = spice_channel_iterate(channel))) ; /* TODO: improve it, this is a bit hairy, c->coroutine will be overwritten on (re)connect, so we skip the normal cleanup path. Ideally, we shouldn't use the same channel structure? */ if (c->state == SPICE_CHANNEL_STATE_CONNECTING) { g_object_unref(channel); goto end; } cleanup: SPICE_DEBUG("Coroutine exit"); SPICE_CHANNEL_GET_CLASS(channel)->channel_disconnect(channel); g_idle_add(spice_channel_delayed_unref, data); end: /* Co-routine exits now - the SpiceChannel object may no longer exist, so don't do anything else now unless you like SEGVs */ exit(1); return NULL; }
static void xfce_xsettings_helper_prop_changed (XfconfChannel *channel, const gchar *prop_name, const GValue *value, XfceXSettingsHelper *helper) { XfceXSetting *setting; g_return_if_fail (helper->channel == channel); xfsettings_dbg_filtered (XFSD_DEBUG_XSETTINGS, "prop \"%s\" changed (type=%s)", prop_name, G_VALUE_TYPE_NAME (value)); if (G_LIKELY (value != NULL)) { setting = g_hash_table_lookup (helper->settings, prop_name); if (G_LIKELY (setting != NULL)) { /* update the value, assuming the types match because * you cannot changes types in xfconf without removing * it first */ g_value_reset (setting->value); g_value_copy (value, setting->value); /* update the serial */ setting->last_change_serial = helper->serial; } else if (xfce_xsettings_helper_prop_valid (prop_name, value)) { /* insert a new setting */ setting = g_slice_new0 (XfceXSetting); setting->value = g_new0 (GValue, 1); setting->last_change_serial = helper->serial; g_value_init (setting->value, G_VALUE_TYPE (value)); g_value_copy (value, setting->value); g_hash_table_insert (helper->settings, g_strdup (prop_name), setting); } else { /* leave, so not notification is scheduled */ return; } } else { /* maybe the value is not found, because we haven't * checked if the property is valid, but that's not * a problem */ g_hash_table_remove (helper->settings, prop_name); } if (helper->notify_idle_id == 0) { /* schedule an update */ helper->notify_idle_id = g_idle_add (xfce_xsettings_helper_notify_idle, helper); } if (helper->notify_xft_idle_id == 0 && (g_str_has_prefix (prop_name, "/Xft/") || g_str_has_prefix (prop_name, "/Gtk/CursorTheme"))) { helper->notify_xft_idle_id = g_idle_add (xfce_xsettings_helper_notify_xft_idle, helper); } }
void add_separator(int menu_id) { MenuItemInfo *mii = malloc(sizeof(MenuItemInfo)); mii->menu_id = menu_id; g_idle_add(do_add_separator, mii); }
static int _copy(Prefs * prefs, unsigned int filec, char * filev[]) { static Copy copy; GtkWidget * vbox; GtkWidget * hbox; GtkSizeGroup * left; GtkSizeGroup * right; GtkWidget * widget; PangoFontDescription * bold; if(filec < 2 || filev == NULL) return 1; /* FIXME report error */ copy.prefs = prefs; copy.filec = filec; copy.filev = filev; copy.cur = 0; /* graphical interface */ copy.window = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_icon_name(GTK_WINDOW(copy.window), "stock_copy"); gtk_window_set_resizable(GTK_WINDOW(copy.window), FALSE); gtk_window_set_title(GTK_WINDOW(copy.window), _("Copy file(s)")); g_signal_connect(G_OBJECT(copy.window), "delete-event", G_CALLBACK( _copy_on_closex), NULL); vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 4); left = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL); right = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL); /* current argument */ hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 4); widget = gtk_label_new(_("Copying: ")); bold = pango_font_description_new(); pango_font_description_set_weight(bold, PANGO_WEIGHT_BOLD); #if GTK_CHECK_VERSION(3, 0, 0) gtk_widget_override_font(widget, bold); g_object_set(widget, "halign", GTK_ALIGN_START, NULL); #else gtk_widget_modify_font(widget, bold); gtk_misc_set_alignment(GTK_MISC(widget), 0.0, 0.5); #endif gtk_size_group_add_widget(left, widget); gtk_box_pack_start(GTK_BOX(hbox), widget, FALSE, TRUE, 0); copy.filename = gtk_entry_new(); gtk_editable_set_editable(GTK_EDITABLE(copy.filename), FALSE); gtk_size_group_add_widget(right, copy.filename); gtk_box_pack_start(GTK_BOX(hbox), copy.filename, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(vbox), hbox, TRUE, TRUE, 0); /* progress bar */ copy.progress = gtk_progress_bar_new(); #if GTK_CHECK_VERSION(3, 0, 0) gtk_progress_bar_set_show_text(GTK_PROGRESS_BAR(copy.progress), TRUE); #endif gtk_progress_bar_set_text(GTK_PROGRESS_BAR(copy.progress), ""); gtk_box_pack_start(GTK_BOX(vbox), copy.progress, TRUE, TRUE, 0); /* file copy */ hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 4); widget = gtk_label_new(_("Filename: ")); #if GTK_CHECK_VERSION(3, 0, 0) gtk_widget_override_font(widget, bold); g_object_set(widget, "halign", GTK_ALIGN_START, NULL); #else gtk_widget_modify_font(widget, bold); gtk_misc_set_alignment(GTK_MISC(widget), 0.0, 0.5); #endif gtk_size_group_add_widget(left, widget); gtk_box_pack_start(GTK_BOX(hbox), widget, FALSE, TRUE, 0); copy.flabel = gtk_label_new(""); gtk_label_set_ellipsize(GTK_LABEL(copy.flabel), PANGO_ELLIPSIZE_START); gtk_label_set_width_chars(GTK_LABEL(copy.flabel), 25); #if GTK_CHECK_VERSION(3, 0, 0) g_object_set(copy.flabel, "halign", GTK_ALIGN_START, NULL); #else gtk_misc_set_alignment(GTK_MISC(copy.flabel), 0.0, 0.5); #endif gtk_size_group_add_widget(right, copy.flabel); gtk_box_pack_start(GTK_BOX(hbox), copy.flabel, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(vbox), hbox, TRUE, TRUE, 0); /* file copy speed */ hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 4); widget = gtk_label_new(_("Copied: ")); #if GTK_CHECK_VERSION(3, 0, 0) gtk_widget_override_font(widget, bold); g_object_set(widget, "halign", GTK_ALIGN_START, NULL); #else gtk_widget_modify_font(widget, bold); gtk_misc_set_alignment(GTK_MISC(widget), 0.0, 0.5); #endif gtk_size_group_add_widget(left, widget); gtk_box_pack_start(GTK_BOX(hbox), widget, FALSE, TRUE, 0); copy.fspeed = gtk_label_new(""); #if GTK_CHECK_VERSION(3, 0, 0) g_object_set(copy.fspeed, "halign", GTK_ALIGN_START, NULL); #else gtk_misc_set_alignment(GTK_MISC(copy.fspeed), 0.0, 0.5); #endif gtk_size_group_add_widget(right, copy.fspeed); gtk_box_pack_start(GTK_BOX(hbox), copy.fspeed, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(vbox), hbox, TRUE, TRUE, 0); /* file copy remaining */ hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 4); widget = gtk_label_new(_("Remaining: ")); #if GTK_CHECK_VERSION(3, 0, 0) gtk_widget_override_font(widget, bold); g_object_set(widget, "halign", GTK_ALIGN_START, NULL); #else gtk_widget_modify_font(widget, bold); gtk_misc_set_alignment(GTK_MISC(widget), 0.0, 0.5); #endif gtk_size_group_add_widget(left, widget); gtk_box_pack_start(GTK_BOX(hbox), widget, FALSE, TRUE, 0); copy.fremaining = gtk_label_new(""); #if GTK_CHECK_VERSION(3, 0, 0) g_object_set(copy.fremaining, "halign", GTK_ALIGN_START, NULL); #else gtk_misc_set_alignment(GTK_MISC(copy.fremaining), 0.0, 0.5); #endif gtk_size_group_add_widget(right, copy.fremaining); gtk_box_pack_start(GTK_BOX(hbox), copy.fremaining, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(vbox), hbox, TRUE, TRUE, 0); /* file progress bar */ copy.fprogress = gtk_progress_bar_new(); #if GTK_CHECK_VERSION(3, 0, 0) gtk_progress_bar_set_show_text(GTK_PROGRESS_BAR(copy.fprogress), TRUE); #endif gtk_progress_bar_set_text(GTK_PROGRESS_BAR(copy.fprogress), ""); gtk_box_pack_start(GTK_BOX(vbox), copy.fprogress, TRUE, TRUE, 0); hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 4); widget = gtk_button_new_from_stock(GTK_STOCK_CANCEL); g_signal_connect_swapped(G_OBJECT(widget), "clicked", G_CALLBACK( _copy_on_cancel), NULL); gtk_box_pack_end(GTK_BOX(hbox), widget, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, TRUE, 0); gtk_container_set_border_width(GTK_CONTAINER(copy.window), 4); gtk_container_add(GTK_CONTAINER(copy.window), vbox); g_idle_add(_copy_idle_first, ©); _copy_refresh(©); gtk_widget_show_all(copy.window); pango_font_description_free(bold); return 0; }
void show_menu_item(int menu_id) { MenuItemInfo *mii = malloc(sizeof(MenuItemInfo)); mii->menu_id = menu_id; g_idle_add(do_show_menu_item, mii); }
int main ( int argc, char *argv[] ) { TIMINGS_START (); cmd_set_arguments ( argc, argv ); // Version if ( find_arg ( "-v" ) >= 0 || find_arg ( "-version" ) >= 0 ) { #ifdef GIT_VERSION fprintf ( stdout, "Version: "GIT_VERSION "\n" ); #else fprintf ( stdout, "Version: "VERSION "\n" ); #endif exit ( EXIT_SUCCESS ); } // Detect if we are in dmenu mode. // This has two possible causes. // 1 the user specifies it on the command-line. if ( find_arg ( "-dmenu" ) >= 0 ) { dmenu_mode = TRUE; } // 2 the binary that executed is called dmenu (e.g. symlink to rofi) else{ // Get the base name of the executable called. char *base_name = g_path_get_basename ( argv[0] ); const char * const dmenu_str = "dmenu"; dmenu_mode = ( strcmp ( base_name, dmenu_str ) == 0 ); // Free the basename for dmenu detection. g_free ( base_name ); } TICK (); // Get the path to the cache dir. cache_dir = g_get_user_cache_dir (); // Create pid file path. const char *path = g_get_user_runtime_dir (); if ( path ) { pidfile = g_build_filename ( path, "rofi.pid", NULL ); } config_parser_add_option ( xrm_String, "pid", (void * *) &pidfile, "Pidfile location" ); if ( find_arg ( "-config" ) < 0 ) { const char *cpath = g_get_user_config_dir (); if ( cpath ) { config_path = g_build_filename ( cpath, "rofi", "config", NULL ); } } else { char *c = NULL; find_arg_str ( "-config", &c ); config_path = rofi_expand_path ( c ); } TICK (); // Register cleanup function. atexit ( cleanup ); TICK (); // Get DISPLAY, first env, then argument. char *display_str = getenv ( "DISPLAY" ); find_arg_str ( "-display", &display_str ); if ( setlocale ( LC_ALL, "" ) == NULL ) { fprintf ( stderr, "Failed to set locale.\n" ); return EXIT_FAILURE; } xcb->connection = xcb_connect ( display_str, &xcb->screen_nbr ); if ( xcb_connection_has_error ( xcb->connection ) ) { fprintf ( stderr, "Failed to open display: %s", display_str ); return EXIT_FAILURE; } TICK_N ( "Open Display" ); xcb->screen = xcb_aux_get_screen ( xcb->connection, xcb->screen_nbr ); xcb_intern_atom_cookie_t *ac = xcb_ewmh_init_atoms ( xcb->connection, &xcb->ewmh ); xcb_generic_error_t *errors = NULL; xcb_ewmh_init_atoms_replies ( &xcb->ewmh, ac, &errors ); if ( errors ) { fprintf ( stderr, "Failed to create EWMH atoms\n" ); free ( errors ); } if ( xkb_x11_setup_xkb_extension ( xcb->connection, XKB_X11_MIN_MAJOR_XKB_VERSION, XKB_X11_MIN_MINOR_XKB_VERSION, XKB_X11_SETUP_XKB_EXTENSION_NO_FLAGS, NULL, NULL, &xkb.first_event, NULL ) < 0 ) { fprintf ( stderr, "cannot setup XKB extension!\n" ); return EXIT_FAILURE; } xkb.context = xkb_context_new ( XKB_CONTEXT_NO_FLAGS ); if ( xkb.context == NULL ) { fprintf ( stderr, "cannot create XKB context!\n" ); return EXIT_FAILURE; } xkb.xcb_connection = xcb->connection; xkb.device_id = xkb_x11_get_core_keyboard_device_id ( xcb->connection ); enum { required_events = ( XCB_XKB_EVENT_TYPE_NEW_KEYBOARD_NOTIFY | XCB_XKB_EVENT_TYPE_MAP_NOTIFY | XCB_XKB_EVENT_TYPE_STATE_NOTIFY ), required_nkn_details = ( XCB_XKB_NKN_DETAIL_KEYCODES ), required_map_parts = ( XCB_XKB_MAP_PART_KEY_TYPES | XCB_XKB_MAP_PART_KEY_SYMS | XCB_XKB_MAP_PART_MODIFIER_MAP | XCB_XKB_MAP_PART_EXPLICIT_COMPONENTS | XCB_XKB_MAP_PART_KEY_ACTIONS | XCB_XKB_MAP_PART_VIRTUAL_MODS | XCB_XKB_MAP_PART_VIRTUAL_MOD_MAP ), required_state_details = ( XCB_XKB_STATE_PART_MODIFIER_BASE | XCB_XKB_STATE_PART_MODIFIER_LATCH | XCB_XKB_STATE_PART_MODIFIER_LOCK | XCB_XKB_STATE_PART_GROUP_BASE | XCB_XKB_STATE_PART_GROUP_LATCH | XCB_XKB_STATE_PART_GROUP_LOCK ), }; static const xcb_xkb_select_events_details_t details = { .affectNewKeyboard = required_nkn_details, .newKeyboardDetails = required_nkn_details, .affectState = required_state_details, .stateDetails = required_state_details, }; xcb_xkb_select_events ( xcb->connection, xkb.device_id, required_events, /* affectWhich */ 0, /* clear */ required_events, /* selectAll */ required_map_parts, /* affectMap */ required_map_parts, /* map */ &details ); xkb.keymap = xkb_x11_keymap_new_from_device ( xkb.context, xcb->connection, xkb.device_id, XKB_KEYMAP_COMPILE_NO_FLAGS ); if ( xkb.keymap == NULL ) { fprintf ( stderr, "Failed to get Keymap for current keyboard device.\n" ); return EXIT_FAILURE; } xkb.state = xkb_x11_state_new_from_device ( xkb.keymap, xcb->connection, xkb.device_id ); if ( xkb.state == NULL ) { fprintf ( stderr, "Failed to get state object for current keyboard device.\n" ); return EXIT_FAILURE; } xkb.compose.table = xkb_compose_table_new_from_locale ( xkb.context, setlocale ( LC_CTYPE, NULL ), 0 ); if ( xkb.compose.table != NULL ) { xkb.compose.state = xkb_compose_state_new ( xkb.compose.table, 0 ); } else { fprintf ( stderr, "Failed to get keyboard compose table. Trying to limp on.\n" ); } if ( xcb_connection_has_error ( xcb->connection ) ) { fprintf ( stderr, "Connection has error\n" ); exit ( EXIT_FAILURE ); } x11_setup ( &xkb ); if ( xcb_connection_has_error ( xcb->connection ) ) { fprintf ( stderr, "Connection has error\n" ); exit ( EXIT_FAILURE ); } const xcb_query_extension_reply_t *er = xcb_get_extension_data ( xcb->connection, &xcb_xinerama_id ); if ( er ) { if ( er->present ) { xcb_xinerama_is_active_cookie_t is_active_req = xcb_xinerama_is_active ( xcb->connection ); xcb_xinerama_is_active_reply_t *is_active = xcb_xinerama_is_active_reply ( xcb->connection, is_active_req, NULL ); xcb->has_xinerama = is_active->state; free ( is_active ); } } main_loop = g_main_loop_new ( NULL, FALSE ); TICK_N ( "Setup mainloop" ); // startup not. xcb->sndisplay = sn_xcb_display_new ( xcb->connection, error_trap_push, error_trap_pop ); if ( xcb_connection_has_error ( xcb->connection ) ) { fprintf ( stderr, "Connection has error\n" ); exit ( EXIT_FAILURE ); } if ( xcb->sndisplay != NULL ) { xcb->sncontext = sn_launchee_context_new_from_environment ( xcb->sndisplay, xcb->screen_nbr ); } if ( xcb_connection_has_error ( xcb->connection ) ) { fprintf ( stderr, "Connection has error\n" ); exit ( EXIT_FAILURE ); } TICK_N ( "Startup Notification" ); // Initialize Xresources subsystem. config_parse_xresource_init (); TICK_N ( "Initialize Xresources system" ); // Setup keybinding setup_abe (); TICK_N ( "Setup abe" ); if ( find_arg ( "-no-config" ) < 0 ) { load_configuration ( ); } if ( !dmenu_mode ) { // setup_modi setup_modi (); } if ( find_arg ( "-no-config" ) < 0 ) { // Reload for dynamic part. load_configuration_dynamic ( ); } // Dump. // catch help request if ( find_arg ( "-h" ) >= 0 || find_arg ( "-help" ) >= 0 || find_arg ( "--help" ) >= 0 ) { help ( argc, argv ); exit ( EXIT_SUCCESS ); } if ( find_arg ( "-dump-xresources" ) >= 0 ) { config_parse_xresource_dump (); exit ( EXIT_SUCCESS ); } if ( find_arg ( "-dump-xresources-theme" ) >= 0 ) { config_parse_xresources_theme_dump (); exit ( EXIT_SUCCESS ); } main_loop_source = g_water_xcb_source_new_for_connection ( NULL, xcb->connection, main_loop_x11_event_handler, NULL, NULL ); TICK_N ( "X11 Setup " ); rofi_view_workers_initialize (); // Setup signal handling sources. // SIGINT g_unix_signal_add ( SIGINT, main_loop_signal_handler_int, NULL ); g_idle_add ( startup, NULL ); // Start mainloop. g_main_loop_run ( main_loop ); return return_code; }
void dls_upnp_search(dls_upnp_t *upnp, dls_client_t *client, dls_task_t *task, dls_upnp_task_complete_t cb) { gchar *upnp_filter = NULL; gchar *upnp_query = NULL; gchar *sort_by = NULL; dls_async_task_t *cb_data = (dls_async_task_t *)task; dls_async_bas_t *cb_task_data; DLEYNA_LOG_DEBUG("Enter"); DLEYNA_LOG_DEBUG("Path: %s", task->target.path); DLEYNA_LOG_DEBUG("Query: %s", task->ut.search.query); DLEYNA_LOG_DEBUG("Start: %u", task->ut.search.start); DLEYNA_LOG_DEBUG("Count: %u", task->ut.search.count); cb_data->cb = cb; cb_task_data = &cb_data->ut.bas; cb_task_data->filter_mask = dls_props_parse_filter(upnp->filter_map, task->ut.search.filter, &upnp_filter); DLEYNA_LOG_DEBUG("Filter Mask 0x%"G_GUINT64_FORMAT"x", cb_task_data->filter_mask); upnp_query = dls_search_translate_search_string(upnp->filter_map, task->ut.search.query); if (!upnp_query) { DLEYNA_LOG_WARNING("Query string is not valid:%s", task->ut.search.query); cb_data->error = g_error_new(DLEYNA_SERVER_ERROR, DLEYNA_ERROR_BAD_QUERY, "Query string is not valid."); goto on_error; } DLEYNA_LOG_DEBUG("UPnP Query %s", upnp_query); sort_by = dls_sort_translate_sort_string(upnp->filter_map, task->ut.search.sort_by); if (!sort_by) { DLEYNA_LOG_WARNING("Invalid Sort Criteria"); cb_data->error = g_error_new(DLEYNA_SERVER_ERROR, DLEYNA_ERROR_BAD_QUERY, "Sort Criteria are not valid"); goto on_error; } DLEYNA_LOG_DEBUG("Sort By %s", sort_by); cb_task_data->protocol_info = client->protocol_info; dls_device_search(client, task, upnp_filter, upnp_query, sort_by); on_error: if (!cb_data->action) (void) g_idle_add(dls_async_task_complete, cb_data); g_free(sort_by); g_free(upnp_query); g_free(upnp_filter); DLEYNA_LOG_DEBUG("Exit with %s", !cb_data->action ? "FAIL" : "SUCCESS"); }
void liferea_shutdown (void) { g_idle_add (on_shutdown, NULL); }
static int need_redraw(lua_State *L) { g_need_redraw = true; g_idle_add(idle, NULL); return 0; }
int main(int argc, char **argv) { int i = 0, numframes; char *filename = NULL; gchar *notefile = NULL; FILE *fp = NULL; struct stat statbuf; char *databuf = NULL; GError *err = NULL; gtk_init(&argc, &argv); /* Load preferences first. Command line options will override those * preferences. */ loadPreferences(); /* Read defaults from preferences. */ filename = NULL; numframes = 2 * prefs.slide_context + 1; runpref.do_wrapping = prefs.do_wrapping; runpref.do_notectrl = prefs.do_notectrl; runpref.cache_max = prefs.cache_max; runpref.fit_mode = prefs.initial_fit_mode; /* get options via getopt */ while ((i = getopt(argc, argv, "s:wnc:N:CTv")) != -1) { switch (i) { case 's': numframes = 2 * atoi(optarg) + 1; if (numframes <= 1) { fprintf(stderr, "Invalid slide count specified.\n"); usage(argv[0]); exit(EXIT_FAILURE); } break; case 'w': runpref.do_wrapping = TRUE; break; case 'n': runpref.do_notectrl = TRUE; break; case 'c': /* don't care if that number is invalid. it'll get * re-adjusted anyway if it's too small. */ runpref.cache_max = atoi(optarg); break; case 'N': notefile = g_strdup(optarg); break; case 'C': /* Force the timer to be a clock. */ prefs.timer_is_clock = TRUE; break; case 'T': /* Force the timer to be a timer (not a clock). */ prefs.timer_is_clock = FALSE; break; case 'v': printf("pdfpres version: %s\n", PDFPRES_VERSION); exit(EXIT_SUCCESS); break; case '?': exit(EXIT_FAILURE); break; } } /* retrieve file name via first non-option argument */ if (optind < argc) { filename = argv[optind]; } if (filename == NULL) { fprintf(stderr, "Invalid file path specified.\n"); usage(argv[0]); exit(EXIT_FAILURE); } /* for the cache to be useful, we'll need at least "some" items. * that is 2 items (prev and next) per preview viewport and 2 * items for the beamer port. * * this means that switching to the previous and next slide will * always be fast. * * note: numframes is not negative (see above), so that cast is okay. */ if (runpref.cache_max < (guint)((numframes + 1) * 2)) runpref.cache_max = (guint)((numframes + 1) * 2); /* try to load the file */ if (stat(filename, &statbuf) == -1) { perror("Could not stat file"); exit(EXIT_FAILURE); } /* note: this buffer must not be freed, it'll be used by poppler * later on. */ databuf = (char *)malloc(statbuf.st_size); g_assert(databuf); fp = fopen(filename, "rb"); if (!fp) { perror("Could not open file"); exit(EXIT_FAILURE); } /* Read 1 element of size "statbuf.st_size". fread() returns the * number of items successfully read. Thus, a return value of "1" * means "success" and anything else is an error. */ if (fread(databuf, statbuf.st_size, 1, fp) != 1) { fprintf(stderr, "Unexpected end of file.\n"); exit(EXIT_FAILURE); } fclose(fp); /* get document from data */ doc = poppler_document_new_from_data(databuf, statbuf.st_size, NULL, &err); if (!doc) { fprintf(stderr, "%s\n", err->message); g_error_free(err); exit(EXIT_FAILURE); } doc_n_pages = poppler_document_get_n_pages(doc); if (doc_n_pages <= 0) { fprintf(stderr, "Huh, no pages in that document.\n"); exit(EXIT_FAILURE); } initGUI(numframes, notefile); /* queue initial prerendering. */ preQueued = TRUE; g_idle_add(idleFillCaches, NULL); gtk_main(); exit(EXIT_SUCCESS); }
static void gtkui_cleanup_wrap(void) { g_idle_add(gtkui_cleanup_shim, NULL); }
static void cogland_queue_redraw (CoglandCompositor *compositor) { if (compositor->redraw_idle == 0) compositor->redraw_idle = g_idle_add (paint_cb, compositor); }
static gpointer external_editor_thread (gpointer user_data) { EMsgComposer *composer = user_data; gchar *filename = NULL; gint status = 0; GSettings *settings; gchar *editor_cmd_line = NULL, *editor_cmd = NULL, *content; gint fd, position = -1, offset = -1; /* prefix temp files with evo so .*vimrc can be setup to recognize them */ fd = g_file_open_tmp ("evoXXXXXX", &filename, NULL); if (fd > 0) { gsize length = 0; close (fd); d (printf ("\n\aTemporary-file Name is : [%s] \n\a", filename)); /* Push the text (if there is one) from the composer to the file */ content = gtkhtml_editor_get_text_plain (GTKHTML_EDITOR (composer), &length); g_file_set_contents (filename, content, length, NULL); } else { struct run_error_dialog_data *data; data = g_new0 (struct run_error_dialog_data, 1); data->composer = composer; data->text = "org.gnome.evolution.plugins.external-editor:no-temp-file"; g_warning ("Temporary file fd is null"); /* run_error_dialog also calls enable_composer */ g_idle_add ((GSourceFunc) run_error_dialog, data); goto finished; } settings = g_settings_new ("org.gnome.evolution.plugin.external-editor"); editor_cmd = g_settings_get_string (settings, "command"); if (!editor_cmd) { if (!(editor_cmd = g_strdup (g_getenv ("EDITOR")))) /* Make gedit the default external editor, * if the default schemas are not installed * and no $EDITOR is set. */ editor_cmd = g_strdup ("gedit"); } g_object_unref (settings); if (g_strrstr (editor_cmd, "vim") != NULL && gtk_html_get_cursor_pos ( gtkhtml_editor_get_html ( GTKHTML_EDITOR (composer)), &position, &offset) && position >= 0 && offset >= 0) { gchar *tmp = editor_cmd; gint lineno; gboolean set_nofork; set_nofork = g_strrstr (editor_cmd, "gvim") != NULL; /* Increment 1 so that entering vim insert mode places you * in the same entry position you were at in the html. */ offset++; /* calculate the line number that the cursor is in */ lineno = numlines (content, position); editor_cmd = g_strdup_printf ( "%s \"+call cursor(%d,%d)\"%s%s", tmp, lineno, offset, set_nofork ? " " : "", set_nofork ? "--nofork" : ""); g_free (tmp); } g_free (content); editor_cmd_line = g_strconcat (editor_cmd, " ", filename, NULL); if (!g_spawn_command_line_sync (editor_cmd_line, NULL, NULL, &status, NULL)) { struct run_error_dialog_data *data; g_warning ("Unable to launch %s: ", editor_cmd_line); data = g_new0 (struct run_error_dialog_data, 1); data->composer = composer; data->text = "org.gnome.evolution.plugins.external-editor:editor-not-launchable"; /* run_error_dialog also calls enable_composer */ g_idle_add ((GSourceFunc) run_error_dialog, data); g_free (filename); g_free (editor_cmd_line); g_free (editor_cmd); goto finished; } g_free (editor_cmd_line); g_free (editor_cmd); #ifdef HAVE_SYS_WAIT_H if (WEXITSTATUS (status) != 0) { #else if (status) { #endif d (printf ("\n\nsome problem here with external editor\n\n")); g_idle_add ((GSourceFunc) enable_composer, composer); goto finished; } else { gchar *buf; if (g_file_get_contents (filename, &buf, NULL, NULL)) { gchar *htmltext; GArray *array; htmltext = camel_text_to_html ( buf, CAMEL_MIME_FILTER_TOHTML_PRE, 0); array = g_array_sized_new ( TRUE, TRUE, sizeof (gpointer), 2 * sizeof (gpointer)); array = g_array_append_val (array, composer); array = g_array_append_val (array, htmltext); g_idle_add ((GSourceFunc) update_composer_text, array); /* We no longer need that temporary file */ if (g_remove (filename) == -1) g_warning ( "%s: Failed to remove file '%s': %s", G_STRFUNC, filename, g_strerror (errno)); g_free (filename); } } finished: g_mutex_lock (&external_editor_running_lock); external_editor_running = FALSE; g_mutex_unlock (&external_editor_running_lock); return NULL; } static void launch_editor (GtkAction *action, EMsgComposer *composer) { d (printf ("\n\nexternal_editor plugin is launched \n\n")); if (editor_running ()) { d (printf ("not opening editor, because it's still running\n")); return; } disable_composer (composer); g_mutex_lock (&external_editor_running_lock); external_editor_running = TRUE; g_mutex_unlock (&external_editor_running_lock); editor_thread = g_thread_new ( NULL, external_editor_thread, composer); g_thread_unref (editor_thread); }
int main(void) { #if !GLIB_CHECK_VERSION(2, 31, 0) g_thread_init(NULL); #endif dbus_g_thread_init(); //////////////////////////////////// /// set to ignore child process terminated signal. signal( SIGCHLD, SIG_IGN ); //////////////////////////////////// MSG_DEBUG("===========START MESSAGING FRAMEWORK=========="); // Reset message server ready flag MsgSettingSetBool(VCONFKEY_MSG_SERVER_READY, false); // Connect to DB // MsgStoConnectDB(); // Open Contact Service MsgOpenContactSvc(); // Clean up mms dir InitMmsDir(); // Regist vconf CB. MsgSettingRegVconfCB(); pthread_t startThreadId; // start transaction manager if (pthread_create(&startThreadId, NULL, StartMsgServer, NULL) != 0) { MSG_DEBUG("StartMsgServer not invoked: %s", strerror(errno)); return -1; } MsgTransactionManager::instance()->getTMStatus(); mainloop = g_main_loop_new(NULL, FALSE); g_type_init(); g_idle_add(InitThreadFunc, NULL); if (mainloop != NULL) { MSG_DEBUG("Start Messaging Framework!!!"); // Run GMainLoop g_main_loop_run(mainloop); } else { MSG_DEBUG("Fail to start Messaging Framework!!!"); } // Remove vconf CB MsgSettingRemoveVconfCB(); // Close Contact Sevice MsgCloseContactSvc(); // Disconnect to DB MsgStoDisconnectDB(); return 0; }
static void eos_cb (GstElement *sink, Player *player) { player->priv->eos_idle_id = g_idle_add ((GSourceFunc) eos_idle_cb, player); }
/* main */ int main (int argc, char *argv[]) { GOptionContext *context; gboolean window_arg = FALSE; gboolean area_arg = FALSE; gboolean include_border_arg = FALSE; gboolean disable_border_arg = FALSE; gboolean interactive_arg = FALSE; gchar *border_effect_arg = NULL; guint delay_arg = 0; GError *error = NULL; const GOptionEntry entries[] = { { "window", 'w', 0, G_OPTION_ARG_NONE, &window_arg, N_("Grab a window instead of the entire screen"), NULL }, { "area", 'a', 0, G_OPTION_ARG_NONE, &area_arg, N_("Grab an area of the screen instead of the entire screen"), NULL }, { "include-border", 'b', 0, G_OPTION_ARG_NONE, &include_border_arg, N_("Include the window border with the screenshot"), NULL }, { "remove-border", 'B', 0, G_OPTION_ARG_NONE, &disable_border_arg, N_("Remove the window border from the screenshot"), NULL }, { "delay", 'd', 0, G_OPTION_ARG_INT, &delay_arg, N_("Take screenshot after specified delay [in seconds]"), N_("seconds") }, { "border-effect", 'e', 0, G_OPTION_ARG_STRING, &border_effect_arg, N_("Effect to add to the border (shadow, border or none)"), N_("effect") }, { "interactive", 'i', 0, G_OPTION_ARG_NONE, &interactive_arg, N_("Interactively set options"), NULL }, { NULL }, }; setlocale (LC_ALL, ""); bindtextdomain (GETTEXT_PACKAGE, MATELOCALEDIR); bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8"); textdomain (GETTEXT_PACKAGE); context = g_option_context_new (_("Take a picture of the screen")); g_option_context_set_ignore_unknown_options (context, FALSE); g_option_context_set_help_enabled (context, TRUE); g_option_context_add_main_entries (context, entries, GETTEXT_PACKAGE); g_option_context_add_group (context, gtk_get_option_group (TRUE)); g_option_context_parse (context, &argc, &argv, &error); if (error) { g_critical ("Unable to parse arguments: %s", error->message); g_error_free (error); g_option_context_free (context); exit (1); } g_option_context_free (context); if (window_arg && area_arg) { g_printerr (_("Conflicting options: --window and --area should not be " "used at the same time.\n")); exit (1); } gtk_window_set_default_icon_name (SCREENSHOOTER_ICON); screenshooter_init_stock_icons (); settings = g_settings_new (MATE_SCREENSHOT_SCHEMA); load_options (); /* allow the command line to override options */ if (window_arg) take_window_shot = TRUE; if (area_arg) take_area_shot = TRUE; if (include_border_arg) include_border = TRUE; if (disable_border_arg) include_border = FALSE; if (border_effect_arg) { g_free (border_effect); border_effect = border_effect_arg; } if (delay_arg > 0) delay = delay_arg; /* interactive mode overrides everything */ if (interactive_arg) { GtkWidget *dialog; gint response; dialog = create_interactive_dialog (); response = gtk_dialog_run (GTK_DIALOG (dialog)); gtk_widget_destroy (dialog); switch (response) { case GTK_RESPONSE_DELETE_EVENT: case GTK_RESPONSE_CANCEL: return EXIT_SUCCESS; case GTK_RESPONSE_OK: break; default: g_assert_not_reached (); break; } } if (((delay > 0 && interactive_arg) || delay_arg > 0) && !take_area_shot) { g_timeout_add (delay * 1000, prepare_screenshot_timeout, NULL); } else { if (interactive_arg) { /* HACK: give time to the dialog to actually disappear. * We don't have any way to tell when the compositor has finished * re-drawing. */ g_timeout_add (200, prepare_screenshot_timeout, NULL); } else g_idle_add (prepare_screenshot_timeout, NULL); } gtk_main (); return EXIT_SUCCESS; }
static void swap_complete_cb (CoglFramebuffer *framebuffer, void *user_data) { g_idle_add (paint_cb, user_data); }
void fe_idle_add (void *func, void *data) { g_idle_add (func, data); }