void eee_accounts_manager_activate_accounts(EeeAccountsManager *self)
{
GSList *iter, *iter2, *iter2_next, *iter_next;
g_return_if_fail(IS_EEE_ACCOUNTS_MANAGER(self));
// for each accessible account
for (iter = self->priv->access_accounts; iter; iter = iter->next)
{
EeeAccount *account;
ESourceGroup *group;
char *name = iter->data;
char *group_name = g_strdup_printf("3e: %s", name);
// find ESourceGroup and EeeAccount
#if EVOLUTION_VERSION >= 232
group = e_source_list_peek_group_by_properties(self->priv->eslist, "name", group_name, NULL);
#else
group = e_source_list_peek_group_by_name(self->priv->eslist, group_name);
#endif /* EVOLUTION_VERSION >= 232 */
account = eee_accounts_manager_find_account_by_name(self, name);
// create account if it does not exist
if (account == NULL)
{
account = eee_account_new(name);
eee_account_set_state(account, EEE_ACCOUNT_STATE_NOTAVAIL);
eee_accounts_manager_add_account(self, account);
}
// create group if it does not exist
if (group == NULL)
{
group = e_source_group_new(group_name, EEE_URI_PREFIX);
e_source_list_add_group(self->priv->eslist, group, -1);
g_object_unref(group);
}
else
{
// check group sources
for (iter2 = e_source_group_peek_sources(group); iter2 != NULL; iter2 = iter2_next)
{
// we may be removing sources so ensure that we have valid next pointer
iter2_next = iter2->next;
ESource *source = iter2->data;
if (e_source_is_3e(source))
{
const char *calname = e_source_get_property(source, "eee-calname");
e_source_set_3e_properties(source, calname, account->name, account, NULL, NULL, 0);
}
else
{
// ESource without calname is useless, drop it
e_source_group_remove_source(group, source);
}
}
g_free(group_name);
}
g_object_set_data(G_OBJECT(group), "accessible", (gpointer)TRUE);
}
// for each ESourceGroup that does not represent accessible account
for (iter = e_source_list_peek_groups(self->priv->eslist); iter; iter = iter_next)
{
iter_next = iter->next;
ESourceGroup *group = iter->data;
gboolean contains_source = FALSE;
// skip non-3E groups and accessible groups initialized above
if (!e_source_group_is_3e(group) || g_object_get_data(G_OBJECT(group), "accessible"))
{
continue;
}
for (iter2 = e_source_group_peek_sources(group); iter2 != NULL; iter2 = iter2_next)
{
// we may be removing sources so ensure that we have valid next pointer
iter2_next = iter2->next;
ESource *source = iter2->data;
// these ESources are probably for shared calendars, if we can't find
// account for them, remove them
if (eee_accounts_manager_find_account_by_source(self, source))
{
contains_source = TRUE;
}
else
{
e_source_group_remove_source(group, source);
}
}
if (!contains_source)
{
e_source_list_remove_group(self->priv->eslist, group);
}
}
e_source_list_sync(self->priv->eslist, NULL);
}
gchar *
tracker_guint_to_string (guint i)
{
return g_strdup_printf ("%u", i);
}
GPtrArray* get_serial_array(GError **error) {
GDBusProxy *udisks_proxy=0;
GVariant *device_list;
GPtrArray* rv=0;
udisks_proxy = g_dbus_proxy_new_for_bus_sync (
G_BUS_TYPE_SYSTEM,
G_DBUS_PROXY_FLAGS_DO_NOT_CONNECT_SIGNALS,
NULL /* info */ ,
DBUS_COMMON_NAME_UDISKS,
DBUS_OBJECT_PATH_UDISKS_ROOT,
DBUS_INTERFACE_UDISKS,
NULL /* cancellable */ ,
error );
if(udisks_proxy == NULL) {
g_prefix_error (error, "Failed to create dBus proxy:");
goto udisks_proxy_create_error;
}
// Call ListNames method, wait for reply
device_list = g_dbus_proxy_call_sync (
udisks_proxy,
"EnumerateDevices",
NULL /* paramatrs */,
G_DBUS_CALL_FLAGS_NONE,
-1 /* timeout_msec */,
NULL /* cancellable */,
error);
if(device_list == NULL) {
g_prefix_error (error, "Failed to call EnumerateDevices udisks method:");
goto enumerate_device_error;
}
// g_print("%s: \n", );
{
GVariantIter *iter;
gchar *device;
g_variant_get (device_list, "(ao)", &iter);
rv = g_ptr_array_new();
g_ptr_array_set_free_func(rv, g_free);
while (g_variant_iter_loop (iter, "o", &device)) {
GDBusProxy *device_proxy = 0;
device_proxy = g_dbus_proxy_new_for_bus_sync (
G_BUS_TYPE_SYSTEM,
G_DBUS_PROXY_FLAGS_DO_NOT_CONNECT_SIGNALS,
NULL /* info */ ,
DBUS_COMMON_NAME_UDISKS,
device,
DBUS_INTERFACE_UDISKS_DEVICE,
NULL /* cancellable */ ,
error );
if(device_proxy == NULL) {
g_prefix_error (error, "Failed to create dBus devices proxy for %s device:", device);
g_ptr_array_unref(rv);
rv=0;
goto devices_proxy_create_error;
}
if( dbus_get_bool_property(device_proxy, "DeviceIsDrive") &&
! dbus_get_bool_property(device_proxy, "DeviceIsRemovable") ) {
gchar* full_serial=0;
gchar *vendor = dbus_get_string_property(device_proxy, "DriveVendor");
gchar *model = dbus_get_string_property(device_proxy, "DriveModel");
gchar *revision = dbus_get_string_property(device_proxy, "DriveRevision");
gchar *serial = dbus_get_string_property(device_proxy, "DriveSerial");
gchar *wwn = dbus_get_string_property(device_proxy, "DriveWwn");
full_serial = g_strdup_printf("%s-%s-%s-%s", model, revision, serial, wwn);
g_ptr_array_add(rv, full_serial);
g_free(vendor);
g_free(model);
g_free(revision);
g_free(serial);
g_free(wwn);
}
g_object_unref (device_proxy);
}
devices_proxy_create_error:
g_variant_iter_free(iter);
}
g_variant_unref(device_list);
enumerate_device_error:
g_object_unref (udisks_proxy);
udisks_proxy_create_error:
return rv;
}
gboolean
gs_plugin_add_distro_upgrades (GsPlugin *plugin,
GsAppList *list,
GCancellable *cancellable,
GError **error)
{
GsPluginData *priv = gs_plugin_get_data (plugin);
gsize len;
guint i;
g_autofree gchar *data = NULL;
g_autoptr(GPtrArray) distros = NULL;
g_autoptr(GSettings) settings = NULL;
/* just ensure there is any data, no matter how old */
if (!gs_plugin_fedora_distro_upgrades_refresh (plugin,
G_MAXUINT,
cancellable,
error))
return FALSE;
/* get cached file */
if (!g_file_get_contents (priv->cachefn, &data, &len, error)) {
gs_utils_error_convert_gio (error);
return FALSE;
}
/* parse data */
settings = g_settings_new ("org.gnome.software");
distros = parse_pkgdb_collections_data (data, (gssize) len, error);
if (distros == NULL)
return FALSE;
g_ptr_array_sort (distros, sort_distros_cb);
for (i = 0; i < distros->len; i++) {
DistroInfo *distro_info = g_ptr_array_index (distros, i);
g_autofree gchar *app_id = NULL;
g_autofree gchar *app_version = NULL;
g_autofree gchar *background = NULL;
g_autofree gchar *cache_key = NULL;
g_autofree gchar *url = NULL;
g_autofree gchar *css = NULL;
g_autoptr(GsApp) app = NULL;
g_autoptr(AsIcon) ic = NULL;
/* only interested in upgrades to the same distro */
if (g_strcmp0 (distro_info->name, priv->os_name) != 0)
continue;
/* only interested in newer versions, but not more than N+2 */
if (distro_info->version <= priv->os_version ||
distro_info->version > priv->os_version + 2)
continue;
/* only interested in non-devel distros */
if (!g_settings_get_boolean (settings, "show-upgrade-prerelease")) {
if (distro_info->status == DISTRO_STATUS_DEVEL)
continue;
}
/* search in the cache */
cache_key = g_strdup_printf ("release-%u", distro_info->version);
app = gs_plugin_cache_lookup (plugin, cache_key);
if (app != NULL) {
gs_app_list_add (list, app);
continue;
}
app_id = g_strdup_printf ("org.fedoraproject.release-%u.upgrade",
distro_info->version);
app_version = g_strdup_printf ("%u", distro_info->version);
/* icon from disk */
ic = as_icon_new ();
as_icon_set_kind (ic, AS_ICON_KIND_LOCAL);
as_icon_set_filename (ic, "/usr/share/pixmaps/fedora-logo-sprite.png");
/* create */
app = gs_app_new (app_id);
gs_app_set_kind (app, AS_APP_KIND_OS_UPGRADE);
gs_app_set_state (app, AS_APP_STATE_AVAILABLE);
gs_app_set_name (app, GS_APP_QUALITY_LOWEST, distro_info->name);
gs_app_set_summary (app, GS_APP_QUALITY_LOWEST,
/* TRANSLATORS: this is a title for Fedora distro upgrades */
_("A major upgrade, with new features and added polish."));
gs_app_set_description (app, GS_APP_QUALITY_LOWEST,
"Fedora Workstation is a polished, "
"easy to use operating system for "
"laptop and desktop computers, with a "
"complete set of tools for developers "
"and makers of all kinds.");
gs_app_set_version (app, app_version);
gs_app_set_size_installed (app, 1024 * 1024 * 1024); /* estimate */
gs_app_set_size_download (app, 256 * 1024 * 1024); /* estimate */
gs_app_set_license (app, GS_APP_QUALITY_LOWEST, "LicenseRef-free");
gs_app_add_quirk (app, AS_APP_QUIRK_NEEDS_REBOOT);
gs_app_add_quirk (app, AS_APP_QUIRK_PROVENANCE);
gs_app_add_quirk (app, AS_APP_QUIRK_NOT_REVIEWABLE);
gs_app_set_origin_ui (app, distro_info->name);
gs_app_add_icon (app, ic);
gs_app_set_management_plugin (app, "packagekit");
/* show a Fedora magazine article for the release */
url = g_strdup_printf ("https://fedoramagazine.org/whats-new-fedora-%u-workstation",
distro_info->version);
gs_app_set_url (app, AS_URL_KIND_HOMEPAGE, url);
/* use a fancy background */
background = get_upgrade_css_background (distro_info->version);
css = g_strdup_printf ("background: %s;"
"background-position: center;"
"background-size: cover;",
background);
gs_app_set_metadata (app, "GnomeSoftware::UpgradeBanner-css", css);
gs_app_list_add (list, app);
/* save in the cache */
gs_plugin_cache_add (plugin, cache_key, app);
}
return TRUE;
}
int
main (int argc, char **argv)
{
int i;
int found_valid = FALSE;
GdkPixbufAnimation *animation;
gtk_init (&argc, &argv);
gdk_rgb_set_verbose (TRUE);
gdk_rgb_init ();
gtk_widget_set_default_colormap (gdk_rgb_get_cmap ());
gtk_widget_set_default_visual (gdk_rgb_get_visual ());
{
char *tbf_readlen = getenv("TBF_READLEN");
if(tbf_readlen) readlen = atoi(tbf_readlen);
}
{
char *tbf_bps = getenv("TBF_KBPS");
guint bps;
if (tbf_bps) {
bps = atoi(tbf_bps);
g_print ("Simulating %d kBytes/sec\n", bps);
readlen = (bps*1024)/10;
}
}
i = 1;
if (argc == 1) {
g_print ("USAGE: testanimation FILE1 ...\n");
return 0;
} else {
for (i = 1; i < argc; i++) {
animation = gdk_pixbuf_animation_new_from_file (argv[i]);
if (animation) {
gint i = 0;
GList *listptr;
for (listptr = gdk_pixbuf_animation_get_frames (animation);
listptr;
listptr = listptr->next) {
GdkPixbufFrame *frame;
GdkPixbuf *pixbuf;
gchar *title;
frame = listptr->data;
pixbuf = gdk_pixbuf_frame_get_pixbuf (frame);
title = g_strdup_printf ("Frame %d", i);
g_print ("Frame %d x:%d y:%d width:%d height:%d\n",
i,
gdk_pixbuf_frame_get_x_offset (frame),
gdk_pixbuf_frame_get_y_offset (frame),
gdk_pixbuf_get_width (pixbuf),
gdk_pixbuf_get_height (pixbuf));
new_testrgb_window (pixbuf, title);
g_free (title);
i++;
}
found_valid = TRUE;
}
}
#if 0
{
GtkWidget* rgb_window = NULL;
ProgressFileStatus status;
GdkPixbufLoader *pixbuf_loader;
pixbuf_loader = gdk_pixbuf_loader_new ();
status.loader = pixbuf_loader;
status.rgbwin = &rgb_window;
status.buf = g_malloc (readlen);
gtk_signal_connect(GTK_OBJECT(pixbuf_loader),
"area_prepared",
GTK_SIGNAL_FUNC(progressive_prepared_callback),
&rgb_window);
gtk_signal_connect(GTK_OBJECT(pixbuf_loader),
"area_updated",
GTK_SIGNAL_FUNC(progressive_updated_callback),
&rgb_window);
status.imagefile = fopen (argv[1], "r");
g_assert (status.imagefile != NULL);
status.readlen = readlen;
status.timeout = gtk_timeout_add(100, update_timeout, &status);
}
#endif
}
if (found_valid)
gtk_main ();
return 0;
}
/* This is based on caja_compute_title_for_uri() and
* caja_file_get_display_name_nocopy() */
char *
panel_util_get_label_for_uri (const char *text_uri)
{
GFile *file;
char *label;
GFile *root;
char *root_display;
/* Here's what we do:
* + x-caja-search: URI
* + check if the URI is a mount
* + if file: URI:
* - check for known file: URI
* - check for description of the GFile
* - use display name of the GFile
* + else:
* - check for description of the GFile
* - if the URI is a root: "root displayname"
* - else: "root displayname: displayname"
*/
label = NULL;
//FIXME: see caja_query_to_readable_string() to have a nice name
if (g_str_has_prefix (text_uri, "x-caja-search:"))
return g_strdup (_("Search"));
file = g_file_new_for_uri (text_uri);
label = panel_util_get_file_display_name_if_mount (file);
if (label) {
g_object_unref (file);
return label;
}
if (g_str_has_prefix (text_uri, "file:")) {
label = panel_util_get_file_display_for_common_files (file);
if (!label)
label = panel_util_get_file_description (file);
if (!label)
label = panel_util_get_file_display_name (file, TRUE);
g_object_unref (file);
return label;
}
label = panel_util_get_file_description (file);
if (label) {
g_object_unref (file);
return label;
}
root = panel_util_get_gfile_root (file);
root_display = panel_util_get_file_description (root);
if (!root_display)
root_display = panel_util_get_file_display_name (root, FALSE);
if (!root_display)
/* can happen with URI schemes non supported by gvfs */
root_display = g_file_get_uri_scheme (root);
if (g_file_equal (file, root))
label = root_display;
else {
char *displayname;
displayname = panel_util_get_file_display_name (file, TRUE);
/* Translators: the first string is the name of a gvfs
* method, and the second string is a path. For
* example, "Trash: some-directory". It means that the
* directory called "some-directory" is in the trash.
*/
label = g_strdup_printf (_("%1$s: %2$s"),
root_display, displayname);
g_free (root_display);
g_free (displayname);
}
g_object_unref (root);
g_object_unref (file);
return label;
}
static void
handle_single_mode (mode_run *mr, char sign, char mode, char *nick,
char *chan, char *arg, int quiet, int is_324,
const message_tags_data *tags_data)
{
session *sess;
server *serv = mr->serv;
char outbuf[4];
char *cm = serv->chanmodes;
gboolean supportsq = FALSE;
outbuf[0] = sign;
outbuf[1] = 0;
outbuf[2] = mode;
outbuf[3] = 0;
sess = find_channel (serv, chan);
if (!sess || !is_channel (serv, chan))
{
/* got modes for a chan we're not in! probably nickmode +isw etc */
sess = serv->front_session;
goto genmode;
}
/* is this a nick mode? */
if (strchr (serv->nick_modes, mode))
{
/* update the user in the userlist */
userlist_update_mode (sess, /*nickname */ arg, mode, sign);
} else
{
if (!is_324 && !sess->ignore_mode && mode_chanmode_type(serv, mode) >= 1)
record_chan_mode (sess, sign, mode, arg);
}
/* Is q a chanmode on this server? */
if (cm)
while (*cm)
{
if (*cm == ',')
break;
if (*cm == 'q')
supportsq = TRUE;
cm++;
}
switch (sign)
{
case '+':
switch (mode)
{
case 'k':
safe_strcpy (sess->channelkey, arg, sizeof (sess->channelkey));
fe_update_channel_key (sess);
fe_update_mode_buttons (sess, mode, sign);
if (!quiet)
EMIT_SIGNAL_TIMESTAMP (XP_TE_CHANSETKEY, sess, nick, arg, NULL,
NULL, 0, tags_data->timestamp);
return;
case 'l':
sess->limit = atoi (arg);
fe_update_channel_limit (sess);
fe_update_mode_buttons (sess, mode, sign);
if (!quiet)
EMIT_SIGNAL_TIMESTAMP (XP_TE_CHANSETLIMIT, sess, nick, arg, NULL,
NULL, 0, tags_data->timestamp);
return;
case 'o':
if (!quiet)
mr->op = mode_cat (mr->op, arg);
return;
case 'h':
if (!quiet)
EMIT_SIGNAL_TIMESTAMP (XP_TE_CHANHOP, sess, nick, arg, NULL, NULL,
0, tags_data->timestamp);
return;
case 'v':
if (!quiet)
mr->voice = mode_cat (mr->voice, arg);
return;
case 'b':
if (!quiet)
EMIT_SIGNAL_TIMESTAMP (XP_TE_CHANBAN, sess, nick, arg, NULL, NULL,
0, tags_data->timestamp);
return;
case 'e':
if (!quiet)
EMIT_SIGNAL_TIMESTAMP (XP_TE_CHANEXEMPT, sess, nick, arg, NULL,
NULL, 0, tags_data->timestamp);
return;
case 'I':
if (!quiet)
EMIT_SIGNAL_TIMESTAMP (XP_TE_CHANINVITE, sess, nick, arg, NULL, NULL,
0, tags_data->timestamp);
return;
case 'q':
if (!supportsq)
break; /* +q is owner on this server */
if (!quiet)
EMIT_SIGNAL_TIMESTAMP (XP_TE_CHANQUIET, sess, nick, arg, NULL, NULL, 0,
tags_data->timestamp);
return;
}
break;
case '-':
switch (mode)
{
case 'k':
sess->channelkey[0] = 0;
fe_update_channel_key (sess);
fe_update_mode_buttons (sess, mode, sign);
if (!quiet)
EMIT_SIGNAL_TIMESTAMP (XP_TE_CHANRMKEY, sess, nick, NULL, NULL,
NULL, 0, tags_data->timestamp);
return;
case 'l':
sess->limit = 0;
fe_update_channel_limit (sess);
fe_update_mode_buttons (sess, mode, sign);
if (!quiet)
EMIT_SIGNAL_TIMESTAMP (XP_TE_CHANRMLIMIT, sess, nick, NULL, NULL,
NULL, 0, tags_data->timestamp);
return;
case 'o':
if (!quiet)
mr->deop = mode_cat (mr->deop, arg);
return;
case 'h':
if (!quiet)
EMIT_SIGNAL_TIMESTAMP (XP_TE_CHANDEHOP, sess, nick, arg, NULL,
NULL, 0, tags_data->timestamp);
return;
case 'v':
if (!quiet)
mr->devoice = mode_cat (mr->devoice, arg);
return;
case 'b':
if (!quiet)
EMIT_SIGNAL_TIMESTAMP (XP_TE_CHANUNBAN, sess, nick, arg, NULL, NULL,
0, tags_data->timestamp);
return;
case 'e':
if (!quiet)
EMIT_SIGNAL_TIMESTAMP (XP_TE_CHANRMEXEMPT, sess, nick, arg, NULL,
NULL, 0, tags_data->timestamp);
return;
case 'I':
if (!quiet)
EMIT_SIGNAL_TIMESTAMP (XP_TE_CHANRMINVITE, sess, nick, arg, NULL,
NULL, 0, tags_data->timestamp);
return;
case 'q':
if (!supportsq)
break; /* -q is owner on this server */
if (!quiet)
EMIT_SIGNAL_TIMESTAMP (XP_TE_CHANUNQUIET, sess, nick, arg, NULL,
NULL, 0, tags_data->timestamp);
return;
}
}
fe_update_mode_buttons (sess, mode, sign);
genmode:
/* Received umode +e. If we're waiting to send JOIN then send now! */
if (mode == 'e' && sign == '+' && !serv->p_cmp (chan, serv->nick))
inbound_identified (serv);
if (!quiet)
{
if (*arg)
{
char *buf = g_strdup_printf ("%s %s", chan, arg);
EMIT_SIGNAL_TIMESTAMP (XP_TE_CHANMODEGEN, sess, nick, outbuf,
outbuf + 2, buf, 0, tags_data->timestamp);
g_free (buf);
}
else
EMIT_SIGNAL_TIMESTAMP (XP_TE_CHANMODEGEN, sess, nick, outbuf,
outbuf + 2, chan, 0, tags_data->timestamp);
}
}
static gboolean
gimp_thumbnail_save (GimpThumbnail *thumbnail,
GimpThumbSize size,
const gchar *filename,
GdkPixbuf *pixbuf,
const gchar *software,
GError **error)
{
const gchar *keys[12];
gchar *values[12];
gchar *basename;
gchar *dirname;
gchar *tmpname;
gboolean success;
gint i = 0;
keys[i] = TAG_DESCRIPTION;
values[i] = g_strdup_printf ("Thumbnail of %s", thumbnail->image_uri);
i++;
keys[i] = TAG_SOFTWARE;
values[i] = g_strdup (software);
i++;
keys[i] = TAG_THUMB_URI;
values[i] = g_strdup (thumbnail->image_uri);
i++;
keys[i] = TAG_THUMB_MTIME;
values[i] = g_strdup_printf ("%" G_GINT64_FORMAT, thumbnail->image_mtime);
i++;
keys[i] = TAG_THUMB_FILESIZE;
values[i] = g_strdup_printf ("%" G_GINT64_FORMAT, thumbnail->image_filesize);
i++;
if (thumbnail->image_mimetype)
{
keys[i] = TAG_THUMB_MIMETYPE;
values[i] = g_strdup (thumbnail->image_mimetype);
i++;
}
if (thumbnail->image_width > 0)
{
keys[i] = TAG_THUMB_IMAGE_WIDTH;
values[i] = g_strdup_printf ("%d", thumbnail->image_width);
i++;
}
if (thumbnail->image_height > 0)
{
keys[i] = TAG_THUMB_IMAGE_HEIGHT;
values[i] = g_strdup_printf ("%d", thumbnail->image_height);
i++;
}
if (thumbnail->image_type)
{
keys[i] = TAG_THUMB_GIMP_TYPE;
values[i] = g_strdup (thumbnail->image_type);
i++;
}
if (thumbnail->image_num_layers > 0)
{
keys[i] = TAG_THUMB_GIMP_LAYERS;
values[i] = g_strdup_printf ("%d", thumbnail->image_num_layers);
i++;
}
keys[i] = NULL;
values[i] = NULL;
basename = g_path_get_basename (filename);
dirname = g_path_get_dirname (filename);
tmpname = g_strdup_printf ("%s%cgimp-thumb-%d-%.8s",
dirname, G_DIR_SEPARATOR, getpid (), basename);
g_free (dirname);
g_free (basename);
success = gdk_pixbuf_savev (pixbuf, tmpname, "png",
(gchar **) keys, values,
error);
for (i = 0; keys[i]; i++)
g_free (values[i]);
if (success)
{
#ifdef GIMP_THUMB_DEBUG
g_printerr ("thumbnail saved to temporary file %s\n", tmpname);
#endif
success = (g_rename (tmpname, filename) == 0);
if (! success)
g_set_error (error, G_FILE_ERROR, g_file_error_from_errno (errno),
_("Could not create thumbnail for %s: %s"),
thumbnail->image_uri, g_strerror (errno));
}
if (success)
{
#ifdef GIMP_THUMB_DEBUG
g_printerr ("temporary thumbnail file renamed to %s\n", filename);
#endif
success = (g_chmod (filename, 0600) == 0);
if (! success)
g_set_error (error, G_FILE_ERROR, g_file_error_from_errno (errno),
"Could not set permissions of thumbnail for %s: %s",
thumbnail->image_uri, g_strerror (errno));
g_object_freeze_notify (G_OBJECT (thumbnail));
gimp_thumbnail_update_thumb (thumbnail, size);
if (success &&
thumbnail->thumb_state == GIMP_THUMB_STATE_EXISTS &&
strcmp (filename, thumbnail->thumb_filename) == 0)
{
thumbnail->thumb_state = GIMP_THUMB_STATE_OK;
}
g_object_thaw_notify (G_OBJECT (thumbnail));
}
g_unlink (tmpname);
g_free (tmpname);
return success;
}
static BraseroBurnResult
brasero_readom_argv_set_iso_boundary (BraseroReadom *readom,
GPtrArray *argv,
GError **error)
{
goffset nb_blocks;
BraseroTrack *track;
GValue *value = NULL;
BraseroTrackType *output = NULL;
brasero_job_get_current_track (BRASERO_JOB (readom), &track);
output = brasero_track_type_new ();
brasero_job_get_output_type (BRASERO_JOB (readom), output);
brasero_track_tag_lookup (track,
BRASERO_TRACK_MEDIUM_ADDRESS_START_TAG,
&value);
if (value) {
guint64 start, end;
/* we were given an address to start */
start = g_value_get_uint64 (value);
/* get the length now */
value = NULL;
brasero_track_tag_lookup (track,
BRASERO_TRACK_MEDIUM_ADDRESS_END_TAG,
&value);
end = g_value_get_uint64 (value);
BRASERO_JOB_LOG (readom,
"reading from sector %lli to %lli",
start,
end);
g_ptr_array_add (argv, g_strdup_printf ("-sectors=%"G_GINT64_FORMAT"-%"G_GINT64_FORMAT,
start,
end));
}
/* 0 means all disc, -1 problem */
else if (brasero_track_disc_get_track_num (BRASERO_TRACK_DISC (track)) > 0) {
goffset start;
BraseroDrive *drive;
BraseroMedium *medium;
drive = brasero_track_disc_get_drive (BRASERO_TRACK_DISC (track));
medium = brasero_drive_get_medium (drive);
brasero_medium_get_track_space (medium,
brasero_track_disc_get_track_num (BRASERO_TRACK_DISC (track)),
NULL,
&nb_blocks);
brasero_medium_get_track_address (medium,
brasero_track_disc_get_track_num (BRASERO_TRACK_DISC (track)),
NULL,
&start);
BRASERO_JOB_LOG (readom,
"reading %i from sector %lli to %lli",
brasero_track_disc_get_track_num (BRASERO_TRACK_DISC (track)),
start,
start + nb_blocks);
g_ptr_array_add (argv, g_strdup_printf ("-sectors=%"G_GINT64_FORMAT"-%"G_GINT64_FORMAT,
start,
start + nb_blocks));
}
/* if it's BIN output just read the last track */
else if (brasero_track_type_get_image_format (output) == BRASERO_IMAGE_FORMAT_BIN) {
goffset start;
BraseroDrive *drive;
BraseroMedium *medium;
drive = brasero_track_disc_get_drive (BRASERO_TRACK_DISC (track));
medium = brasero_drive_get_medium (drive);
brasero_medium_get_last_data_track_space (medium,
NULL,
&nb_blocks);
brasero_medium_get_last_data_track_address (medium,
NULL,
&start);
BRASERO_JOB_LOG (readom,
"reading last track from sector %"G_GINT64_FORMAT" to %"G_GINT64_FORMAT,
start,
start + nb_blocks);
g_ptr_array_add (argv, g_strdup_printf ("-sectors=%"G_GINT64_FORMAT"-%"G_GINT64_FORMAT,
start,
start + nb_blocks));
}
else {
brasero_track_get_size (track, &nb_blocks, NULL);
g_ptr_array_add (argv, g_strdup_printf ("-sectors=0-%"G_GINT64_FORMAT, nb_blocks));
}
brasero_track_type_free (output);
return BRASERO_BURN_OK;
}
/**
* gstreamill_job_start:
* @job: (in): json type of job description.
*
* Returns: json type of job execution result.
*/
gchar * gstreamill_job_start (Gstreamill *gstreamill, gchar *job_desc)
{
gchar *p, *name;
Job *job;
if (!jobdesc_is_valid (job_desc)) {
p = g_strdup ("Invalid job");
return p;
}
if (jobdesc_is_live (job_desc)) {
GST_ERROR ("live job arrived");
} else {
GST_ERROR ("transcode job arrived");
}
/* create job object */
name = jobdesc_get_name (job_desc);
if (get_job (gstreamill, name) != NULL) {
GST_ERROR ("start live job failure, duplicated name %s.", name);
p = g_strdup_printf ("start live job failure, duplicated name %s.", name);
g_free (name);
return p;
}
job = job_new ("job", job_desc, "name", name, NULL);
g_free (name);
/* job initialize */
job->log_dir = gstreamill->log_dir;
g_mutex_init (&(job->access_mutex));
job->is_live = jobdesc_is_live (job_desc);
job->eos = FALSE;
job->current_access = 0;
job->age = 0;
job->last_start_time = NULL;
if (job_initialize (job, gstreamill->daemon) != 0) {
p = g_strdup ("initialize job failure");
g_object_unref (job);
return p;
}
/* reset and start job */
job_reset (job);
if (gstreamill->daemon) {
p = create_job_process (job);
GST_ERROR ("%s: %s", p, job->name);
if (g_str_has_suffix (p, "success")) {
g_mutex_lock (&(gstreamill->job_list_mutex));
gstreamill->job_list = g_slist_append (gstreamill->job_list, job);
g_mutex_unlock (&(gstreamill->job_list_mutex));
} else {
g_object_unref (job);
}
} else {
if (job_start (job) == 0) {
g_mutex_lock (&(gstreamill->job_list_mutex));
gstreamill->job_list = g_slist_append (gstreamill->job_list, job);
g_mutex_unlock (&(gstreamill->job_list_mutex));
p = g_strdup ("success");
} else {
p = g_strdup ("failure");
}
}
return p;
}
/**
* gimp_thumbnail_save_failure:
* @thumbnail: a #GimpThumbnail object
* @software: a string describing the software saving the thumbnail
* @error: return location for possible errors
*
* Saves a failure thumbnail for the image associated with
* @thumbnail. This is an empty pixbuf that indicates that an attempt
* to create a preview for the image file failed. It should be used to
* prevent the software from further attempts to create this thumbnail.
*
* Return value: %TRUE if a failure thumbnail was successfully written,
* %FALSE otherwise
**/
gboolean
gimp_thumbnail_save_failure (GimpThumbnail *thumbnail,
const gchar *software,
GError **error)
{
GdkPixbuf *pixbuf;
gchar *name;
gchar *desc;
gchar *time_str;
gchar *size_str;
gboolean success;
g_return_val_if_fail (GIMP_IS_THUMBNAIL (thumbnail), FALSE);
g_return_val_if_fail (thumbnail->image_uri != NULL, FALSE);
g_return_val_if_fail (software != NULL, FALSE);
GIMP_THUMB_DEBUG_CALL (thumbnail);
name = gimp_thumb_name_from_uri (thumbnail->image_uri, GIMP_THUMB_SIZE_FAIL);
if (! name)
return TRUE;
if (! gimp_thumb_ensure_thumb_dir (GIMP_THUMB_SIZE_FAIL, error))
{
g_free (name);
return FALSE;
}
pixbuf = gdk_pixbuf_new (GDK_COLORSPACE_RGB, FALSE, 8, 1, 1);
desc = g_strdup_printf ("Thumbnail failure for %s", thumbnail->image_uri);
time_str = g_strdup_printf ("%" G_GINT64_FORMAT, thumbnail->image_mtime);
size_str = g_strdup_printf ("%" G_GINT64_FORMAT, thumbnail->image_filesize);
success = gdk_pixbuf_save (pixbuf, name, "png", error,
TAG_DESCRIPTION, desc,
TAG_SOFTWARE, software,
TAG_THUMB_URI, thumbnail->image_uri,
TAG_THUMB_MTIME, time_str,
TAG_THUMB_FILESIZE, size_str,
NULL);
if (success)
{
success = (g_chmod (name, 0600) == 0);
if (success)
gimp_thumbnail_update_thumb (thumbnail, GIMP_THUMB_SIZE_NORMAL);
else
g_set_error (error, G_FILE_ERROR, g_file_error_from_errno (errno),
"Could not set permissions of thumbnail '%s': %s",
name, g_strerror (errno));
}
g_object_unref (pixbuf);
g_free (size_str);
g_free (time_str);
g_free (desc);
g_free (name);
return success;
}
static void job_check_func (gpointer data, gpointer user_data)
{
Job *job = (Job *)data;
Gstreamill *gstreamill = (Gstreamill *)user_data;
if (gstreamill->stop) {
GST_ERROR ("waitting %s stopped", job->name);
return;
}
/* stat report. */
if (gstreamill->daemon && (job->worker_pid != 0)) {
job_stat_update (job);
GST_INFO ("Job %s's average cpu: %d%%, cpu: %d%%, rss: %d",
job->name,
job->cpu_average,
job->cpu_current,
job->memory);
}
if (*(job->output->state) != GST_STATE_PLAYING) {
return;
}
source_check (gstreamill, job);
encoders_check (gstreamill, job);
if (job->is_live) {
sync_check (gstreamill, job);
}
/* check non live job eos */
if (!job->is_live) {
gint i;
gboolean eos = TRUE;
for (i = 0; i < job->output->encoder_count; i++) {
if (!(*(job->output->encoders[i].eos))) {
eos = FALSE;
break;
} else {
/* add #EXT-X-ENDLIST to encodrs.i.hlssink.propery.playlist-location */
gchar *location, *property, *playlist1, *playlist2;
property = g_strdup_printf ("encoder.%d.elements.hlssink.property.playlist-location", i);
location = jobdesc_element_property_value (job->description, property);
g_file_get_contents (location, &playlist1, NULL, NULL);
playlist2 = g_strdup_printf ("%s#EXT-X-ENDLIST\n", playlist1);
g_file_set_contents (location, playlist2, strlen(playlist2), NULL);
g_free (playlist1);
g_free (playlist2);
g_free (property);
}
}
if (eos) {
stop_job (job, SIGUSR2);
job->eos = TRUE;
}
}
}
* }
*
*/
gchar * gstreamill_stat (Gstreamill *gstreamill)
{
gchar *template = "{\n"
" \"version\": \"%s\",\n"
" \"builddate\": %s,\n"
" \"buildtime\": %s,\n"
" \"starttime\": %s,\n"
" \"job\": %s]\n}\n";
gchar *stat, *jobarray, *p;
GSList *list;
Job *job;
jobarray = g_strdup_printf ("[");
g_mutex_lock (&(gstreamill->job_list_mutex));
list = gstreamill->job_list;
while (list != NULL) {
job = list->data;
p = jobarray;
jobarray = g_strdup_printf ("%s\"%s\"", p, job->name);
g_free (p);
list = list->next;
if (list != NULL) {
p = jobarray;
jobarray = g_strdup_printf ("%s,", p);
g_free (p);
}
}
g_mutex_unlock (&(gstreamill->job_list_mutex));
static gboolean
gdk_gix_screen_get_setting (GdkScreen *screen,
const gchar *name,
GValue *value)
{
g_return_val_if_fail (GDK_IS_SCREEN (screen), FALSE);
/*
* XXX : if these values get changed through the Windoze UI the
* respective gdk_events are not generated yet.
*/
if (strcmp ("gtk-theme-name", name) == 0)
{
g_value_set_string (value, "ms-windows");
}
else if (strcmp ("gtk-double-click-time", name) == 0)
{
//gint i = GetDoubleClickTime ();
//GDK_NOTE(MISC, g_print("gdk_screen_get_setting(\"%s\") : %d\n", name, i));
//g_value_set_int (value, i);
return FALSE;
}
else if (strcmp ("gtk-double-click-distance", name) == 0)
{
//gint i = MAX(GetSystemMetrics (SM_CXDOUBLECLK), GetSystemMetrics (SM_CYDOUBLECLK));
//GDK_NOTE(MISC, g_print("gdk_screen_get_setting(\"%s\") : %d\n", name, i));
//g_value_set_int (value, i);
return FALSE;
}
else if (strcmp ("gtk-dnd-drag-threshold", name) == 0)
{
//gint i = MAX(GetSystemMetrics (SM_CXDRAG), GetSystemMetrics (SM_CYDRAG));
//GDK_NOTE(MISC, g_print("gdk_screen_get_setting(\"%s\") : %d\n", name, i));
//g_value_set_int (value, i);
return FALSE;
}
else if (strcmp ("gtk-split-cursor", name) == 0)
{
GDK_NOTE(MISC, g_print("gdk_screen_get_setting(\"%s\") : FALSE\n", name));
g_value_set_boolean (value, FALSE);
return TRUE;
}
else if (strcmp ("gtk-alternative-button-order", name) == 0)
{
GDK_NOTE(MISC, g_print("gdk_screen_get_setting(\"%s\") : TRUE\n", name));
g_value_set_boolean (value, TRUE);
return TRUE;
}
else if (strcmp ("gtk-alternative-sort-arrows", name) == 0)
{
GDK_NOTE(MISC, g_print("gdk_screen_get_setting(\"%s\") : TRUE\n", name));
g_value_set_boolean (value, TRUE);
return TRUE;
}
#if 0
/*
* With 'MS Sans Serif' as windows menu font (default on win98se) you'll get a
* bunch of :
* WARNING **: Couldn't load font "MS Sans Serif 8" falling back to "Sans 8"
* at least with testfilechooser (regardless of the bitmap check below)
* so just disabling this code seems to be the best we can do --hb
*/
else if (strcmp ("gtk-font-name", name) == 0)
{
NONCLIENTMETRICS ncm;
ncm.cbSize = sizeof(NONCLIENTMETRICS);
if (SystemParametersInfo (SPI_GETNONCLIENTMETRICS, ncm.cbSize, &ncm, FALSE))
{
/* Pango finally uses GetDeviceCaps to scale, we use simple
* approximation here.
*/
int nHeight = (0 > ncm.lfMenuFont.lfHeight ? -3*ncm.lfMenuFont.lfHeight/4 : 10);
if (OUT_STRING_PRECIS == ncm.lfMenuFont.lfOutPrecision)
GDK_NOTE(MISC, g_print("gdk_screen_get_setting(%s) : ignoring bitmap font '%s'\n",
name, ncm.lfMenuFont.lfFaceName));
else if (ncm.lfMenuFont.lfFaceName && strlen(ncm.lfMenuFont.lfFaceName) > 0 &&
/* Avoid issues like those described in bug #135098 */
g_utf8_validate (ncm.lfMenuFont.lfFaceName, -1, NULL))
{
char* s = g_strdup_printf ("%s %d", ncm.lfMenuFont.lfFaceName, nHeight);
GDK_NOTE(MISC, g_print("gdk_screen_get_setting(%s) : %s\n", name, s));
g_value_set_string (value, s);
g_free(s);
return TRUE;
}
}
}
#endif
return FALSE;
}
static GstBusSyncReply
bus_callback (GstBus * bus, GstMessage * message, gpointer data)
{
const GstStructure *st;
const GValue *image;
GstBuffer *buf = NULL;
guint8 *data_buf = NULL;
gchar *caps_string;
guint size = 0;
gchar *preview_filename = NULL;
FILE *f = NULL;
size_t written;
switch (GST_MESSAGE_TYPE (message)) {
case GST_MESSAGE_ERROR:{
GError *err;
gchar *debug;
gst_message_parse_error (message, &err, &debug);
g_print ("Error: %s\n", err->message);
g_error_free (err);
g_free (debug);
/* Write debug graph to file */
GST_DEBUG_BIN_TO_DOT_FILE_WITH_TS (GST_BIN (camera_bin),
GST_DEBUG_GRAPH_SHOW_ALL, "camerabin.error");
g_main_loop_quit (loop);
break;
}
case GST_MESSAGE_STATE_CHANGED:
if (GST_IS_BIN (GST_MESSAGE_SRC (message))) {
GstState oldstate, newstate;
gst_message_parse_state_changed (message, &oldstate, &newstate, NULL);
GST_DEBUG_OBJECT (GST_MESSAGE_SRC (message), "state-changed: %s -> %s",
gst_element_state_get_name (oldstate),
gst_element_state_get_name (newstate));
}
break;
case GST_MESSAGE_EOS:
/* end-of-stream */
GST_INFO ("got eos() - should not happen");
g_main_loop_quit (loop);
break;
default:
st = gst_message_get_structure (message);
if (st) {
if (gst_structure_has_name (message->structure, "prepare-xwindow-id")) {
if (window) {
gst_x_overlay_set_xwindow_id (GST_X_OVERLAY (GST_MESSAGE_SRC
(message)), window);
gst_message_unref (message);
message = NULL;
return GST_BUS_DROP;
}
} else if (gst_structure_has_name (st, "image-captured")) {
GST_DEBUG ("image-captured");
} else if (gst_structure_has_name (st, "preview-image")) {
GST_DEBUG ("preview-image");
//extract preview-image from msg
image = gst_structure_get_value (st, "buffer");
if (image) {
buf = gst_value_get_buffer (image);
data_buf = GST_BUFFER_DATA (buf);
size = GST_BUFFER_SIZE (buf);
preview_filename = g_strdup_printf ("test_vga.rgb");
caps_string = gst_caps_to_string (GST_BUFFER_CAPS (buf));
g_print ("writing buffer to %s, buffer caps: %s\n",
preview_filename, caps_string);
g_free (caps_string);
f = g_fopen (preview_filename, "w");
if (f) {
written = fwrite (data_buf, size, 1, f);
if (!written) {
g_print ("errro writing file\n");
}
fclose (f);
} else {
g_print ("error opening file for raw image writing\n");
}
g_free (preview_filename);
}
}
}
/* unhandled message */
break;
}
return GST_BUS_PASS;
}
static BraseroBurnResult
brasero_readom_set_argv (BraseroProcess *process,
GPtrArray *argv,
GError **error)
{
BraseroBurnResult result = FALSE;
BraseroTrackType *output = NULL;
BraseroImageFormat format;
BraseroJobAction action;
BraseroReadom *readom;
BraseroMedium *medium;
BraseroDrive *drive;
BraseroTrack *track;
BraseroMedia media;
gchar *outfile_arg;
gchar *dev_str;
readom = BRASERO_READOM (process);
/* This is a kind of shortcut */
brasero_job_get_action (BRASERO_JOB (process), &action);
if (action == BRASERO_JOB_ACTION_SIZE)
return brasero_readom_get_size (readom, error);
g_ptr_array_add (argv, g_strdup ("readom"));
brasero_job_get_current_track (BRASERO_JOB (readom), &track);
drive = brasero_track_disc_get_drive (BRASERO_TRACK_DISC (track));
if (!brasero_drive_get_device (drive))
return BRASERO_BURN_ERR;
dev_str = g_strdup_printf ("dev=%s", brasero_drive_get_device (drive));
g_ptr_array_add (argv, dev_str);
g_ptr_array_add (argv, g_strdup ("-nocorr"));
medium = brasero_drive_get_medium (drive);
media = brasero_medium_get_status (medium);
output = brasero_track_type_new ();
brasero_job_get_output_type (BRASERO_JOB (readom), output);
format = brasero_track_type_get_image_format (output);
brasero_track_type_free (output);
if ((media & BRASERO_MEDIUM_DVD)
&& format != BRASERO_IMAGE_FORMAT_BIN) {
g_set_error (error,
BRASERO_BURN_ERROR,
BRASERO_BURN_ERROR_GENERAL,
_("An internal error occurred"));
return BRASERO_BURN_ERR;
}
if (format == BRASERO_IMAGE_FORMAT_CLONE) {
/* NOTE: with this option the sector size is 2448
* because it is raw96 (2352+96) otherwise it is 2048 */
g_ptr_array_add (argv, g_strdup ("-clone"));
}
else if (format == BRASERO_IMAGE_FORMAT_BIN) {
g_ptr_array_add (argv, g_strdup ("-noerror"));
/* don't do it for clone since we need the entire disc */
result = brasero_readom_argv_set_iso_boundary (readom, argv, error);
if (result != BRASERO_BURN_OK)
return result;
}
else
BRASERO_JOB_NOT_SUPPORTED (readom);
if (brasero_job_get_fd_out (BRASERO_JOB (readom), NULL) != BRASERO_BURN_OK) {
gchar *image;
if (format != BRASERO_IMAGE_FORMAT_CLONE
&& format != BRASERO_IMAGE_FORMAT_BIN)
BRASERO_JOB_NOT_SUPPORTED (readom);
result = brasero_job_get_image_output (BRASERO_JOB (readom),
&image,
NULL);
if (result != BRASERO_BURN_OK)
return result;
outfile_arg = g_strdup_printf ("-f=%s", image);
g_ptr_array_add (argv, outfile_arg);
g_free (image);
}
else if (format == BRASERO_IMAGE_FORMAT_BIN) {
outfile_arg = g_strdup ("-f=-");
g_ptr_array_add (argv, outfile_arg);
}
else /* unfortunately raw images can't be piped out */
BRASERO_JOB_NOT_SUPPORTED (readom);
brasero_job_set_use_average_rate (BRASERO_JOB (process), TRUE);
return BRASERO_BURN_OK;
}
int
main (int argc, char *argv[])
{
GError *error;
GOptionContext *context;
GFile *source, *dest, *target;
gboolean dest_is_dir;
char *basename;
int i;
GFileCopyFlags flags;
int retval = 0;
gchar *param;
gchar *summary;
setlocale (LC_ALL, "");
bindtextdomain (GETTEXT_PACKAGE, GVFS_LOCALEDIR);
bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
textdomain (GETTEXT_PACKAGE);
error = NULL;
param = g_strdup_printf ("%s... %s", _("SOURCE"), _("DEST"));
summary = _("Move one or more files from SOURCE to DEST.");
context = g_option_context_new (param);
g_option_context_set_summary (context, summary);
g_option_context_add_main_entries (context, entries, GETTEXT_PACKAGE);
g_option_context_parse (context, &argc, &argv, &error);
if (error != NULL)
{
g_printerr (_("Error parsing commandline options: %s\n"), error->message);
g_printerr ("\n");
g_printerr (_("Try \"%s --help\" for more information."), g_get_prgname ());
g_printerr ("\n");
g_error_free (error);
return 1;
}
if (argc <= 2)
{
show_help (context, _("Missing operand\n"));
return 1;
}
dest = g_file_new_for_commandline_arg (argv[argc-1]);
if (no_target_directory && argc > 3)
{
show_help (context, _("Too many arguments\n"));
g_object_unref (dest);
return 1;
}
dest_is_dir = is_dir (dest);
if (!dest_is_dir && argc > 3)
{
g_printerr (_("Target %s is not a directory\n"), argv[argc-1]);
show_help (context, NULL);
g_object_unref (dest);
return 1;
}
g_option_context_free (context);
g_free (param);
for (i = 1; i < argc - 1; i++)
{
source = g_file_new_for_commandline_arg (argv[i]);
if (dest_is_dir && !no_target_directory)
{
basename = g_file_get_basename (source);
target = g_file_get_child (dest, basename);
g_free (basename);
}
else
target = g_object_ref (dest);
flags = 0;
if (backup)
flags |= G_FILE_COPY_BACKUP;
if (!interactive)
flags |= G_FILE_COPY_OVERWRITE;
error = NULL;
if (!g_file_move (source, target, flags, NULL, progress?show_progress:NULL, NULL, &error))
{
if (interactive && g_error_matches (error, G_IO_ERROR, G_IO_ERROR_EXISTS))
{
char line[16];
g_error_free (error);
error = NULL;
basename = g_file_get_basename (target);
g_print ("overwrite %s?", basename);
g_free (basename);
if (fgets(line, sizeof (line), stdin) &&
line[0] == 'y')
{
flags |= G_FILE_COPY_OVERWRITE;
if (!g_file_move (source, target, flags, NULL, NULL, NULL, &error))
goto move_failed;
}
}
else
{
move_failed:
g_printerr (_("Error moving file %s: %s\n"), argv[i], error->message);
g_error_free (error);
retval = 1;
}
}
g_object_unref (source);
g_object_unref (target);
}
g_object_unref (dest);
return retval;
}
/**
* uploading function executed by the background" thread
*/
static void osm_traces_upload_thread ( OsmTracesInfo *oti, gpointer threaddata )
{
/* Due to OSM limits, we have to enforce ele and time fields */
static GpxWritingOptions options = { TRUE, TRUE };
FILE *file = NULL;
gchar *filename = NULL;
int fd;
GError *error = NULL;
int ret;
g_assert(oti != NULL);
/* Opening temporary file */
fd = g_file_open_tmp("viking_osm_upload_XXXXXX.gpx", &filename, &error);
if (fd < 0) {
g_error(_("failed to open temporary file: %s"), strerror(errno));
return;
}
g_clear_error(&error);
g_debug("%s: temporary file = %s", __FUNCTION__, filename);
/* Creating FILE* */
file = fdopen(fd, "w");
/* writing gpx file */
if (oti->track_name != NULL)
{
/* Upload only the selected track */
VikTrack *track = vik_trw_layer_get_track(oti->vtl, oti->track_name);
a_gpx_write_track_file_options(&options, oti->track_name, track, file);
}
else
{
/* Upload the whole VikTrwLayer */
a_gpx_write_file_options(&options, oti->vtl, file);
}
/* We can close the file */
/* This also close the associated fd */
fclose(file);
file = NULL;
/* finally, upload it */
gint ans = osm_traces_upload_file(user, password, filename,
oti->name, oti->description, oti->tags, oti->vistype);
//
// Show result in statusbar or failure in dialog for user feedback
//
// Get current time to put into message to show when result was generated
// since need to show difference between operations (when displayed on statusbar)
// NB If on dialog then don't need time.
time_t timenow;
struct tm* timeinfo;
time ( &timenow );
timeinfo = localtime ( &timenow );
gchar timestr[80];
// Compact time only - as days/date isn't very useful here
strftime ( timestr, sizeof(timestr), "%X)", timeinfo );
//
// Test to see if window it was invoked on is still valid
// Not sure if this test really works! (i.e. if the window was closed in the mean time)
//
if ( IS_VIK_WINDOW ((VikWindow *)VIK_GTK_WINDOW_FROM_LAYER(oti->vtl)) ) {
gchar* msg;
if ( ans == 0 ) {
// Success
msg = g_strdup_printf ( "%s (@%s)", _("Uploaded to OSM"), timestr );
vik_statusbar_set_message ( vik_window_get_statusbar ( (VikWindow *)VIK_GTK_WINDOW_FROM_LAYER(oti->vtl) ), VIK_STATUSBAR_INFO, msg );
}
// Use UPPER CASE for bad news :(
else if ( ans < 0 ) {
msg = g_strdup_printf ( "%s (@%s)", _("FAILED TO UPLOAD DATA TO OSM - CURL PROBLEM"), timestr );
vik_statusbar_set_message ( vik_window_get_statusbar ( (VikWindow *)VIK_GTK_WINDOW_FROM_LAYER(oti->vtl) ), VIK_STATUSBAR_INFO, msg );
//a_dialog_error_msg ( VIK_GTK_WINDOW_FROM_LAYER(oti->vtl), msg );
}
else {
msg = g_strdup_printf ( "%s : %s %d (@%s)", _("FAILED TO UPLOAD DATA TO OSM"), _("HTTP response code"), ans, timestr );
vik_statusbar_set_message ( vik_window_get_statusbar ( (VikWindow *)VIK_GTK_WINDOW_FROM_LAYER(oti->vtl) ), VIK_STATUSBAR_INFO, msg );
//VikTrwLayer *vtl = oti->vtl;
// Crashes here - multi-thread issue...
//a_dialog_error_msg ( VIK_GTK_WINDOW_FROM_LAYER(vtl), msg );
}
g_free (msg);
}
/* Removing temporary file */
ret = g_unlink(filename);
if (ret != 0) {
g_error(_("failed to unlink temporary file: %s"), strerror(errno));
}
}
// got HttpConnection object
static void fileio_release_on_part_con_cb (gpointer client, gpointer ctx)
{
HttpConnection *con = (HttpConnection *) client;
FileIO *fop = (FileIO *) ctx;
gchar *path;
gboolean res;
FileIOPart *part;
size_t buf_len;
const gchar *buf;
LOG_debug (FIO_LOG, INO_CON_H"Releasing fop. Size: %zu", INO_T (fop->ino), con, evbuffer_get_length (fop->write_buf));
// add part information to the list
part = g_new0 (FileIOPart, 1);
part->part_number = fop->part_number;
buf_len = evbuffer_get_length (fop->write_buf);
buf = (const gchar *)evbuffer_pullup (fop->write_buf, buf_len);
// XXX: move to separate thread
// 1. calculate MD5 of a part.
get_md5_sum (buf, buf_len, &part->md5str, &part->md5b);
// 2. calculate MD5 of multiple message blocks
MD5_Update (&fop->md5, buf, buf_len);
fop->l_parts = g_list_append (fop->l_parts, part);
// if this is a multipart
if (fop->multipart_initiated) {
if (!fop->uploadid) {
LOG_err (FIO_LOG, INO_CON_H"UploadID is not set, aborting operation !", INO_T (fop->ino), con);
fileio_destroy (fop);
return;
}
path = g_strdup_printf ("%s?partNumber=%u&uploadId=%s",
fop->fname, fop->part_number, fop->uploadid);
fop->part_number++;
} else {
path = g_strdup (fop->fname);
}
#ifdef MAGIC_ENABLED
// guess MIME type
gchar *mime_type = magic_buffer (application_get_magic_ctx (fop->app), buf, buf_len);
if (mime_type) {
LOG_debug (FIO_LOG, "Guessed MIME type of %s as %s", path, mime_type);
fop->content_type = g_strdup (mime_type);
} else {
LOG_err (FIO_LOG, "Failed to guess MIME type of %s !", path);
}
#endif
http_connection_acquire (con);
// add output headers
http_connection_add_output_header (con, "Content-MD5", part->md5b);
if (fop->content_type)
http_connection_add_output_header (con, "Content-Type", fop->content_type);
// if this is the full file
if (!fop->multipart_initiated) {
time_t t;
gchar time_str[50];
// Add current time
t = time (NULL);
if (strftime (time_str, sizeof (time_str), "%a, %d %b %Y %H:%M:%S GMT", gmtime(&t))) {
http_connection_add_output_header (con, "x-amz-meta-date", time_str);
}
http_connection_add_output_header (con, "x-amz-storage-class", conf_get_string (application_get_conf (con->app), "s3.storage_type"));
}
res = http_connection_make_request (con,
path, "PUT", fop->write_buf, TRUE, NULL,
fileio_release_on_part_sent_cb,
fop
);
g_free (path);
if (!res) {
LOG_err (FIO_LOG, INO_CON_H"Failed to create HTTP request !", INO_T (fop->ino), con);
http_connection_release (con);
fileio_destroy (fop);
return;
}
}
/**
* Uploading a VikTrwLayer
*
* @param vtl VikTrwLayer
* @param track_name if not null, the name of the track to upload
*/
static void osm_traces_upload_viktrwlayer ( VikTrwLayer *vtl, const gchar *track_name )
{
GtkWidget *dia = gtk_dialog_new_with_buttons (_("OSM upload"),
VIK_GTK_WINDOW_FROM_LAYER(vtl),
GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_STOCK_CANCEL,
GTK_RESPONSE_REJECT,
GTK_STOCK_OK,
GTK_RESPONSE_ACCEPT,
NULL);
const gchar *default_user = get_default_user();
const gchar *pref_user = a_preferences_get(VIKING_OSM_TRACES_PARAMS_NAMESPACE "username")->s;
const gchar *pref_password = a_preferences_get(VIKING_OSM_TRACES_PARAMS_NAMESPACE "password")->s;
const gchar *name = NULL;
GtkWidget *user_label, *user_entry;
GtkWidget *password_label, *password_entry;
GtkWidget *name_label, *name_entry;
GtkWidget *description_label, *description_entry;
GtkWidget *tags_label, *tags_entry;
GtkComboBox *visibility;
const OsmTraceVis_t *vis_t;
user_label = gtk_label_new(_("Email:"));
user_entry = gtk_entry_new();
if (user != NULL && user[0] != '\0')
gtk_entry_set_text(GTK_ENTRY(user_entry), user);
else if (pref_user != NULL && pref_user[0] != '\0')
gtk_entry_set_text(GTK_ENTRY(user_entry), pref_user);
else if (default_user != NULL)
gtk_entry_set_text(GTK_ENTRY(user_entry), default_user);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dia)->vbox), user_label, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dia)->vbox), user_entry, FALSE, FALSE, 0);
gtk_widget_set_tooltip_markup(GTK_WIDGET(user_entry),
_("The email used as login\n"
"<small>Enter the email you use to login into www.openstreetmap.org.</small>"));
password_label = gtk_label_new(_("Password:"******"The password used to login\n"
"<small>Enter the password you use to login into www.openstreetmap.org.</small>"));
name_label = gtk_label_new(_("File's name:"));
name_entry = gtk_entry_new();
if (track_name != NULL)
name = track_name;
else
name = vik_layer_get_name(VIK_LAYER(vtl));
gtk_entry_set_text(GTK_ENTRY(name_entry), name);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dia)->vbox), name_label, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dia)->vbox), name_entry, FALSE, FALSE, 0);
gtk_widget_set_tooltip_markup(GTK_WIDGET(name_entry),
_("The name of the file on OSM\n"
"<small>This is the name of the file created on the server."
"This is not the name of the local file.</small>"));
description_label = gtk_label_new(_("Description:"));
description_entry = gtk_entry_new();
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dia)->vbox), description_label, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dia)->vbox), description_entry, FALSE, FALSE, 0);
gtk_widget_set_tooltip_text(GTK_WIDGET(description_entry),
_("The description of the trace"));
tags_label = gtk_label_new(_("Tags:"));
tags_entry = gtk_entry_new();
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dia)->vbox), tags_label, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dia)->vbox), tags_entry, FALSE, FALSE, 0);
gtk_widget_set_tooltip_text(GTK_WIDGET(tags_entry),
_("The tags associated to the trace"));
visibility = GTK_COMBO_BOX(gtk_combo_box_new_text ());
for (vis_t = OsmTraceVis; vis_t->combostr != NULL; vis_t++)
gtk_combo_box_append_text(visibility, vis_t->combostr);
/* Set identifiable by default */
gtk_combo_box_set_active(visibility, 0);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dia)->vbox), GTK_WIDGET(visibility), FALSE, FALSE, 0);
/* User should think about it first... */
gtk_dialog_set_default_response ( GTK_DIALOG(dia), GTK_RESPONSE_REJECT );
gtk_widget_show_all ( dia );
gtk_widget_grab_focus ( description_entry );
if ( gtk_dialog_run ( GTK_DIALOG(dia) ) == GTK_RESPONSE_ACCEPT )
{
gchar *title = NULL;
/* overwrite authentication info */
set_login(gtk_entry_get_text(GTK_ENTRY(user_entry)),
gtk_entry_get_text(GTK_ENTRY(password_entry)));
/* Storing data for the future thread */
OsmTracesInfo *info = g_malloc(sizeof(OsmTracesInfo));
info->name = g_strdup(gtk_entry_get_text(GTK_ENTRY(name_entry)));
info->description = g_strdup(gtk_entry_get_text(GTK_ENTRY(description_entry)));
/* TODO Normalize tags: they will be used as URL part */
info->tags = g_strdup(gtk_entry_get_text(GTK_ENTRY(tags_entry)));
info->vistype = &OsmTraceVis[gtk_combo_box_get_active(visibility)];
info->vtl = VIK_TRW_LAYER(g_object_ref(vtl));
info->track_name = (track_name == NULL) ? NULL : g_strdup(track_name);
title = g_strdup_printf(_("Uploading %s to OSM"), info->name);
/* launch the thread */
a_background_thread(VIK_GTK_WINDOW_FROM_LAYER(vtl), /* parent window */
title, /* description string */
(vik_thr_func) osm_traces_upload_thread, /* function to call within thread */
info, /* pass along data */
(vik_thr_free_func) oti_free, /* function to free pass along data */
(vik_thr_free_func) NULL,
1 );
g_free ( title ); title = NULL;
}
gtk_widget_destroy ( dia );
}
static gint smtp_auth_recv(SMTPSession *session, const gchar *msg)
{
gchar buf[MESSAGEBUFSIZE];
switch (session->auth_type) {
case SMTPAUTH_LOGIN:
session->state = SMTP_AUTH_LOGIN_USER;
if (!strncmp(msg, "334 ", 4)) {
base64_encode(buf, session->user, strlen(session->user));
if (session_send_msg(SESSION(session), SESSION_MSG_NORMAL,
buf) < 0)
return SM_ERROR;
log_print(LOG_PROTOCOL, "ESMTP> [USERID]\n");
} else {
/* Server rejects AUTH */
if (session_send_msg(SESSION(session), SESSION_MSG_NORMAL,
"*") < 0)
return SM_ERROR;
log_print(LOG_PROTOCOL, "ESMTP> *\n");
}
break;
case SMTPAUTH_CRAM_MD5:
session->state = SMTP_AUTH_CRAM_MD5;
if (!strncmp(msg, "334 ", 4)) {
gchar *response;
gchar *response64;
gchar *challenge;
gint challengelen;
guchar hexdigest[33];
challenge = g_malloc(strlen(msg + 4) + 1);
challengelen = base64_decode(challenge, msg + 4, -1);
challenge[challengelen] = '\0';
log_print(LOG_PROTOCOL, "ESMTP< [Decoded: %s]\n", challenge);
g_snprintf(buf, sizeof(buf), "%s", session->pass);
md5_hex_hmac(hexdigest, challenge, challengelen,
buf, strlen(session->pass));
g_free(challenge);
response = g_strdup_printf
("%s %s", session->user, hexdigest);
log_print(LOG_PROTOCOL, "ESMTP> [Encoded: %s]\n", response);
response64 = g_malloc((strlen(response) + 3) * 2 + 1);
base64_encode(response64, response, strlen(response));
g_free(response);
if (session_send_msg(SESSION(session), SESSION_MSG_NORMAL,
response64) < 0)
return SM_ERROR;
log_print(LOG_PROTOCOL, "ESMTP> %s\n", response64);
g_free(response64);
} else {
/* Server rejects AUTH */
if (session_send_msg(SESSION(session), SESSION_MSG_NORMAL,
"*") < 0)
return SM_ERROR;
log_print(LOG_PROTOCOL, "ESMTP> *\n");
}
break;
case SMTPAUTH_DIGEST_MD5:
default:
/* stop smtp_auth when no correct authtype */
if (session_send_msg(SESSION(session), SESSION_MSG_NORMAL, "*") < 0)
return SM_ERROR;
log_print(LOG_PROTOCOL, "ESMTP> *\n");
break;
}
return SM_OK;
}
void
restraint_append_message (SoupSession *session,
SoupMessage *msg,
gpointer msg_data,
MessageFinishCallback finish_callback,
GCancellable *cancellable,
gpointer user_data)
{
ClientData *client_data = (ClientData *) msg_data;
time_t result;
result = time(NULL);
static time_t transaction_id = 0;
// calculate the transaction id. base it off of epoch
// incase the host reboots we shouldn't collide
if (transaction_id == 0) {
transaction_id = result;
}
GString *body = g_string_new("");
MessageData *message_data;
message_data = g_slice_new0 (MessageData);
message_data->msg = msg;
message_data->user_data = user_data;
message_data->finish_callback = finish_callback;
if (!g_cancellable_is_cancelled (cancellable)) {
SoupURI *uri = soup_message_get_uri (msg);
soup_message_headers_foreach (msg->request_headers, append_header,
body);
// if we are doing a POST transaction
// increment transaction_id and add it to headers
// populate Location header in msg->reponse_headers
const gchar *path = soup_uri_get_path (uri);
if (g_strcmp0 (msg->method, "POST") == 0) {
g_string_append_printf (body,
"transaction-id: %jd\n", (intmax_t) transaction_id);
gchar *location_url = g_strdup_printf ("%s%jd", path, (intmax_t) transaction_id);
soup_message_headers_append (msg->response_headers, "Location", location_url);
g_free (location_url);
transaction_id++;
}
soup_message_set_status (msg, SOUP_STATUS_OK);
g_string_append_printf (body,
"rstrnt-path: %s\n"
"rstrnt-method: %s\n"
"Content-Length: %d\r\n\r\n",
path,
msg->method,
(guint) msg->request_body->length);
SoupBuffer *request = soup_message_body_flatten (msg->request_body);
body = g_string_append_len (body, request->data,
request->length);
g_string_append_printf (body,
"\r\n--cut-here\n");
soup_buffer_free (request);
soup_message_body_append (client_data->client_msg->response_body,
SOUP_MEMORY_TAKE,
body->str, body->len);
g_string_free (body, FALSE);
soup_server_unpause_message (client_data->server, client_data->client_msg);
}
if (finish_callback) {
g_idle_add_full (G_PRIORITY_DEFAULT_IDLE,
message_finish,
message_data,
message_destroy);
} else {
g_object_unref (msg);
message_destroy (message_data);
}
}
void HTTP::encode_request(const Attribute& m_attr)
{
char *tmp = g_strdup_printf("GET %s%s HTTP/1.1", m_attr.get_dir()->c_str(),m_attr.get_file_name()->c_str());
cout<<tmp<<endl;
}
/* SYNTAX: DCC SEND <nick> <file> */
static void cmd_dcc_send(const char *data, IRC_SERVER_REC *server, WI_IRC_REC *item)
{
char *target, *fname, *str, *ptr;
void *free_arg;
char host[MAX_IP_LEN];
int hfile, hlisten, port;
long fsize;
DCC_REC *dcc, *chat;
IPADDR own_ip;
g_return_if_fail(data != NULL);
if (!cmd_get_params(data, &free_arg, 2 | PARAM_FLAG_GETREST, &target, &fname))
return;
if (*target == '\0' || *fname == '\0') cmd_param_error(CMDERR_NOT_ENOUGH_PARAMS);
/* if we're in dcc chat, send the request via it. */
chat = item_get_dcc(item);
if (chat != NULL && (chat->mirc_ctcp || g_strcasecmp(target, chat->nick) != 0))
chat = NULL;
if ((server == NULL || !server->connected) && chat == NULL)
cmd_param_error(CMDERR_NOT_CONNECTED);
if (dcc_find_item(DCC_TYPE_SEND, target, fname)) {
signal_emit("dcc error send exists", 2, target, fname);
cmd_params_free(free_arg);
return;
}
str = convert_home(fname);
if (!g_path_is_absolute(str)) {
char *path;
g_free(str);
path = convert_home(settings_get_str("dcc_upload_path"));
str = g_strconcat(path, G_DIR_SEPARATOR_S, fname, NULL);
g_free(path);
}
hfile = open(str, O_RDONLY);
g_free(str);
if (hfile == -1) {
signal_emit("dcc error file not found", 2, target, fname);
cmd_params_free(free_arg);
return;
}
fsize = lseek(hfile, 0, SEEK_END);
lseek(hfile, 0, SEEK_SET);
/* get the IP address we use with IRC server */
if (net_getsockname(chat != NULL ? chat->handle : net_sendbuffer_handle(server->handle), &own_ip, NULL) == -1) {
close(hfile);
cmd_param_error(CMDERR_ERRNO);
}
/* start listening */
port = settings_get_int("dcc_port");
hlisten = net_listen(&own_ip, &port);
if (hlisten == -1) {
close(hfile);
cmd_param_error(CMDERR_ERRNO);
}
/* skip path, change all spaces to _ */
fname = g_strdup(g_basename(fname));
for (ptr = fname; *ptr != '\0'; ptr++)
if (*ptr == ' ') *ptr = '_';
dcc = dcc_create(DCC_TYPE_SEND, hlisten, target, fname, server, chat);
dcc->port = port;
dcc->size = fsize;
dcc->fhandle = hfile;
dcc->tagconn = g_input_add(hlisten, G_INPUT_READ,
(GInputFunction) dcc_send_init, dcc);
/* send DCC request */
dcc_make_address(&own_ip, host);
str = g_strdup_printf("DCC SEND %s %s %d %lu",
fname, host, port, fsize);
dcc_ctcp_message(target, server, chat, FALSE, str);
g_free(str);
g_free(fname);
cmd_params_free(free_arg);
}
gchar *
tracker_glong_to_string (glong i)
{
return g_strdup_printf ("%ld", i);
}
/**
* thunar_dialogs_show_job_ask_replace:
* @parent : the parent #GtkWindow or %NULL.
* @src_file : the #ThunarFile of the source file.
* @dst_file : the #ThunarFile of the destination file that
* may be replaced with the source file.
*
* Asks the user whether to replace the destination file with the
* source file identified by @src_file.
*
* Return value: the selected #ThunarJobResponse.
**/
ThunarJobResponse
thunar_dialogs_show_job_ask_replace (GtkWindow *parent,
ThunarFile *src_file,
ThunarFile *dst_file)
{
ThunarIconFactory *icon_factory;
ThunarPreferences *preferences;
ThunarDateStyle date_style;
GtkIconTheme *icon_theme;
GtkWidget *dialog;
GtkWidget *grid;
GtkWidget *image;
GtkWidget *label;
GdkPixbuf *icon;
gchar *date_custom_style;
gchar *date_string;
gchar *size_string;
gchar *text;
gint response;
gboolean file_size_binary;
_thunar_return_val_if_fail (parent == NULL || GTK_IS_WINDOW (parent), THUNAR_JOB_RESPONSE_CANCEL);
_thunar_return_val_if_fail (THUNAR_IS_FILE (src_file), THUNAR_JOB_RESPONSE_CANCEL);
_thunar_return_val_if_fail (THUNAR_IS_FILE (dst_file), THUNAR_JOB_RESPONSE_CANCEL);
/* determine the style used to format dates */
preferences = thunar_preferences_get ();
g_object_get (G_OBJECT (preferences), "misc-date-style", &date_style, NULL);
g_object_get (G_OBJECT (preferences), "misc-date-custom-style", &date_custom_style, NULL);
g_object_get (G_OBJECT (preferences), "misc-file-size-binary", &file_size_binary, NULL);
g_object_unref (G_OBJECT (preferences));
/* setup the confirmation dialog */
dialog = gtk_dialog_new_with_buttons (_("Confirm to replace files"),
parent,
GTK_DIALOG_MODAL
| GTK_DIALOG_DESTROY_WITH_PARENT,
_("_Cancel"), GTK_RESPONSE_CANCEL,
_("S_kip All"), THUNAR_JOB_RESPONSE_NO_ALL,
_("_Skip"), THUNAR_JOB_RESPONSE_NO,
_("Replace _All"), THUNAR_JOB_RESPONSE_YES_ALL,
_("_Replace"), THUNAR_JOB_RESPONSE_YES,
NULL);
gtk_dialog_set_default_response (GTK_DIALOG (dialog), THUNAR_JOB_RESPONSE_YES);
/* determine the icon factory to use */
icon_theme = gtk_icon_theme_get_for_screen (gtk_widget_get_screen (dialog));
icon_factory = thunar_icon_factory_get_for_icon_theme (icon_theme);
grid = gtk_grid_new ();
gtk_grid_set_column_spacing (GTK_GRID (grid), 5);
gtk_grid_set_row_spacing (GTK_GRID (grid), 6);
gtk_container_set_border_width (GTK_CONTAINER (grid), 10);
gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))), grid, TRUE, TRUE, 0);
gtk_widget_show (grid);
image = gtk_image_new_from_icon_name ("stock_folder-copy", GTK_ICON_SIZE_BUTTON);
gtk_widget_set_halign (image, GTK_ALIGN_CENTER);
gtk_widget_set_valign (image, GTK_ALIGN_START);
gtk_widget_set_margin_start (GTK_WIDGET(image), 6);
gtk_widget_set_margin_end (GTK_WIDGET(image), 6);
gtk_widget_set_margin_top (GTK_WIDGET(image), 6);
gtk_widget_set_margin_bottom (GTK_WIDGET(image), 6);
gtk_widget_set_vexpand (image, TRUE);
gtk_grid_attach (GTK_GRID (grid), image, 0, 0, 1, 1);
gtk_widget_show (image);
if (thunar_file_is_symlink (dst_file))
{
text = g_strdup_printf (_("This folder already contains a symbolic link \"%s\"."),
thunar_file_get_display_name (dst_file));
}
else if (thunar_file_is_directory (dst_file))
{
text = g_strdup_printf (_("This folder already contains a folder \"%s\"."),
thunar_file_get_display_name (dst_file));
}
else
{
text = g_strdup_printf (_("This folder already contains a file \"%s\"."),
thunar_file_get_display_name (dst_file));
}
label = gtk_label_new (text);
gtk_label_set_xalign (GTK_LABEL (label), 0.0f);
gtk_label_set_attributes (GTK_LABEL (label), thunar_pango_attr_list_big ());
gtk_widget_set_hexpand (label, TRUE);
gtk_grid_attach (GTK_GRID (grid), label, 1, 0, 2, 1);
gtk_widget_show (label);
g_free (text);
if (thunar_file_is_symlink (dst_file))
text = g_strdup_printf (Q_("ReplaceDialogPart1|Do you want to replace the link"));
else if (thunar_file_is_directory (dst_file))
text = g_strdup_printf (Q_("ReplaceDialogPart1|Do you want to replace the existing folder"));
else
text = g_strdup_printf (Q_("ReplaceDialogPart1|Do you want to replace the existing file"));
label = gtk_label_new (text);
gtk_label_set_xalign (GTK_LABEL (label), 0.0f);
gtk_widget_set_hexpand (label, TRUE);
gtk_grid_attach (GTK_GRID (grid), label, 1, 1, 2, 1);
gtk_widget_show (label);
g_free (text);
icon = thunar_icon_factory_load_file_icon (icon_factory, dst_file, THUNAR_FILE_ICON_STATE_DEFAULT, 48);
image = gtk_image_new_from_pixbuf (icon);
gtk_widget_set_margin_start (GTK_WIDGET(image), 6);
gtk_widget_set_margin_end (GTK_WIDGET(image), 6);
gtk_widget_set_margin_top (GTK_WIDGET(image), 6);
gtk_widget_set_margin_bottom (GTK_WIDGET(image), 6);
gtk_grid_attach (GTK_GRID (grid), image, 1, 2, 1, 1);
g_object_unref (G_OBJECT (icon));
gtk_widget_show (image);
size_string = thunar_file_get_size_string_long (dst_file, file_size_binary);
date_string = thunar_file_get_date_string (dst_file, THUNAR_FILE_DATE_MODIFIED, date_style, date_custom_style);
text = g_strdup_printf ("%s %s\n%s %s", _("Size:"), size_string, _("Modified:"), date_string);
label = gtk_label_new (text);
gtk_label_set_xalign (GTK_LABEL (label), 0.0f);
gtk_widget_set_hexpand (label, TRUE);
gtk_grid_attach (GTK_GRID (grid), label, 2, 2, 1, 1);
gtk_widget_show (label);
g_free (size_string);
g_free (date_string);
g_free (text);
if (thunar_file_is_symlink (src_file))
text = g_strdup_printf (Q_("ReplaceDialogPart2|with the following link?"));
else if (thunar_file_is_directory (src_file))
text = g_strdup_printf (Q_("ReplaceDialogPart2|with the following folder?"));
else
text = g_strdup_printf (Q_("ReplaceDialogPart2|with the following file?"));
label = gtk_label_new (text);
gtk_label_set_xalign (GTK_LABEL (label), 0.0f);
gtk_widget_set_hexpand (label, TRUE);
gtk_grid_attach (GTK_GRID (grid), label, 1, 3, 2, 1);
gtk_widget_show (label);
g_free (text);
icon = thunar_icon_factory_load_file_icon (icon_factory, src_file, THUNAR_FILE_ICON_STATE_DEFAULT, 48);
image = gtk_image_new_from_pixbuf (icon);
gtk_widget_set_margin_start (GTK_WIDGET(image), 6);
gtk_widget_set_margin_end (GTK_WIDGET(image), 6);
gtk_widget_set_margin_top (GTK_WIDGET(image), 6);
gtk_widget_set_margin_bottom (GTK_WIDGET(image), 6);
gtk_grid_attach (GTK_GRID (grid), image, 1, 4, 1, 1);
g_object_unref (G_OBJECT (icon));
gtk_widget_show (image);
size_string = thunar_file_get_size_string_long (src_file, file_size_binary);
date_string = thunar_file_get_date_string (src_file, THUNAR_FILE_DATE_MODIFIED, date_style, date_custom_style);
text = g_strdup_printf ("%s %s\n%s %s", _("Size:"), size_string, _("Modified:"), date_string);
label = gtk_label_new (text);
gtk_label_set_xalign (GTK_LABEL (label), 0.0f);
gtk_widget_set_hexpand (label, TRUE);
gtk_grid_attach (GTK_GRID (grid), label, 2, 4, 1, 1);
gtk_widget_show (label);
g_free (size_string);
g_free (date_string);
g_free (text);
/* run the dialog */
response = gtk_dialog_run (GTK_DIALOG (dialog));
gtk_widget_destroy (dialog);
/* cleanup */
g_object_unref (G_OBJECT (icon_factory));
/* translate GTK responses */
if (G_UNLIKELY (response < 0))
response = THUNAR_JOB_RESPONSE_CANCEL;
return response;
}
gchar *
tracker_guint32_to_string (guint32 i)
{
return g_strdup_printf ("%" G_GUINT32_FORMAT, i);
}
/**
* thunar_dialogs_show_rename_file:
* @parent : a #GtkWidget on which the error dialog should be shown, or a #GdkScreen
* if no #GtkWidget is known. May also be %NULL, in which case the default
* #GdkScreen will be used.
* @file : the #ThunarFile we're going to rename.
*
* Displays the Thunar rename dialog for a single file rename.
*
* Return value: The #ThunarJob responsible for renaming the file or
* %NULL if there was no renaming required.
**/
ThunarJob *
thunar_dialogs_show_rename_file (gpointer parent,
ThunarFile *file)
{
ThunarIconFactory *icon_factory;
GtkIconTheme *icon_theme;
const gchar *filename;
const gchar *text;
ThunarJob *job = NULL;
GtkWidget *dialog;
GtkWidget *entry;
GtkWidget *label;
GtkWidget *image;
GtkWidget *grid;
GtkWindow *window;
GdkPixbuf *icon;
GdkScreen *screen;
glong offset;
gchar *title;
gint response;
PangoLayout *layout;
gint layout_width;
gint layout_offset;
gint parent_width = 500;
_thunar_return_val_if_fail (parent == NULL || GDK_IS_SCREEN (parent) || GTK_IS_WINDOW (parent), FALSE);
_thunar_return_val_if_fail (THUNAR_IS_FILE (file), FALSE);
/* parse the parent window and screen */
screen = thunar_util_parse_parent (parent, &window);
/* get the filename of the file */
filename = thunar_file_get_display_name (file);
/* create a new dialog window */
title = g_strdup_printf (_("Rename \"%s\""), filename);
dialog = gtk_dialog_new_with_buttons (title,
window,
GTK_DIALOG_MODAL
| GTK_DIALOG_DESTROY_WITH_PARENT,
_("_Cancel"), GTK_RESPONSE_CANCEL,
_("_Rename"), GTK_RESPONSE_OK,
NULL);
gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK);
g_free (title);
/* move the dialog to the appropriate screen */
if (G_UNLIKELY (window == NULL && screen != NULL))
gtk_window_set_screen (GTK_WINDOW (dialog), screen);
grid = gtk_grid_new ();
gtk_grid_set_column_spacing (GTK_GRID (grid), 6);
gtk_grid_set_row_spacing (GTK_GRID (grid), 3);
gtk_container_set_border_width (GTK_CONTAINER (grid), 6);
gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))), grid, TRUE, TRUE, 0);
gtk_widget_show (grid);
icon_theme = gtk_icon_theme_get_for_screen (gtk_widget_get_screen (dialog));
icon_factory = thunar_icon_factory_get_for_icon_theme (icon_theme);
icon = thunar_icon_factory_load_file_icon (icon_factory, file, THUNAR_FILE_ICON_STATE_DEFAULT, 48);
g_object_unref (G_OBJECT (icon_factory));
image = gtk_image_new_from_pixbuf (icon);
gtk_widget_set_margin_start (GTK_WIDGET(image), 6);
gtk_widget_set_margin_end (GTK_WIDGET(image), 6);
gtk_widget_set_margin_top (GTK_WIDGET(image), 6);
gtk_widget_set_margin_bottom (GTK_WIDGET(image), 6);
gtk_grid_attach (GTK_GRID (grid), image, 0, 0, 1, 2);
g_object_unref (G_OBJECT (icon));
gtk_widget_show (image);
label = gtk_label_new (_("Enter the new name:"));
gtk_label_set_xalign (GTK_LABEL (label), 0.0f);
gtk_widget_set_hexpand (label, TRUE);
gtk_grid_attach (GTK_GRID (grid), label, 1, 0, 1, 1);
gtk_widget_show (label);
entry = gtk_entry_new ();
gtk_entry_set_activates_default (GTK_ENTRY (entry), TRUE);
gtk_widget_set_hexpand (entry, TRUE);
gtk_widget_set_valign (entry, GTK_ALIGN_CENTER);
gtk_grid_attach (GTK_GRID (grid), entry, 1, 1, 1, 1);
gtk_widget_show (entry);
/* setup the old filename */
gtk_entry_set_text (GTK_ENTRY (entry), filename);
/* check if we don't have a directory here */
if (!thunar_file_is_directory (file))
{
/* check if the filename contains an extension */
text = thunar_util_str_get_extension (filename);
if (G_LIKELY (text != NULL))
{
/* grab focus to the entry first, else the selection will be altered later */
gtk_widget_grab_focus (entry);
/* determine the UTF-8 char offset */
offset = g_utf8_pointer_to_offset (filename, text);
/* select the text prior to the dot */
if (G_LIKELY (offset > 0))
gtk_editable_select_region (GTK_EDITABLE (entry), 0, offset);
}
}
/* get the size the entry requires to render the full text */
layout = gtk_entry_get_layout (GTK_ENTRY (entry));
pango_layout_get_pixel_size (layout, &layout_width, NULL);
gtk_entry_get_layout_offsets (GTK_ENTRY (entry), &layout_offset, NULL);
layout_width += (layout_offset * 2) + (12 * 4) + 48; /* 12px free space in entry */
/* parent window width */
if (G_LIKELY (window != NULL))
{
/* keep below 90% of the parent window width */
gtk_window_get_size (GTK_WINDOW (window), &parent_width, NULL);
parent_width *= 0.90f;
}
/* resize the dialog to make long names fit as much as possible */
gtk_window_set_default_size (GTK_WINDOW (dialog), CLAMP (layout_width, 300, parent_width), -1);
/* run the dialog */
response = gtk_dialog_run (GTK_DIALOG (dialog));
if (G_LIKELY (response == GTK_RESPONSE_OK))
{
/* hide the dialog */
gtk_widget_hide (dialog);
/* determine the new filename */
text = gtk_entry_get_text (GTK_ENTRY (entry));
/* check if we have a new name here */
if (G_LIKELY (!exo_str_is_equal (filename, text)))
{
/* try to rename the file */
job = thunar_io_jobs_rename_file (file, text);
}
}
/* cleanup */
gtk_widget_destroy (dialog);
return job;
}
static void navigator_graph_pattern_load(rasqal_graph_pattern *gp, int gp_index,int indent, GSList** template_query_)
{
int triple_index = 0;
raptor_sequence *seq;
rasqal_variable * var;
rasqal_triple* t;
rasqal_literal_type type;
GSList* template_query= *template_query_;
indent += 1;
/* look for triples */
while(1) {
t = rasqal_graph_pattern_get_triple(gp, triple_index);
if(!t)
break;
/*
rasqal_literal_type type;
printf ("triple\n");
type=rasqal_literal_get_rdf_term_type(t->subject);
printf ("S type %d val %s\n", type, rasqal_literal_as_string (t->subject)) ;
type=rasqal_literal_get_rdf_term_type(t->predicate);
printf ("P type %d val %s\n", type, rasqal_literal_as_string (t->predicate)) ;
type=rasqal_literal_get_rdf_term_type(t->object);
printf ("O type %d val %s\n", type, rasqal_literal_as_string (t->object)) ;
*/
//ssTriple_t *ttemp = (ssTriple_t *)g_new0(ssTriple_t,1);
ssTriple_t_sparql *ttemp = (ssTriple_t_sparql *)g_new0(ssTriple_t_sparql,1);
type=rasqal_literal_get_rdf_term_type(t->subject);
//var=rasqal_literal_as_variable(t->subject);
//rasqal_variable_print(var, stdout);
//printf("\n");
//printf("%s\n", var->name);
//rasqal_free_variable (var);
if ((type==RASQAL_LITERAL_UNKNOWN) && (rasqal_literal_as_string(t->subject) == NULL))
{ //variable , needs a wildcard
var=rasqal_literal_as_variable(t->subject);
ttemp->subject_var=g_strdup(var->name);
rasqal_free_variable (var);
ttemp->subject=g_strdup_printf("%s",wildcard1);
}
else
{ ttemp->subject=g_strdup(rasqal_literal_as_string (t->subject));
ttemp->subject_var=NULL;
}
type=rasqal_literal_get_rdf_term_type(t->predicate);
if ((type==RASQAL_LITERAL_UNKNOWN) && (rasqal_literal_as_string(t->predicate) == NULL))
{ //variable , needs a wildcard
var=rasqal_literal_as_variable(t->predicate);
ttemp->predicate_var=g_strdup(var->name);
rasqal_free_variable (var);
ttemp->predicate=g_strdup_printf("%s",wildcard1);
}
else
{ ttemp->predicate=g_strdup(rasqal_literal_as_string (t->predicate));
ttemp->predicate_var=NULL;
}
type=rasqal_literal_get_rdf_term_type(t->object);
if ((type==RASQAL_LITERAL_UNKNOWN) && (rasqal_literal_as_string(t->object) == NULL))
{ //variable , needs a wildcard
var=rasqal_literal_as_variable(t->object);
ttemp->object_var=g_strdup(var->name);
rasqal_free_variable (var);
ttemp->object=g_strdup_printf("%s",wildcard1);
}
else
{
if (type==RASQAL_LITERAL_STRING)
{ ttemp->object=g_strdup(rasqal_literal_as_string (t->object));
ttemp->objType = ssElement_TYPE_LIT;
}
else
{ ttemp->object=g_strdup(rasqal_literal_as_string (t->object));
ttemp->objType = ssElement_TYPE_URI;
}
ttemp->object_var=NULL;
}
ttemp->gp_index=gp_index;
ttemp->indent=indent;
//printf("SPARQL Binding triple is: \t%s\t%s\t%s , obj_Type %d \n", ttemp->subject, ttemp->predicate, ttemp->object, ttemp->objType);
//printf(" Vars: \t%s\t%s\t%s , gp_index %d indent %d\n", ttemp->subject_var, ttemp->predicate_var, ttemp->object_var,ttemp->gp_index,ttemp->indent);
template_query= g_slist_prepend(template_query, ttemp);
triple_index++;
}
/* look for sub-graph patterns */
seq = rasqal_graph_pattern_get_sub_graph_pattern_sequence(gp);
if(seq && raptor_sequence_size(seq) > 0) {
gp_index = 0;
while(1)
{
rasqal_graph_pattern* sgp;
sgp = rasqal_graph_pattern_get_sub_graph_pattern(gp, gp_index);
if(!sgp)
break;
navigator_graph_pattern_load(sgp, gp_index, indent + 1, &template_query);
gp_index++;
}
}
indent -= 1;
*template_query_=template_query;
}
/* sync finish phase */
static gboolean eee_accounts_manager_sync_phase2(EeeAccountsManager *self)
{
GSList *iter, *iter2, *iter_next, *iter2_next;
g_return_val_if_fail(IS_EEE_ACCOUNTS_MANAGER(self), FALSE);
// unmark groups/sources
for (iter = e_source_list_peek_groups(self->priv->eslist); iter; iter = iter->next)
{
ESourceGroup *group = E_SOURCE_GROUP(iter->data);
if (!e_source_group_is_3e(group))
{
continue;
}
g_object_set_data(G_OBJECT(group), "synced", (gpointer)FALSE);
for (iter2 = e_source_group_peek_sources(group); iter2; iter2 = iter2->next)
{
ESource *source = E_SOURCE(iter2->data);
g_object_set_data(G_OBJECT(source), "synced", (gpointer)FALSE);
}
}
// go through synced account description structures and update ESourceList
// accordingly
for (iter = self->priv->sync_accounts; iter; iter = iter->next)
{
EeeAccount *account = iter->data;
EeeAccount *current_account;
ESourceGroup *group;
char *group_name = g_strdup_printf("3e: %s", account->name);
// find ESourceGroup and EeeAccount
#if EVOLUTION_VERSION >= 232
group = e_source_list_peek_group_by_properties(self->priv->eslist, "name", group_name, NULL);
#else
group = e_source_list_peek_group_by_name(self->priv->eslist, group_name);
#endif /* EVOLUTION_VERSION >= 232 */
current_account = eee_accounts_manager_find_account_by_name(self, account->name);
if (account->state == EEE_ACCOUNT_STATE_DISABLED)
{
if (current_account)
{
eee_accounts_manager_remove_account(self, current_account);
}
if (group)
{
e_source_list_remove_group(self->priv->eslist, group);
}
g_object_unref(account);
continue;
}
// create account if it does not exist
if (current_account == NULL)
{
eee_accounts_manager_add_account(self, g_object_ref(account));
}
else
{
eee_account_copy(current_account, account);
}
// create group if it does not exist
if (group == NULL)
{
group = e_source_group_new(group_name, EEE_URI_PREFIX);
e_source_list_add_group(self->priv->eslist, group, -1);
g_object_unref(group);
}
g_free(group_name);
// check group sources if account is available, otherwise just mark them as
// synced
if (account->state == EEE_ACCOUNT_STATE_NOTAVAIL)
{
GSList *iter_grp, *iter_src;
for (iter_grp = e_source_list_peek_groups(self->priv->eslist); iter_grp; iter_grp = iter_grp->next)
{
ESourceGroup *group = iter_grp->data;
for (iter_src = e_source_group_peek_sources(group); iter_src; iter_src = iter_src->next)
{
ESource *source = iter_src->data;
const char *account_name = e_source_get_property(source, "eee-account");
if (account_name && !strcmp(account_name, account->name))
{
g_object_set_data(G_OBJECT(source), "synced", (gpointer)TRUE);
g_object_set_data(G_OBJECT(group), "synced", (gpointer)TRUE);
}
}
}
}
else
{
GArray * cals = eee_account_peek_calendars (account);
guint i;
for (i = 0; i < cals->len; i++)
{
ESCalendarInfo *cal = g_array_index (cals, ESCalendarInfo *, i);
ESource *source;
if (!strcmp(cal->owner, account->name))
{
// calendar owned by owner of account that represents current group
source = e_source_group_peek_source_by_calname(group, cal->name);
if (source == NULL)
{
source = e_source_new_3e_with_attrs(cal->name, cal->owner, account, cal->perm, cal->attrs);
e_source_group_add_source(group, source, -1);
g_object_unref(source);
}
else
{
e_source_set_3e_properties_with_attrs(source, cal->name, cal->owner, account, cal->perm, cal->attrs);
}
}
else
{
char *owner_group_name = g_strdup_printf("3e: %s", cal->owner);
// shared calendar, it should be put into another group
#if EVOLUTION_VERSION >= 232
ESourceGroup *owner_group = e_source_list_peek_group_by_properties(self->priv->eslist, "name", owner_group_name, NULL);
#else
ESourceGroup *owner_group = e_source_list_peek_group_by_name(self->priv->eslist, owner_group_name);
#endif /* EVOLUTION_VERSION >= 232 */
if (owner_group == NULL)
{
owner_group = e_source_group_new(owner_group_name, EEE_URI_PREFIX);
e_source_list_add_group(self->priv->eslist, owner_group, -1);
g_object_unref(owner_group);
}
g_object_set_data(G_OBJECT(owner_group), "synced", (gpointer)TRUE);
source = e_source_group_peek_source_by_calname(owner_group, cal->name);
if (source == NULL)
{
source = e_source_new_3e_with_attrs(cal->name, cal->owner, account, cal->perm, cal->attrs);
e_source_group_add_source(owner_group, source, -1);
g_object_unref(source);
}
else
{
e_source_set_3e_properties_with_attrs(source, cal->name, cal->owner, account, cal->perm, cal->attrs);
}
}
g_object_set_data(G_OBJECT(source), "synced", (gpointer)TRUE);
}
}
g_object_set_data(G_OBJECT(group), "synced", (gpointer)TRUE);
g_object_unref(account);
}
g_slist_free(self->priv->sync_accounts);
self->priv->sync_accounts = NULL;
// remove non-marked sources/groups
for (iter = e_source_list_peek_groups(self->priv->eslist); iter; iter = iter_next)
{
ESourceGroup *group = E_SOURCE_GROUP(iter->data);
iter_next = iter->next;
if (!e_source_group_is_3e(group))
{
continue;
}
if (g_object_get_data(G_OBJECT(group), "synced"))
{
for (iter2 = e_source_group_peek_sources(group); iter2; iter2 = iter2_next)
{
ESource *source = E_SOURCE(iter2->data);
iter2_next = iter2->next;
if (!g_object_get_data(G_OBJECT(source), "synced"))
{
e_source_group_remove_source(group, source);
}
}
}
else
{
e_source_list_remove_group(self->priv->eslist, group);
}
}
e_source_list_sync(self->priv->eslist, NULL);
return TRUE;
}
