/**
* Deletes a registry value.
*
* @param keyName Fully path of registry key. This parameter is modified.
* @param name Value name
* @return 0 on success
*/
int
delete_registry_value (char *keyName, const char *name)
{
int ret = 0;
LONG result;
HKEY key;
HKEY hKey;
char *subkey;
if ((keyName == NULL) || (name == NULL))
return -1;
get_registry_key (keyName, &key, &subkey);
result = RegOpenKeyEx (key, subkey, 0L, KEY_ALL_ACCESS, &hKey);
if (result != ERROR_SUCCESS)
{
log_message ("[delete_registry_value] Failed to open key: %s", keyName);
return -1;
}
result = RegDeleteValue (hKey, name);
if (result != ERROR_SUCCESS)
{
log_message ("[delete_registry_value] Failed to delete value: %s, %s", keyName, name);
ret = -1;
}
RegCloseKey (hKey);
return ret;
}
static MenuMonitor* lookup_monitor(const char* path, gboolean is_directory)
{
MenuMonitor *retval;
char *registry_key;
retval = NULL;
registry_key = get_registry_key (path, is_directory);
if (monitors_registry == NULL)
{
monitors_registry = g_hash_table_new_full (g_str_hash,
g_str_equal,
g_free,
NULL);
}
else
{
retval = g_hash_table_lookup (monitors_registry, registry_key);
}
if (retval == NULL)
{
retval = register_monitor (path, is_directory);
g_hash_table_insert (monitors_registry, registry_key, retval);
return retval;
}
else
{
g_free (registry_key);
return mate_menu_monitor_ref(retval);
}
}
/**
* Sets a registry value.
*
* @param keyName Fully qualified registry key. This parameter is modified.
* @param name Name of registry value
* @param value Value
* @param type Type of value (string or dword)
* @return 0 on success
*/
int
set_registry_value (char *keyName, const char *name, const char *value, const char *type)
{
int ret = 0;
LONG result;
HKEY key;
HKEY hKey;
char *subkey;
DWORD dispos;
DWORD data;
get_registry_key (keyName, &key, &subkey);
result = RegCreateKeyEx (key, subkey, 0L, NULL, REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hKey, &dispos);
if (result != ERROR_SUCCESS)
{
log_message ("[set_registry_value] Failed to create key: %s, %s", keyName, name);
return -1;
}
if (strcmp (type, "string") == 0)
{
result = RegSetValueEx (hKey, name, 0L, REG_SZ, (BYTE *)value, strlen(value) + 1);
if (result != ERROR_SUCCESS)
{
log_message ("[set_registry_value] Failed to set value: %s, %s, %s, %s", keyName, name, value, type);
result = -1;
}
}
else if (strcmp (type, "dword") == 0)
{
data = atol (value);
result = RegSetValueEx (hKey, name, 0L, REG_DWORD, (BYTE *)&data, sizeof(DWORD));
if (result != ERROR_SUCCESS)
{
log_message ("[set_registry_value] Failed to set value: %s, %s, %s, %s", keyName, name, value, type);
result = -1;
}
}
else
{
log_message ("[set_registry_value] Unknown value type: %s", type);
ret = -1;
}
RegCloseKey (hKey);
return ret;
}
/**
* Deletes a registry key.
*
* @param keyName Full path to the registry key. This parameter is modified.
* @return 0 on success
*/
int
delete_registry_key (char *keyName)
{
LONG result;
HKEY key;
char *subkey;
if (keyName == NULL)
return -1;
get_registry_key (keyName, &key, &subkey);
result = RegDeleteKey (key, subkey);
if (result != ERROR_SUCCESS)
{
log_message ("[delete_registry_key] Failed to delete key: %s", keyName);
return -1;
}
return 0;
}
void
menu_monitor_unref (MenuMonitor *monitor)
{
char *registry_key;
g_return_if_fail (monitor != NULL);
g_return_if_fail (monitor->refcount > 0);
if (--monitor->refcount > 0)
return;
registry_key = get_registry_key (monitor->path, monitor->is_directory);
g_hash_table_remove (monitors_registry, registry_key);
g_free (registry_key);
if (g_hash_table_size (monitors_registry) == 0)
{
g_hash_table_destroy (monitors_registry);
monitors_registry = NULL;
}
if (monitor->monitor)
{
g_file_monitor_cancel (monitor->monitor);
g_object_unref (monitor->monitor);
monitor->monitor = NULL;
}
g_slist_foreach (monitor->notifies, (GFunc) menu_monitor_notify_unref, NULL);
g_slist_free (monitor->notifies);
monitor->notifies = NULL;
menu_monitor_clear_pending_events (monitor);
g_free (monitor->path);
monitor->path = NULL;
g_free (monitor);
}
char*
get_registry_value (char *keyName, const char *name)
{
HKEY key, hKey;
char *subkey;
LONG result;
DWORD type;
DWORD data;
DWORD dataSize;
char *value = NULL;
get_registry_key (keyName, &key, &subkey);
result = RegOpenKeyEx (key, subkey, 0, KEY_READ, &hKey);
dataSize = 0;
RegQueryValueEx (hKey, name, 0, &type, NULL, &dataSize);
if (type == REG_DWORD)
{
dataSize = sizeof (DWORD);
result = RegQueryValueEx (hKey, name, 0, NULL, (LPBYTE)&data, &dataSize);
if (result == ERROR_SUCCESS)
{
value = malloc (255);
_ultoa (data, value, 10);
}
}
else if ((type == REG_EXPAND_SZ) || (type == REG_SZ))
{
value = malloc (dataSize + 1);
memset (value, dataSize + 1, 0);
result = RegQueryValueEx (hKey, name, 0, NULL, (LPBYTE)value, &dataSize);
}
RegCloseKey (hKey);
return value;
}
