#include <gtkhtml/gtkhtml.h>
#include <gdk/gdkkeysyms.h>
#include <glib/gstdio.h>
+#include <dbus/dbus-glib.h>
+#include <dbus/dbus-glib-lowlevel.h>
#include <gio/gio.h>
#include "hb.h"
}
static gboolean
-dep_check(signal_user_data_t *ud, const gchar *name)
+dep_check(signal_user_data_t *ud, const gchar *name, gboolean *out_hide)
{
GtkWidget *widget;
GObject *dep_object;
array = ghb_dict_lookup(rev_map, name);
count = ghb_array_len(array);
+ *out_hide = FALSE;
for (ii = 0; ii < count; ii++)
{
data = ghb_array_get_nth(array, ii);
widget = GHB_WIDGET(ud->builder, widget_name);
dep_object = gtk_builder_get_object(ud->builder, name);
g_free(widget_name);
+ if (!GTK_WIDGET_SENSITIVE(widget))
+ continue;
if (dep_object == NULL)
{
g_message("Failed to find widget");
gint jj = 0;
gchar **values;
gboolean sensitive = FALSE;
- gboolean die;
+ gboolean die, hide;
die = ghb_value_boolean(ghb_array_get_nth(data, 2));
+ hide = ghb_value_boolean(ghb_array_get_nth(data, 3));
value = ghb_value_string(ghb_array_get_nth(data, 1));
values = g_strsplit(value, "|", 10);
g_free(value);
jj++;
}
sensitive = die ^ sensitive;
- if (!sensitive) result = FALSE;
+ if (!sensitive)
+ {
+ result = FALSE;
+ *out_hide |= hide;
+ }
g_strfreev (values);
g_free(value);
}
for (ii = 0; ii < count; ii++)
{
gboolean sensitive;
+ gboolean hide;
data = ghb_array_get_nth(array, ii);
dep_name = ghb_value_string(data);
g_free(dep_name);
continue;
}
- sensitive = dep_check(ud, dep_name);
+ sensitive = dep_check(ud, dep_name, &hide);
g_free(dep_name);
if (GTK_IS_ACTION(dep_object))
+ {
gtk_action_set_sensitive(GTK_ACTION(dep_object), sensitive);
+ gtk_action_set_visible(GTK_ACTION(dep_object), sensitive || !hide);
+ }
else
+ {
gtk_widget_set_sensitive(GTK_WIDGET(dep_object), sensitive);
+ if (!sensitive && hide)
+ {
+ gtk_widget_hide(GTK_WIDGET(dep_object));
+ }
+ else
+ {
+ gtk_widget_show_now(GTK_WIDGET(dep_object));
+ }
+ }
}
}
&iter, (gpointer*)(void*)&dep_name, (gpointer*)(void*)&value))
{
gboolean sensitive;
+ gboolean hide;
+
dep_object = gtk_builder_get_object (ud->builder, dep_name);
if (dep_object == NULL)
{
g_message("Failed to find dependent widget %s", dep_name);
continue;
}
- sensitive = dep_check(ud, dep_name);
+ sensitive = dep_check(ud, dep_name, &hide);
if (GTK_IS_ACTION(dep_object))
- gtk_action_set_sensitive(GTK_ACTION(dep_object), sensitive);
- else
- gtk_widget_set_sensitive(GTK_WIDGET(dep_object), sensitive);
- }
-}
-
-static gchar*
-expand_tilde(const gchar *path)
-{
- const gchar *user_home;
- gchar *home;
- const gchar *suffix;
- gchar *expanded_path = NULL;
-
- g_debug("expand_tilde ()");
- if (path[0] == '~')
- {
- user_home = g_get_home_dir();
- home = NULL; // squash warning about home uninitialized
- if (path[1] == 0)
- {
- home = g_strdup(user_home);
- suffix = "";
- }
- else if (path[1] == '/')
{
- home = g_strdup(user_home);
- suffix = &path[2];
+ gtk_action_set_sensitive(GTK_ACTION(dep_object), sensitive);
+ gtk_action_set_visible(GTK_ACTION(dep_object), sensitive || !hide);
}
else
{
- home = g_path_get_dirname(user_home);
- suffix = &path[1];
+ gtk_widget_set_sensitive(GTK_WIDGET(dep_object), sensitive);
+ if (!sensitive && hide)
+ {
+ gtk_widget_hide(GTK_WIDGET(dep_object));
+ }
+ else
+ {
+ gtk_widget_show_now(GTK_WIDGET(dep_object));
+ }
}
- expanded_path = g_strdup_printf("%s/%s", home, suffix);
- g_free(home);
}
- return expanded_path;
}
void
g_debug("set_destination");
if (ghb_settings_get_boolean(ud->settings, "use_source_name"))
{
+ GString *str = g_string_new("");
gchar *vol_name, *filename, *extension;
- gchar *dir, *new_name;
+ gchar *new_name;
+ gint title;
- filename = ghb_settings_get_string(ud->settings, "destination");
+ filename = ghb_settings_get_string(ud->settings, "dest_file");
extension = ghb_settings_get_string(ud->settings, "FileFormat");
- dir = g_path_get_dirname (filename);
vol_name = ghb_settings_get_string(ud->settings, "volume_label");
- if (ghb_settings_get_boolean(ud->settings, "chapters_in_destination"))
+ g_string_append_printf(str, "%s", vol_name);
+ title = ghb_settings_combo_int(ud->settings, "title");
+ if (title >= 0)
{
- gint start, end;
-
- start = ghb_settings_get_int(ud->settings, "start_chapter");
- end = ghb_settings_get_int(ud->settings, "end_chapter");
- if (start == end)
+ if (ghb_settings_get_boolean(
+ ud->settings, "title_no_in_destination"))
{
- new_name = g_strdup_printf("%s/%s-%d.%s",
- dir, vol_name, start, extension);
+
+ title = ghb_settings_combo_int(ud->settings, "title");
+ g_string_append_printf(str, " - %d", title+1);
}
- else
+ if (ghb_settings_get_boolean(
+ ud->settings, "chapters_in_destination"))
{
- new_name = g_strdup_printf("%s/%s-%d-%d.%s",
- dir, vol_name, start, end, extension);
+ gint start, end;
+
+ if (!ghb_settings_get_boolean(
+ ud->settings, "title_no_in_destination"))
+ {
+ g_string_append_printf(str, " -");
+ }
+ start = ghb_settings_get_int(ud->settings, "start_chapter");
+ end = ghb_settings_get_int(ud->settings, "end_chapter");
+ if (start == end)
+ g_string_append_printf(str, " Ch %d", start);
+ else
+ g_string_append_printf(str, " Ch %d-%d", start, end);
}
}
- else
- {
- new_name = g_strdup_printf("%s/%s.%s", dir, vol_name, extension);
- }
- ghb_ui_update(ud, "destination", ghb_string_value(new_name));
+ g_string_append_printf(str, ".%s", extension);
+ new_name = g_string_free(str, FALSE);
+ ghb_ui_update(ud, "dest_file", ghb_string_value(new_name));
g_free(filename);
g_free(extension);
g_free(vol_name);
- g_free(dir);
g_free(new_name);
}
}
gtk_progress_bar_set_text (progress, "Scanning ...");
ghb_hb_cleanup(TRUE);
prune_logs(ud);
- ghb_backend_scan (path, 0);
+ gint preview_count;
+ preview_count = ghb_settings_get_int(ud->settings, "preview_count");
+ ghb_backend_scan(path, 0, preview_count);
g_free(path);
}
else
g_debug("update_destination_extension ()");
extension = ghb_settings_get_string(ud->settings, "FileFormat");
- entry = GTK_ENTRY(GHB_WIDGET(ud->builder, "destination"));
+ entry = GTK_ENTRY(GHB_WIDGET(ud->builder, "dest_file"));
filename = g_strdup(gtk_entry_get_text(entry));
for (ii = 0; containers[ii] != NULL; ii++)
{
break;
}
new_name = g_strjoin(".", filename, extension, NULL);
- ghb_ui_update(ud, "destination", ghb_string_value(new_name));
+ ghb_ui_update(ud, "dest_file", ghb_string_value(new_name));
g_free(new_name);
break;
}
break;
}
}
+ if (start < 0) start = 0;
if (start < end)
{
gtk_editable_select_region(GTK_EDITABLE(entry), start, end);
static gboolean update_default_destination = FALSE;
void
-destination_entry_changed_cb(GtkEntry *entry, signal_user_data_t *ud)
+dest_dir_set_cb(GtkFileChooserButton *dest_chooser, signal_user_data_t *ud)
{
- gchar *dest;
+ gchar *dest_file, *dest_dir, *dest;
- g_debug("destination_entry_changed_cb ()");
- if ((dest = expand_tilde(gtk_entry_get_text(entry))) != NULL)
- {
- gtk_entry_set_text(entry, dest);
- g_free(dest);
- }
+ g_debug("dest_dir_set_cb ()");
+ ghb_widget_to_setting(ud->settings, (GtkWidget*)dest_chooser);
+ dest_file = ghb_settings_get_string(ud->settings, "dest_file");
+ dest_dir = ghb_settings_get_string(ud->settings, "dest_dir");
+ dest = g_strdup_printf("%s/%s", dest_dir, dest_file);
+ ghb_settings_set_string(ud->settings, "destination", dest);
+ g_free(dest_file);
+ g_free(dest_dir);
+ g_free(dest);
+ update_default_destination = TRUE;
+}
+
+void
+dest_file_changed_cb(GtkEntry *entry, signal_user_data_t *ud)
+{
+ gchar *dest_file, *dest_dir, *dest;
+
+ g_debug("dest_file_changed_cb ()");
update_destination_extension(ud);
ghb_widget_to_setting(ud->settings, (GtkWidget*)entry);
// This signal goes off with ever keystroke, so I'm putting this
// update on the timer.
+ dest_file = ghb_settings_get_string(ud->settings, "dest_file");
+ dest_dir = ghb_settings_get_string(ud->settings, "dest_dir");
+ dest = g_strdup_printf("%s/%s", dest_dir, dest_file);
+ ghb_settings_set_string(ud->settings, "destination", dest);
+ g_free(dest_file);
+ g_free(dest_dir);
+ g_free(dest);
update_default_destination = TRUE;
}
g_free(basename);
if (gtk_dialog_run(GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT)
{
- char *filename;
+ char *filename, *dirname;
+ GtkFileChooser *dest_chooser;
filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
- entry = (GtkEntry*)GHB_WIDGET(ud->builder, "destination");
- if (entry == NULL)
- {
- g_debug("Failed to find widget: %s", "destination");
- }
- else
- {
- gtk_entry_set_text(entry, filename);
- }
+ basename = g_path_get_basename(filename);
+ dirname = g_path_get_dirname(filename);
+ entry = (GtkEntry*)GHB_WIDGET(ud->builder, "dest_file");
+ gtk_entry_set_text(entry, basename);
+ dest_chooser = GTK_FILE_CHOOSER(GHB_WIDGET(ud->builder, "dest_dir"));
+ gtk_file_chooser_set_filename(dest_chooser, dirname);
+ g_free (dirname);
+ g_free (basename);
g_free (filename);
}
gtk_widget_destroy(dialog);
}
// Unfortunately, there is no way to query how many frames were
- // actually generated during the scan. It attempts to make 10.
+ // actually generated during the scan.
// If I knew how many were generated, I would adjust the spin
// control range here.
- ghb_ui_update(ud, "preview_frame", ghb_int64_value(1));
+ // I do know how many were asked for.
+ gint preview_count;
+ preview_count = ghb_settings_get_int(ud->settings, "preview_count");
+ widget = GHB_WIDGET(ud->builder, "preview_frame");
+ gtk_spin_button_set_range (GTK_SPIN_BUTTON(widget), 1, preview_count);
+ ghb_ui_update(ud, "preview_frame", ghb_int64_value(2));
ghb_set_preview_image (ud);
+ if (ghb_settings_get_boolean(ud->settings, "title_no_in_destination"))
+ {
+ set_destination(ud);
+ }
}
void
ghb_live_reset(ud);
}
-static void
-validate_filter_widget(signal_user_data_t *ud, const gchar *name)
-{
- GtkTreeModel *store;
- GtkTreeIter iter;
- const gchar *str;
- gboolean foundit = FALSE;
- GtkComboBox *combo = GTK_COMBO_BOX(GHB_WIDGET(ud->builder, name));
- if (gtk_combo_box_get_active(combo) < 0)
- { // Validate user input
- gchar *val = ghb_settings_get_string(ud->settings, name);
- store = gtk_combo_box_get_model(combo);
- // Check to see if user manually entered one of the combo options
- if (gtk_tree_model_get_iter_first(store, &iter))
- {
- do
- {
- gtk_tree_model_get(store, &iter, 0, &str, -1);
- if (strcasecmp(val, str) == 0)
- {
- gtk_combo_box_set_active_iter(combo, &iter);
- foundit = TRUE;
- break;
- }
- } while (gtk_tree_model_iter_next(store, &iter));
- }
- if (!foundit)
- { // validate format of filter string
- if (!ghb_validate_filter_string(val, -1))
- gtk_combo_box_set_active(combo, 0);
- }
- g_free(val);
- }
-}
-
-gboolean
-deint_tweak_focus_out_cb(GtkWidget *widget, GdkEventFocus *event,
- signal_user_data_t *ud)
-{
- g_debug("deint_tweak_focus_out_cb ()");
- validate_filter_widget(ud, "tweak_PictureDeinterlace");
- return FALSE;
-}
-
-gboolean
-denoise_tweak_focus_out_cb(GtkWidget *widget, GdkEventFocus *event,
- signal_user_data_t *ud)
-{
- g_debug("denoise_tweak_focus_out_cb ()");
- validate_filter_widget(ud, "tweak_PictureDenoise");
- return FALSE;
-}
-
void
http_opt_changed_cb(GtkWidget *widget, signal_user_data_t *ud)
{
{
static gint unique_id = 1;
gchar *type, *modified, *preset;
- GValue *path;
+ const GValue *path;
gboolean preset_modified;
g_debug("submit_job");
if (status == GHB_QUEUE_PENDING)
{
current = ii;
+ ghb_inhibit_gpm();
queue_scan(ud, js);
return js;
}
}
// Nothing pending
+ ghb_uninhibit_gpm();
return NULL;
}
// Find the next pending item after the current running item
if (status == GHB_QUEUE_PENDING)
{
current = jj;
+ ghb_inhibit_gpm();
queue_scan(ud, js);
return js;
}
if (status == GHB_QUEUE_PENDING)
{
current = ii;
+ ghb_inhibit_gpm();
queue_scan(ud, js);
return js;
}
}
// Nothing found
+ ghb_uninhibit_gpm();
return NULL;
}
else if (status.queue.state & GHB_STATE_SCANDONE)
{
ghb_clear_queue_state(GHB_STATE_SCANDONE);
+ usleep(2000000);
submit_job(ud->current_job);
}
else if (status.queue.state & GHB_STATE_PAUSED)
}
gtk_progress_bar_set_fraction (progress, 1.0);
ghb_clear_queue_state(GHB_STATE_WORKDONE);
+ if (ud->job_activity_log)
+ g_io_channel_unref(ud->job_activity_log);
+ ud->job_activity_log = NULL;
if (!ud->cancel_encode)
+ {
ud->current_job = ghb_start_next_job(ud, FALSE);
+ }
else
+ {
+ ghb_uninhibit_gpm();
ud->current_job = NULL;
+ }
if (js)
ghb_settings_set_int(js, "job_status", qstatus);
ghb_save_queue(ud->queue);
ud->cancel_encode = FALSE;
- g_io_channel_unref(ud->job_activity_log);
- ud->job_activity_log = NULL;
}
else if (status.queue.state & GHB_STATE_MUXING)
{
buffer = gtk_text_view_get_buffer (textview);
// I would like to auto-scroll the window when the scrollbar
// is at the bottom,
- // must determining whether the insert point is at
+ // must determine whether the insert point is at
// the bottom of the window
window = gtk_text_view_get_window(textview, GTK_TEXT_WINDOW_TEXT);
if (window != NULL)
gtk_text_buffer_insert(buffer, &iter, text, -1);
if (bottom)
{
- //gtk_text_view_scroll_to_iter(textview, &iter, 0, FALSE, 0, 0);
- mark = gtk_text_buffer_get_insert (buffer);
+ gtk_text_buffer_get_end_iter(buffer, &iter);
+ mark = gtk_text_buffer_create_mark(buffer, NULL, &iter, FALSE);
gtk_text_view_scroll_mark_onscreen(textview, mark);
+ gtk_text_buffer_delete_mark(buffer, mark);
}
g_io_channel_write_chars (ud->activity_log, text,
length, &length, NULL);
+ g_io_channel_flush(ud->activity_log, NULL);
if (ud->job_activity_log)
+ {
g_io_channel_write_chars (ud->job_activity_log, text,
length, &length, NULL);
+ g_io_channel_flush(ud->job_activity_log, NULL);
+ }
g_free(text);
}
if (status != G_IO_STATUS_NORMAL)
return TRUE;
}
+static void
+set_visible(GtkWidget *widget, gboolean visible)
+{
+ if (visible)
+ {
+ gtk_widget_show_now(widget);
+ }
+ else
+ {
+ gtk_widget_hide(widget);
+ }
+}
+
void
show_activity_clicked_cb(GtkWidget *xwidget, signal_user_data_t *ud)
{
GtkWidget *widget = GHB_WIDGET (ud->builder, "activity_window");
- gtk_widget_show (widget);
+ set_visible(widget, gtk_toggle_tool_button_get_active(
+ GTK_TOGGLE_TOOL_BUTTON(xwidget)));
+}
+
+void
+show_activity_menu_clicked_cb(GtkWidget *xwidget, signal_user_data_t *ud)
+{
+ GtkWidget *widget = GHB_WIDGET (ud->builder, "activity_window");
+ set_visible(widget, TRUE);
+ widget = GHB_WIDGET (ud->builder, "show_activity");
+ gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(widget), TRUE);
+}
+
+gboolean
+activity_window_delete_cb(GtkWidget *xwidget, GdkEvent *event, signal_user_data_t *ud)
+{
+ set_visible(xwidget, FALSE);
+ GtkWidget *widget = GHB_WIDGET (ud->builder, "show_activity");
+ gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(widget), FALSE);
+ return TRUE;
}
void
show_queue_clicked_cb(GtkWidget *xwidget, signal_user_data_t *ud)
{
GtkWidget *widget = GHB_WIDGET (ud->builder, "queue_window");
- gtk_widget_show (widget);
+ set_visible(widget, gtk_toggle_tool_button_get_active(
+ GTK_TOGGLE_TOOL_BUTTON(xwidget)));
}
void
-show_presets_toggled_cb(GtkToggleButton *button, signal_user_data_t *ud)
+show_queue_menu_clicked_cb(GtkWidget *xwidget, signal_user_data_t *ud)
+{
+ GtkWidget *widget = GHB_WIDGET (ud->builder, "queue_window");
+ set_visible(widget, TRUE);
+ widget = GHB_WIDGET (ud->builder, "show_queue");
+ gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(widget), TRUE);
+}
+
+gboolean
+queue_window_delete_cb(GtkWidget *xwidget, GdkEvent *event, signal_user_data_t *ud)
+{
+ set_visible(xwidget, FALSE);
+ GtkWidget *widget = GHB_WIDGET (ud->builder, "show_queue");
+ gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(widget), FALSE);
+ return TRUE;
+}
+
+void
+show_presets_toggled_cb(GtkWidget *action, signal_user_data_t *ud)
{
GtkWidget *widget;
GtkWindow *hb_window;
g_debug("show_presets_clicked_cb ()");
widget = GHB_WIDGET (ud->builder, "presets_frame");
- if (gtk_toggle_button_get_active(button))
+ ghb_widget_to_setting(ud->settings, action);
+ if (ghb_settings_get_boolean(ud->settings, "show_presets"))
{
gtk_widget_show_now(widget);
}
hb_window = GTK_WINDOW(GHB_WIDGET (ud->builder, "hb_window"));
gtk_window_resize(hb_window, 16, 16);
}
- ghb_widget_to_setting(ud->settings, GTK_WIDGET(button));
ghb_pref_save(ud->settings, "show_presets");
}
-1);
gtk_tree_model_get(GTK_TREE_MODEL(store), &iter, 0, &index, -1);
- GValue *chapters;
+ const GValue *chapters;
GValue *chapter;
chapters = ghb_settings_get_value(ud->settings, "chapter_list");
}
}
-static void
-set_visible(GtkWidget *widget, gboolean visible)
-{
- if (visible)
- {
- gtk_widget_show_now(widget);
- }
- else
- {
- gtk_widget_hide(widget);
- }
-}
-
void
ghb_hbfd(signal_user_data_t *ud, gboolean hbfd)
{
set_visible(widget, !hbfd);
widget = GHB_WIDGET(ud->builder, "presets_remove");
set_visible(widget, !hbfd);
- widget = GHB_WIDGET(ud->builder, "presets_default");
- set_visible(widget, !hbfd);
widget = GHB_WIDGET (ud->builder, "hb_window");
gtk_window_resize(GTK_WINDOW(widget), 16, 16);
ghb_widget_to_setting (ud->settings, widget);
const gchar *name = gtk_widget_get_name(widget);
ghb_pref_save(ud->settings, name);
-
- gboolean tweaks = ghb_settings_get_boolean(ud->settings, "allow_tweaks");
- widget = GHB_WIDGET(ud->builder, "PictureDeinterlace");
- tweaks ? gtk_widget_hide(widget) : gtk_widget_show(widget);
- widget = GHB_WIDGET(ud->builder, "tweak_PictureDeinterlace");
- !tweaks ? gtk_widget_hide(widget) : gtk_widget_show(widget);
-
- widget = GHB_WIDGET(ud->builder, "PictureDenoise");
- tweaks ? gtk_widget_hide(widget) : gtk_widget_show(widget);
- widget = GHB_WIDGET(ud->builder, "tweak_PictureDenoise");
- !tweaks ? gtk_widget_hide(widget) : gtk_widget_show(widget);
- if (tweaks)
- {
- const GValue *value;
- value = ghb_settings_get_value(ud->settings, "PictureDeinterlace");
- ghb_ui_update(ud, "tweak_PictureDeinterlace", value);
- value = ghb_settings_get_value(ud->settings, "PictureDenoise");
- ghb_ui_update(ud, "tweak_PictureDenoise", value);
- }
- else
- {
- const GValue *value;
- value = ghb_settings_get_value(ud->settings, "tweak_PictureDeinterlace");
- ghb_ui_update(ud, "PictureDeinterlace", value);
- value = ghb_settings_get_value(ud->settings, "tweak_PictureDenoise");
- ghb_ui_update(ud, "PictureDenoise", value);
- }
}
void
return dvd_devices;
}
-
-static DBusConnection *dbus_connection = NULL;
static LibHalContext *hal_ctx;
gboolean
update_source_label(ud, device);
ghb_hb_cleanup(TRUE);
prune_logs(ud);
- ghb_backend_scan(device, 0);
+ gint preview_count;
+ preview_count = ghb_settings_get_int(ud->settings, "preview_count");
+ ghb_backend_scan(device, 0, preview_count);
}
else
{
ghb_hb_cleanup(TRUE);
prune_logs(ud);
- ghb_backend_scan("/dev/null", 0);
+ ghb_backend_scan("/dev/null", 0, 1);
}
}
g_free(device);
}
-static gboolean
+static void
dbus_init (void)
{
- DBusError error;
+ dbus_g_thread_init();
+}
- if (dbus_connection != NULL)
- return TRUE;
+#define GPM_DBUS_SERVICE "org.freedesktop.PowerManagement"
+#define GPM_DBUS_INHIBIT_PATH "/org/freedesktop/PowerManagement/Inhibit"
+#define GPM_DBUS_INHIBIT_INTERFACE "org.freedesktop.PowerManagement.Inhibit"
+static gboolean gpm_inhibited = FALSE;
+static guint gpm_cookie = -1;
- dbus_error_init (&error);
- if (!(dbus_connection = dbus_bus_get (DBUS_BUS_SYSTEM, &error))) {
- g_debug ("could not get system bus: %s", error.message);
- dbus_error_free (&error);
- return FALSE;
+void
+ghb_inhibit_gpm()
+{
+ DBusGConnection *conn;
+ DBusGProxy *proxy;
+ GError *error = NULL;
+ gboolean res;
+
+
+ if (gpm_inhibited)
+ {
+ // Already inhibited
+ return;
+ }
+ g_debug("ghb_inhibit_gpm()");
+ conn = dbus_g_bus_get(DBUS_BUS_SESSION, &error);
+ if (error != NULL)
+ {
+ g_debug("DBUS cannot connect: %s", error->message);
+ g_error_free(error);
+ return;
+ }
+ proxy = dbus_g_proxy_new_for_name(conn, GPM_DBUS_SERVICE,
+ GPM_DBUS_INHIBIT_PATH, GPM_DBUS_INHIBIT_INTERFACE);
+ if (proxy == NULL)
+ {
+ g_debug("Could not get DBUS proxy: %s", GPM_DBUS_SERVICE);
+ dbus_g_connection_unref(conn);
+ return;
}
+ res = dbus_g_proxy_call(proxy, "Inhibit", &error,
+ G_TYPE_STRING, "ghb",
+ G_TYPE_STRING, "Encoding",
+ G_TYPE_INVALID,
+ G_TYPE_UINT, &gpm_cookie,
+ G_TYPE_INVALID);
+ if (!res)
+ {
+ g_warning("Inhibit method failed");
+ gpm_cookie = -1;
+ }
+ if (error != NULL)
+ {
+ g_warning("Inhibit problem: %s", error->message);
+ g_error_free(error);
+ gpm_cookie = -1;
+ }
+ gpm_inhibited = TRUE;
+ g_object_unref(G_OBJECT(proxy));
+ dbus_g_connection_unref(conn);
+}
- //dbus_connection_setup_with_g_main (dbus_connection, NULL);
- //dbus_connection_set_exit_on_disconnect (dbus_connection, FALSE);
- //dbus_connection_add_filter (dbus_connection, gvm_dbus_filter_function, NULL, NULL);
+void
+ghb_uninhibit_gpm()
+{
+ DBusGConnection *conn;
+ DBusGProxy *proxy;
+ GError *error = NULL;
+ gboolean res;
+
+ g_debug("ghb_uninhibit_gpm() gpm_cookie %u", gpm_cookie);
- return TRUE;
+ if (!gpm_inhibited)
+ {
+ // Not inhibited
+ return;
+ }
+ conn = dbus_g_bus_get(DBUS_BUS_SESSION, &error);
+ if (error != NULL)
+ {
+ g_debug("DBUS cannot connect: %s", error->message);
+ g_error_free(error);
+ return;
+ }
+ proxy = dbus_g_proxy_new_for_name(conn, GPM_DBUS_SERVICE,
+ GPM_DBUS_INHIBIT_PATH, GPM_DBUS_INHIBIT_INTERFACE);
+ if (proxy == NULL)
+ {
+ g_debug("Could not get DBUS proxy: %s", GPM_DBUS_SERVICE);
+ dbus_g_connection_unref(conn);
+ return;
+ }
+ res = dbus_g_proxy_call(proxy, "UnInhibit", &error,
+ G_TYPE_UINT, gpm_cookie,
+ G_TYPE_INVALID,
+ G_TYPE_INVALID);
+ if (!res)
+ {
+ g_warning("UnInhibit method failed");
+ }
+ if (error != NULL)
+ {
+ g_warning("UnInhibit problem: %s", error->message);
+ g_error_free(error);
+ }
+ gpm_inhibited = FALSE;
+ dbus_g_connection_unref(conn);
+ g_object_unref(G_OBJECT(proxy));
}
void
ghb_hal_init()
{
+ DBusGConnection *gconn;
+ DBusConnection *conn;
+ GError *gerror = NULL;
DBusError error;
char **devices;
int nr;
- if (!dbus_init ())
- return;
+ dbus_init ();
if (!(hal_ctx = libhal_ctx_new ())) {
g_warning ("failed to create a HAL context!");
return;
}
- libhal_ctx_set_dbus_connection (hal_ctx, dbus_connection);
+ gconn = dbus_g_bus_get(DBUS_BUS_SYSTEM, &gerror);
+ if (gerror != NULL)
+ {
+ g_warning("DBUS cannot connect: %s", gerror->message);
+ g_error_free(gerror);
+ return;
+ }
+ conn = dbus_g_connection_get_connection(gconn);
+ libhal_ctx_set_dbus_connection (hal_ctx, conn);
dbus_error_init (&error);
if (!libhal_ctx_init (hal_ctx, &error)) {
g_warning ("libhal_ctx_init failed: %s", error.message ? error.message : "unknown");
dbus_error_free (&error);
libhal_ctx_free (hal_ctx);
+ dbus_g_connection_unref(gconn);
return;
}
libhal_ctx_shutdown (hal_ctx, NULL);
libhal_ctx_free (hal_ctx);
+ dbus_g_connection_unref(gconn);
return;
}
libhal_free_string_array (devices);
-
- //gvm_hal_claim_branch ("/org/freedesktop/Hal/devices/local");
+ dbus_g_connection_unref(gconn);
}
gboolean
browse_url(url);
}
-static gboolean check_stable_update(signal_user_data_t *ud);
+static gpointer check_stable_update(signal_user_data_t *ud);
static gboolean stable_update_lock = FALSE;
static void
|| ibuild <= HB_BUILD || skip == ibuild)
{
if (!stable_update_lock && HB_BUILD % 100)
- g_idle_add((GSourceFunc)check_stable_update, ud);
+ g_thread_create((GThreadFunc)check_stable_update, ud, FALSE, NULL);
goto done;
}
msg = g_strdup_printf("HandBrake %s/%s is now available (you have %s/%d).",
return ioc;
}
-gboolean
+gpointer
ghb_check_update(signal_user_data_t *ud)
{
gchar *query;
}
ioc = ghb_net_open(ud, "handbrake.fr", 80);
if (ioc == NULL)
- return FALSE;
+ return NULL;
g_io_channel_write_chars(ioc, query, strlen(query), &len, &gerror);
g_io_channel_flush(ioc, &gerror);
// This function is initiated by g_idle_add. Must return false
// so that it is not called again
- return FALSE;
+ return NULL;
}
-static gboolean
+static gpointer
check_stable_update(signal_user_data_t *ud)
{
gchar *query;
query = "GET /appcast.xml HTTP/1.0\r\nHost: handbrake.fr\r\n\r\n";
ioc = ghb_net_open(ud, "handbrake.fr", 80);
if (ioc == NULL)
- return FALSE;
+ return NULL;
g_io_channel_write_chars(ioc, query, strlen(query), &len, &gerror);
g_io_channel_flush(ioc, &gerror);
// This function is initiated by g_idle_add. Must return false
// so that it is not called again
- return FALSE;
+ return NULL;
}
OSDN Git Service
