static void
cb_user_stream_init (CbUserStream *self)
{
self->receivers = g_ptr_array_new ();
self->data = g_string_new (NULL);
self->restarting = FALSE;
self->state = STATE_STOPPED;
if (self->stresstest)
{
self->proxy = oauth_proxy_new ("0rvHLdbzRULZd5dz6X1TUA",
"oGrvd6654nWLhzLcJywSW3pltUfkhP4BnraPPVNhHtY",
"https://stream.twitter.com/",
FALSE);
}
else
{
/* TODO: We should be getting these from the settings */
self->proxy = oauth_proxy_new ("0rvHLdbzRULZd5dz6X1TUA",
"oGrvd6654nWLhzLcJywSW3pltUfkhP4BnraPPVNhHtY",
"https://userstream.twitter.com/",
FALSE);
}
self->proxy_data_set = FALSE;
self->network_monitor = g_network_monitor_get_default ();
self->network_available = g_network_monitor_get_network_available (self->network_monitor);
self->network_changed_id = g_signal_connect (self->network_monitor,
"network-changed",
G_CALLBACK (network_changed_cb), self);
if (!self->network_available)
start_network_timeout (self);
}
static void
applet_destroy (GtkWidget *widget, MateWeatherApplet *gw_applet)
{
GNetworkMonitor *monitor;
if (gw_applet->pref_dialog)
gtk_widget_destroy (gw_applet->pref_dialog);
if (gw_applet->details_dialog)
gtk_widget_destroy (gw_applet->details_dialog);
if (gw_applet->timeout_tag > 0) {
g_source_remove(gw_applet->timeout_tag);
gw_applet->timeout_tag = 0;
}
if (gw_applet->suncalc_timeout_tag > 0) {
g_source_remove(gw_applet->suncalc_timeout_tag);
gw_applet->suncalc_timeout_tag = 0;
}
if (gw_applet->settings) {
g_object_unref (gw_applet->settings);
gw_applet->settings = NULL;
}
monitor = g_network_monitor_get_default ();
g_signal_handlers_disconnect_by_func (monitor,
G_CALLBACK (network_changed),
gw_applet);
weather_info_abort (gw_applet->mateweather_info);
}
void NetworkStateNotifier::initialize()
{
m_monitor = g_network_monitor_get_default();
g_assert(G_IS_NETWORK_MONITOR(m_monitor));
g_signal_connect(m_monitor, "network_changed", G_CALLBACK(networkChangedCallback), this);
updateState();
}
static void
gis_goa_page_dispose (GObject *object)
{
GisGoaPage *page = GIS_GOA_PAGE (object);
GisGoaPagePrivate *priv = gis_goa_page_get_instance_private (page);
GNetworkMonitor *network_monitor = g_network_monitor_get_default ();
g_clear_object (&priv->goa_client);
g_signal_handlers_disconnect_by_func (network_monitor, G_CALLBACK (network_status_changed), page);
G_OBJECT_CLASS (gis_goa_page_parent_class)->dispose (object);
}
static void
gclue_locator_stop_sync (GClueLocator *locator)
{
if (locator->priv->network_changed_id) {
g_signal_handler_disconnect (g_network_monitor_get_default (),
locator->priv->network_changed_id);
locator->priv->network_changed_id = 0;
}
g_cancellable_cancel (locator->priv->cancellable);
g_cancellable_reset (locator->priv->cancellable);
g_clear_object (&locator->priv->ipclient);
}
void
soundmenu_lastfm_init (SoundmenuLastfm *lastfm)
{
#if GLIB_CHECK_VERSION(2,32,0)
if (g_network_monitor_get_network_available (g_network_monitor_get_default ()))
#else
if(nm_is_online () == TRUE)
#endif
g_idle_add (soundmenu_lastfm_connect_idle, lastfm);
else
g_timeout_add_seconds_full (G_PRIORITY_DEFAULT_IDLE, 30,
soundmenu_lastfm_connect_idle, lastfm,
NULL);
}
static void
sync_visibility (GisGoaPage *page)
{
GisGoaPagePrivate *priv = gis_goa_page_get_instance_private (page);
GisAssistant *assistant = gis_driver_get_assistant (GIS_PAGE (page)->driver);
GNetworkMonitor *network_monitor = g_network_monitor_get_default ();
gboolean visible;
if (gis_assistant_get_current_page (assistant) == GIS_PAGE (page))
return;
visible = (priv->accounts_exist || g_network_monitor_get_network_available (network_monitor));
gtk_widget_set_visible (GTK_WIDGET (page), visible);
}
int
main(int argv, char **argc)
{
GNetworkMonitor *nmon;
gboolean up;
g_type_init();
nmon = g_network_monitor_get_default();
g_signal_connect(nmon, "network-changed", G_CALLBACK(network_status_changed_callback), NULL);
printf("pkgng version: %s\n", PKGVERSION);
printf("packagekit version: %i.%i.%i\n", PK_MAJOR_VERSION, PK_MINOR_VERSION, PK_MICRO_VERSION);
printf("network: %s\n", ((g_network_monitor_get_network_available(nmon) == TRUE) ? "up" : "down"));
for(;;)
;
return 0;
}
static void
gedit_app_init (GeditApp *app)
{
GeditAppPrivate *priv;
priv = gedit_app_get_instance_private (app);
g_set_application_name ("gedit");
gtk_window_set_default_icon_name ("accessories-text-editor");
priv->monitor = g_network_monitor_get_default ();
g_signal_connect (priv->monitor,
"network-changed",
G_CALLBACK (get_network_available),
app);
g_application_add_main_option_entries (G_APPLICATION (app), options);
#ifdef ENABLE_INTROSPECTION
g_application_add_option_group (G_APPLICATION (app), g_irepository_get_option_group ());
#endif
}
static void
gis_goa_page_constructed (GObject *object)
{
GisGoaPage *page = GIS_GOA_PAGE (object);
GisGoaPagePrivate *priv = gis_goa_page_get_instance_private (page);
GError *error = NULL;
GNetworkMonitor *network_monitor = g_network_monitor_get_default ();
G_OBJECT_CLASS (gis_goa_page_parent_class)->constructed (object);
gis_page_set_skippable (GIS_PAGE (page), TRUE);
priv->providers = g_hash_table_new (g_str_hash, g_str_equal);
priv->goa_client = goa_client_new_sync (NULL, &error);
if (priv->goa_client == NULL) {
g_warning ("Failed to get a GoaClient: %s", error->message);
g_error_free (error);
return;
}
g_signal_connect (priv->goa_client, "account-added",
G_CALLBACK (accounts_changed), page);
g_signal_connect (priv->goa_client, "account-removed",
G_CALLBACK (accounts_changed), page);
g_signal_connect (network_monitor, "network-changed",
G_CALLBACK (network_status_changed), page);
gtk_list_box_set_header_func (GTK_LIST_BOX (priv->accounts_list),
update_header_func,
NULL, NULL);
g_signal_connect (priv->accounts_list, "row-activated",
G_CALLBACK (row_activated), page);
populate_provider_list (page);
sync_accounts (page);
}
void
gclue_locator_start (GClueLocator *locator,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
GSimpleAsyncResult *simple;
GNetworkMonitor *monitor;
g_return_if_fail (GCLUE_IS_LOCATOR (locator));
if (locator->priv->network_changed_id)
return; /* Already started */
locator->priv->ipclient = gclue_ipclient_new ();
g_object_set (locator->priv->ipclient,
"server", "http://freegeoip.net/json/",
"compatibility-mode", TRUE,
NULL);
monitor = g_network_monitor_get_default ();
locator->priv->network_changed_id =
g_signal_connect (monitor,
"network-changed",
G_CALLBACK (on_network_changed),
locator);
if (g_network_monitor_get_network_available (monitor))
on_network_changed (monitor, TRUE, locator);
simple = g_simple_async_result_new (G_OBJECT (locator),
callback,
user_data,
gclue_locator_start);
g_simple_async_result_complete_in_idle (simple);
g_object_unref (simple);
}
ClockLocationPrivate *priv = PRIVATE (this);
GNetworkMonitor *monitor;
priv->name = NULL;
priv->city = NULL;
priv->systz = system_timezone_new ();
priv->timezone = NULL;
priv->tzname = NULL;
priv->latitude = 0;
priv->longitude = 0;
monitor = g_network_monitor_get_default();
g_signal_connect (monitor, "network-changed",
G_CALLBACK (network_changed), this);
#if GTK_CHECK_VERSION (3, 0, 0)
priv->temperature_unit = GWEATHER_TEMP_UNIT_CENTIGRADE;
priv->speed_unit = GWEATHER_SPEED_UNIT_MS;
#else
priv->temperature_unit = TEMP_UNIT_CENTIGRADE;
priv->speed_unit = SPEED_UNIT_MS;
#endif
}
static void
clock_location_finalize (GObject *g_obj)
{
int
main (int argc, char **argv)
{
MinCloudAgentApp selfstruct = { 0, };
MinCloudAgentApp *self = &selfstruct;
GCancellable *cancellable = NULL;
const char *src_address;
guint srcport = 80;
g_setenv ("GIO_USE_VFS", "local", TRUE);
if (!prepare_root_ssh (cancellable, &self->error))
goto out;
src_address = g_getenv ("MIN_CLOUDAGENT_ADDRESS");
if (!src_address)
src_address = "169.254.169.254";
{
const char *srcport_str = g_getenv ("MIN_CLOUDAGENT_PORT");
if (srcport_str)
srcport = (guint) g_ascii_strtoull (srcport_str, NULL, 10);
}
self->addr = g_inet_address_new_from_string (src_address);
self->addr_port = (GInetSocketAddress*)g_inet_socket_address_new (self->addr, srcport);
self->netmon = g_network_monitor_get_default ();
self->cancellable = cancellable;
self->running = TRUE;
self->session = soup_session_sync_new_with_options (SOUP_SESSION_USER_AGENT, "min-cloud-agent",
SOUP_SESSION_SSL_USE_SYSTEM_CA_FILE, TRUE,
SOUP_SESSION_USE_THREAD_CONTEXT, TRUE,
NULL);
self->authorized_keys_path = g_file_new_for_path ("/root/.ssh/authorized_keys");
self->userdata_done_stamp = g_file_new_for_path (MIN_CLOUD_AGENT_STATEDIR "/userdata.stamp");
self->done_stamp = g_file_new_for_path (MIN_CLOUD_AGENT_STATEDIR "/done.stamp");
if (g_file_query_exists (self->done_stamp, NULL))
goto out;
g_signal_connect (self->netmon, "network-changed",
G_CALLBACK (on_network_changed),
self);
recheck_metadata_reachability (self);
while (self->running && self->error == NULL)
g_main_context_iteration (NULL, TRUE);
if (self->error)
goto out;
if (!g_file_replace_contents (self->done_stamp, "done\n", 5,
NULL, FALSE, 0,
NULL, cancellable, &self->error))
goto out;
out:
if (self->error)
{
g_printerr ("error: %s\n", self->error->message);
return 1;
}
return 0;
}
void mateweather_applet_create (MateWeatherApplet *gw_applet)
{
GtkActionGroup *action_group;
gchar *ui_path;
AtkObject *atk_obj;
GNetworkMonitor*monitor;
gw_applet->mateweather_pref.location = NULL;
gw_applet->mateweather_pref.show_notifications = FALSE;
gw_applet->mateweather_pref.update_interval = 1800;
gw_applet->mateweather_pref.update_enabled = TRUE;
gw_applet->mateweather_pref.detailed = FALSE;
gw_applet->mateweather_pref.radar_enabled = TRUE;
gw_applet->mateweather_pref.temperature_unit = TEMP_UNIT_INVALID;
gw_applet->mateweather_pref.speed_unit = SPEED_UNIT_INVALID;
gw_applet->mateweather_pref.pressure_unit = PRESSURE_UNIT_INVALID;
gw_applet->mateweather_pref.distance_unit = DISTANCE_UNIT_INVALID;
mate_panel_applet_set_flags (gw_applet->applet, MATE_PANEL_APPLET_EXPAND_MINOR);
mate_panel_applet_set_background_widget(gw_applet->applet,
GTK_WIDGET(gw_applet->applet));
g_set_application_name (_("Weather Report"));
gtk_window_set_default_icon_name ("weather-storm");
gw_applet->container = gtk_alignment_new (0.5, 0.5, 0, 0);
gtk_container_add (GTK_CONTAINER (gw_applet->applet), gw_applet->container);
g_signal_connect (G_OBJECT(gw_applet->applet), "change_orient",
G_CALLBACK(change_orient_cb), gw_applet);
g_signal_connect (G_OBJECT(gw_applet->applet), "size_allocate",
G_CALLBACK(size_allocate_cb), gw_applet);
g_signal_connect (G_OBJECT(gw_applet->applet), "destroy",
G_CALLBACK (applet_destroy), gw_applet);
g_signal_connect (G_OBJECT(gw_applet->applet), "button_press_event",
G_CALLBACK(clicked_cb), gw_applet);
g_signal_connect (G_OBJECT(gw_applet->applet), "key_press_event",
G_CALLBACK(key_press_cb), gw_applet);
gtk_widget_set_tooltip_text (GTK_WIDGET(gw_applet->applet), _("MATE Weather"));
atk_obj = gtk_widget_get_accessible (GTK_WIDGET (gw_applet->applet));
if (GTK_IS_ACCESSIBLE (atk_obj))
atk_object_set_name (atk_obj, _("MATE Weather"));
gw_applet->size = mate_panel_applet_get_size (gw_applet->applet);
gw_applet->orient = mate_panel_applet_get_orient (gw_applet->applet);
action_group = gtk_action_group_new ("MateWeather Applet Actions");
gtk_action_group_set_translation_domain (action_group, GETTEXT_PACKAGE);
gtk_action_group_add_actions (action_group,
weather_applet_menu_actions,
G_N_ELEMENTS (weather_applet_menu_actions),
gw_applet);
ui_path = g_build_filename (MATEWEATHER_MENU_UI_DIR, "mateweather-applet-menu.xml", NULL);
mate_panel_applet_setup_menu_from_file (gw_applet->applet,
ui_path, action_group);
g_free (ui_path);
if (mate_panel_applet_get_locked_down (gw_applet->applet)) {
GtkAction *action;
action = gtk_action_group_get_action (action_group, "Props");
gtk_action_set_visible (action, FALSE);
}
g_object_unref (action_group);
place_widgets(gw_applet);
monitor = g_network_monitor_get_default();
g_signal_connect (monitor, "network-changed",
G_CALLBACK (network_changed), gw_applet);}
void gweather_applet_create (GWeatherApplet *gw_applet)
{
GSimpleActionGroup *action_group;
GAction *action;
gchar *ui_path;
AtkObject *atk_obj;
GWeatherForecastType type;
GNetworkMonitor*monitor;
panel_applet_set_flags (gw_applet->applet, PANEL_APPLET_EXPAND_MINOR);
gw_applet->container = gtk_alignment_new (0.5, 0.5, 0, 0);
gtk_container_add (GTK_CONTAINER (gw_applet->applet), gw_applet->container);
g_signal_connect (G_OBJECT(gw_applet->applet), "change_orient",
G_CALLBACK(change_orient_cb), gw_applet);
g_signal_connect (G_OBJECT(gw_applet->applet), "size_allocate",
G_CALLBACK(size_allocate_cb), gw_applet);
g_signal_connect (G_OBJECT(gw_applet->applet), "destroy",
G_CALLBACK (applet_destroy), gw_applet);
g_signal_connect (G_OBJECT(gw_applet->applet), "button_press_event",
G_CALLBACK(clicked_cb), gw_applet);
g_signal_connect (G_OBJECT(gw_applet->applet), "key_press_event",
G_CALLBACK(key_press_cb), gw_applet);
gtk_widget_set_tooltip_text (GTK_WIDGET(gw_applet->applet), _("GNOME Weather"));
atk_obj = gtk_widget_get_accessible (GTK_WIDGET (gw_applet->applet));
if (GTK_IS_ACCESSIBLE (atk_obj))
atk_object_set_name (atk_obj, _("GNOME Weather"));
gw_applet->orient = panel_applet_get_orient (gw_applet->applet);
action_group = g_simple_action_group_new ();
g_action_map_add_action_entries (G_ACTION_MAP (action_group),
weather_applet_menu_actions,
G_N_ELEMENTS (weather_applet_menu_actions),
gw_applet);
ui_path = g_build_filename (GWEATHER_MENU_UI_DIR, "gweather-applet-menu.xml", NULL);
panel_applet_setup_menu_from_file (gw_applet->applet,
ui_path, action_group,
GETTEXT_PACKAGE);
g_free (ui_path);
gtk_widget_insert_action_group (GTK_WIDGET (gw_applet->applet), "gweather",
G_ACTION_GROUP (action_group));
action = g_action_map_lookup_action (G_ACTION_MAP (action_group), "preferences");
g_object_bind_property (gw_applet->applet, "locked-down", action, "enabled",
G_BINDING_DEFAULT|G_BINDING_INVERT_BOOLEAN|G_BINDING_SYNC_CREATE);
g_object_unref (action_group);
type = g_settings_get_boolean (gw_applet->applet_settings, "detailed") ?
GWEATHER_FORECAST_ZONE : GWEATHER_FORECAST_STATE;
gw_applet->gweather_info = gweather_info_new(NULL, type);
g_signal_connect (gw_applet->gweather_info, "updated",
G_CALLBACK (update_finish), gw_applet);
place_widgets(gw_applet);
monitor = g_network_monitor_get_default();
g_signal_connect (monitor, "network-changed",
G_CALLBACK (network_changed), gw_applet);
}
static void
gbp_flatpak_download_stage_query (IdeBuildStage *stage,
IdeBuildPipeline *pipeline,
GCancellable *cancellable)
{
GbpFlatpakDownloadStage *self = (GbpFlatpakDownloadStage *)stage;
IdeConfiguration *config;
GNetworkMonitor *monitor;
g_autofree gchar *staging_dir = NULL;
g_autofree gchar *manifest_path = NULL;
g_autofree gchar *stop_at_option = NULL;
const gchar *src_dir;
const gchar *primary_module;
g_assert (GBP_IS_FLATPAK_DOWNLOAD_STAGE (self));
g_assert (IDE_IS_BUILD_PIPELINE (pipeline));
g_assert (!cancellable || G_IS_CANCELLABLE (cancellable));
config = ide_build_pipeline_get_configuration (pipeline);
if (!GBP_IS_FLATPAK_CONFIGURATION (config))
{
ide_build_stage_set_completed (stage, TRUE);
return;
}
if (self->invalid)
{
g_autoptr(IdeSubprocessLauncher) launcher = NULL;
primary_module = gbp_flatpak_configuration_get_primary_module (GBP_FLATPAK_CONFIGURATION (config));
manifest_path = gbp_flatpak_configuration_get_manifest_path (GBP_FLATPAK_CONFIGURATION (config));
staging_dir = gbp_flatpak_get_staging_dir (config);
src_dir = ide_build_pipeline_get_srcdir (pipeline);
launcher = ide_subprocess_launcher_new (G_SUBPROCESS_FLAGS_STDOUT_PIPE |
G_SUBPROCESS_FLAGS_STDERR_PIPE);
ide_subprocess_launcher_set_run_on_host (launcher, TRUE);
ide_subprocess_launcher_set_clear_env (launcher, FALSE);
ide_subprocess_launcher_set_cwd (launcher, src_dir);
ide_subprocess_launcher_push_argv (launcher, "flatpak-builder");
ide_subprocess_launcher_push_argv (launcher, "--ccache");
ide_subprocess_launcher_push_argv (launcher, "--force-clean");
if (!dzl_str_empty0 (self->state_dir))
{
ide_subprocess_launcher_push_argv (launcher, "--state-dir");
ide_subprocess_launcher_push_argv (launcher, self->state_dir);
}
ide_subprocess_launcher_push_argv (launcher, "--download-only");
if (!self->force_update)
ide_subprocess_launcher_push_argv (launcher, "--disable-updates");
stop_at_option = g_strdup_printf ("--stop-at=%s", primary_module);
ide_subprocess_launcher_push_argv (launcher, stop_at_option);
ide_subprocess_launcher_push_argv (launcher, staging_dir);
ide_subprocess_launcher_push_argv (launcher, manifest_path);
ide_build_stage_launcher_set_launcher (IDE_BUILD_STAGE_LAUNCHER (self), launcher);
ide_build_stage_set_completed (stage, FALSE);
self->invalid = FALSE;
self->force_update = FALSE;
}
/* Ignore downloads if there is no connection */
monitor = g_network_monitor_get_default ();
if (!g_network_monitor_get_network_available (monitor))
{
ide_build_stage_log (stage,
IDE_BUILD_LOG_STDOUT,
_("Network is not available, skipping downloads"),
-1);
ide_build_stage_set_completed (stage, TRUE);
}
}
