GType
sim_group_alarm_get_type (void)
{
static GType object_type = 0;
G_LOCK_DEFINE_STATIC (SimGroupAlarm);
G_LOCK (SimGroupAlarm);
if (!object_type)
{
static const GTypeInfo type_info = {
sizeof (SimGroupAlarmClass),
NULL,
NULL,
(GClassInitFunc) sim_group_alarm_class_init,
NULL,
NULL, /* class data */
sizeof (SimGroupAlarm),
0, /* number of pre-allocs */
(GInstanceInitFunc) sim_group_alarm_instance_init,
NULL /* value table */
};
object_type = g_type_register_static (G_TYPE_OBJECT, "SimGroupAlarm", &type_info, 0);
}
G_UNLOCK (SimGroupAlarm);
return object_type;
}
/**
* g_thread_pool_new:
* @func: a function to execute in the threads of the new thread pool
* @user_data: user data that is handed over to @func every time it
* is called
* @max_threads: the maximal number of threads to execute concurrently
* in the new thread pool, -1 means no limit
* @exclusive: should this thread pool be exclusive?
* @error: return location for error, or %NULL
*
* This function creates a new thread pool.
*
* Whenever you call g_thread_pool_push(), either a new thread is
* created or an unused one is reused. At most @max_threads threads
* are running concurrently for this thread pool. @max_threads = -1
* allows unlimited threads to be created for this thread pool. The
* newly created or reused thread now executes the function @func
* with the two arguments. The first one is the parameter to
* g_thread_pool_push() and the second one is @user_data.
*
* The parameter @exclusive determines whether the thread pool owns
* all threads exclusive or shares them with other thread pools.
* If @exclusive is %TRUE, @max_threads threads are started
* immediately and they will run exclusively for this thread pool
* until it is destroyed by g_thread_pool_free(). If @exclusive is
* %FALSE, threads are created when needed and shared between all
* non-exclusive thread pools. This implies that @max_threads may
* not be -1 for exclusive thread pools. Besides, exclusive thread
* pools are not affected by g_thread_pool_set_max_idle_time()
* since their threads are never considered idle and returned to the
* global pool.
*
* @error can be %NULL to ignore errors, or non-%NULL to report
* errors. An error can only occur when @exclusive is set to %TRUE
* and not all @max_threads threads could be created.
* See #GThreadError for possible errors that may occur.
* Note, even in case of error a valid #GThreadPool is returned.
*
* Returns: the new #GThreadPool
*/
GThreadPool *
g_thread_pool_new (GFunc func,
gpointer user_data,
gint max_threads,
gboolean exclusive,
GError **error)
{
GRealThreadPool *retval;
G_LOCK_DEFINE_STATIC (init);
g_return_val_if_fail (func, NULL);
g_return_val_if_fail (!exclusive || max_threads != -1, NULL);
g_return_val_if_fail (max_threads >= -1, NULL);
retval = g_new (GRealThreadPool, 1);
retval->pool.func = func;
retval->pool.user_data = user_data;
retval->pool.exclusive = exclusive;
retval->queue = g_async_queue_new ();
g_cond_init (&retval->cond);
retval->max_threads = max_threads;
retval->num_threads = 0;
retval->running = TRUE;
retval->immediate = FALSE;
retval->waiting = FALSE;
retval->sort_func = NULL;
retval->sort_user_data = NULL;
G_LOCK (init);
if (!unused_thread_queue)
unused_thread_queue = g_async_queue_new ();
G_UNLOCK (init);
if (retval->pool.exclusive)
{
g_async_queue_lock (retval->queue);
while (retval->num_threads < retval->max_threads)
{
GError *local_error = NULL;
if (!g_thread_pool_start_thread (retval, &local_error))
{
g_propagate_error (error, local_error);
break;
}
}
g_async_queue_unlock (retval->queue);
}
return (GThreadPool*) retval;
}
OwrLocalMediaSource *_owr_local_media_source_new_cached(gint device_index, const gchar *name,
OwrMediaType media_type, OwrSourceType source_type)
{
static OwrLocalMediaSource *test_sources[2] = { NULL, };
static GHashTable *sources[2] = { NULL, };
G_LOCK_DEFINE_STATIC(source_cache);
OwrLocalMediaSource *ret = NULL;
gchar *cached_name;
int i;
G_LOCK(source_cache);
if (G_UNLIKELY(sources[0] == NULL)) {
sources[0] = g_hash_table_new(NULL, NULL);
sources[1] = g_hash_table_new(NULL, NULL);
}
i = media_type == OWR_MEDIA_TYPE_AUDIO ? 0 : 1;
if (source_type == OWR_SOURCE_TYPE_TEST) {
if (test_sources[i] == NULL)
test_sources[i] = _owr_local_media_source_new(device_index, name, media_type, source_type);
ret = test_sources[i];
} else if (source_type == OWR_SOURCE_TYPE_CAPTURE) {
ret = g_hash_table_lookup(sources[i], GINT_TO_POINTER(device_index));
if (ret) {
g_object_get(ret, "name", &cached_name, NULL);
if (!g_str_equal(name, cached_name)) {
/* Device at this index seems to have changed, throw the old one away */
g_object_unref(ret);
ret = NULL;
}
g_free(cached_name);
}
if (!ret) {
ret = _owr_local_media_source_new(device_index, name, media_type, source_type);
g_hash_table_insert(sources[i], GINT_TO_POINTER(device_index), ret);
}
} else
g_assert_not_reached();
G_UNLOCK (source_cache);
return g_object_ref(ret);
}
static gchar *
get_package_directory_from_module (const gchar *module_name)
{
static GHashTable *module_dirs = NULL;
G_LOCK_DEFINE_STATIC (module_dirs);
HMODULE hmodule = NULL;
gchar *fn;
G_LOCK (module_dirs);
if (module_dirs == NULL)
module_dirs = g_hash_table_new (g_str_hash, g_str_equal);
fn = g_hash_table_lookup (module_dirs, module_name ? module_name : "");
if (fn)
{
G_UNLOCK (module_dirs);
return g_strdup (fn);
}
if (module_name)
{
wchar_t *wc_module_name = g_utf8_to_utf16 (module_name, -1, NULL, NULL, NULL);
hmodule = GetModuleHandleW (wc_module_name);
g_free (wc_module_name);
if (!hmodule)
{
G_UNLOCK (module_dirs);
return NULL;
}
}
fn = g_win32_get_package_installation_directory_of_module (hmodule);
if (fn == NULL)
{
G_UNLOCK (module_dirs);
return NULL;
}
g_hash_table_insert (module_dirs, module_name ? g_strdup (module_name) : "", fn);
G_UNLOCK (module_dirs);
return g_strdup (fn);
}
static GType
gst_iir_equalizer_band_get_type (void)
{
#ifdef GSTREAMER_LITE
static volatile GType type = 0;
G_LOCK_DEFINE_STATIC(type_init_mutex);
#else // !GSTREAMER_LITE
static GType type = 0;
#endif // GSTREAMER_LITE
if (G_UNLIKELY (!type)) {
#ifdef GSTREAMER_LITE
G_LOCK(type_init_mutex);
if(!type) // Use double check lock pattern
{
#endif // GSTREAMER_LITE
const GTypeInfo type_info = {
sizeof (GstIirEqualizerBandClass),
NULL,
NULL,
(GClassInitFunc) gst_iir_equalizer_band_class_init,
NULL,
NULL,
sizeof (GstIirEqualizerBand),
0,
(GInstanceInitFunc) gst_iir_equalizer_band_init,
};
type =
g_type_register_static (GST_TYPE_OBJECT, "GstIirEqualizerBand",
&type_info, 0);
#ifdef GSTREAMER_LITE
}
G_UNLOCK(type_init_mutex);
#endif // GSTREAMER_LITE
}
return (type);
}
void
vfolder_load_storage (EMailBackend *backend)
{
/* lock for loading storage, it is safe to call it more than once */
G_LOCK_DEFINE_STATIC (vfolder_hash);
CamelService *service;
const gchar *key;
const gchar *data_dir;
const gchar *config_dir;
gchar *user, *storeuri;
EFilterRule *rule;
MailFolderCache *folder_cache;
EMailSession *session;
gchar *xmlfile;
GConfClient *client;
g_return_if_fail (E_IS_MAIL_BACKEND (backend));
G_LOCK (vfolder_hash);
if (vfolder_hash) {
/* we have already initialized */
G_UNLOCK (vfolder_hash);
return;
}
vfolder_hash = g_hash_table_new (g_str_hash, g_str_equal);
G_UNLOCK (vfolder_hash);
data_dir = mail_session_get_data_dir ();
config_dir = mail_session_get_config_dir ();
session = e_mail_backend_get_session (backend);
/* first, create the vfolder store, and set it up */
storeuri = g_strdup_printf("vfolder:%s/vfolder", data_dir);
service = camel_session_add_service (
CAMEL_SESSION (session), "vfolder",
storeuri, CAMEL_PROVIDER_STORE, NULL);
if (service != NULL) {
camel_service_set_display_name (service, _("Search Folders"));
em_utils_connect_service_sync (service, NULL, NULL);
} else {
g_warning("Cannot open vfolder store - no vfolders available");
return;
}
g_return_if_fail (CAMEL_IS_STORE (service));
vfolder_store = CAMEL_STORE (service);
g_signal_connect (
service, "folder-deleted",
G_CALLBACK (store_folder_deleted_cb), backend);
g_signal_connect (
service, "folder-renamed",
G_CALLBACK (store_folder_renamed_cb), NULL);
/* load our rules */
user = g_build_filename (config_dir, "vfolders.xml", NULL);
context = em_vfolder_context_new (backend);
xmlfile = g_build_filename (EVOLUTION_PRIVDATADIR, "vfoldertypes.xml", NULL);
if (e_rule_context_load ((ERuleContext *) context,
xmlfile, user) != 0) {
g_warning("cannot load vfolders: %s\n", ((ERuleContext *)context)->error);
}
g_free (xmlfile);
g_free (user);
g_signal_connect (
context, "rule_added",
G_CALLBACK (context_rule_added), context);
g_signal_connect (
context, "rule_removed",
G_CALLBACK (context_rule_removed), context);
/* load store to mail component */
e_mail_store_add (backend, vfolder_store);
/* and setup the rules we have */
rule = NULL;
while ((rule = e_rule_context_next_rule ((ERuleContext *) context, rule, NULL))) {
if (rule->name) {
d(printf("rule added: %s\n", rule->name));
context_rule_added ((ERuleContext *) context, rule);
} else {
d(printf("invalid rule (%p) encountered: rule->name is NULL\n", rule));
}
}
g_free (storeuri);
/* reenable the feature if required */
client = gconf_client_get_default ();
key = "/apps/evolution/mail/display/enable_vfolders";
if (!gconf_client_get_bool (client, key, NULL))
gconf_client_set_bool (client, key, TRUE, NULL);
g_object_unref (client);
folder_cache = e_mail_session_get_folder_cache (session);
g_signal_connect (
folder_cache, "folder-available",
G_CALLBACK (folder_available_cb), backend);
g_signal_connect (
folder_cache, "folder-unavailable",
G_CALLBACK (folder_unavailable_cb), backend);
g_signal_connect (
folder_cache, "folder-deleted",
G_CALLBACK (folder_deleted_cb), backend);
g_signal_connect (
folder_cache, "folder-renamed",
G_CALLBACK (folder_renamed_cb), NULL);
}