static void check_button_toggled(GtkWidget *widget, gpointer user_data)
{
CtkXVideo *ctk_xvideo = CTK_XVIDEO(user_data);
gint attribute, enabled;
gchar *str;
user_data = g_object_get_data(G_OBJECT(widget), "xvideo_attribute");
attribute = GPOINTER_TO_INT(user_data);
enabled = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget));
NvCtrlSetAttribute(ctk_xvideo->handle, attribute, enabled);
switch (attribute) {
case NV_CTRL_ATTR_XV_TEXTURE_SYNC_TO_VBLANK:
str = "Texture Sync To VBlank"; break;
case NV_CTRL_ATTR_XV_BLITTER_SYNC_TO_VBLANK:
str = "Blitter Sync To VBlank"; break;
default:
return;
}
sensitize_radio_buttons(ctk_xvideo);
post_check_button_toggled(ctk_xvideo, str, enabled);
} /* check_button_toggled() */
/*
* Handles NV_CTRL_ENABLED_DISPLAYS events and updates
* the list of displays in the UI.
*/
static void enabled_displays_handler(GObject *object, gpointer arg1,
gpointer user_data)
{
CtkXVideo *ctk_xvideo = CTK_XVIDEO(user_data);
xv_sync_to_display_rebuild_buttons(ctk_xvideo, TRUE);
}
static void slider_changed(GtkAdjustment *adjustment, gpointer user_data)
{
CtkXVideo *ctk_xvideo = CTK_XVIDEO(user_data);
gint attribute, value;
gchar *str;
user_data = g_object_get_data(G_OBJECT(adjustment), "xvideo_attribute");
attribute = GPOINTER_TO_INT(user_data);
value = (gint) adjustment->value;
NvCtrlSetAttribute(ctk_xvideo->handle, attribute, value);
switch (attribute) {
case NV_CTRL_ATTR_XV_OVERLAY_SATURATION: str = "Overlay Saturation"; break;
case NV_CTRL_ATTR_XV_OVERLAY_CONTRAST: str = "Overlay Contrast"; break;
case NV_CTRL_ATTR_XV_OVERLAY_BRIGHTNESS: str = "Overlay Brightness"; break;
case NV_CTRL_ATTR_XV_OVERLAY_HUE: str = "Overlay Hue"; break;
case NV_CTRL_ATTR_XV_TEXTURE_CONTRAST: str = "Texture Contrast"; break;
case NV_CTRL_ATTR_XV_TEXTURE_BRIGHTNESS: str = "Texture Brightness"; break;
case NV_CTRL_ATTR_XV_TEXTURE_HUE: str = "Texture Hue"; break;
case NV_CTRL_ATTR_XV_TEXTURE_SATURATION: str = "Texture Saturation"; break;
default:
return;
}
ctk_config_statusbar_message(ctk_xvideo->ctk_config,
"Set XVideo %s to %d.", str, value);
} /* slider_changed() */
static void xv_sync_to_display_update_received(GtkObject *object,
gpointer arg1,
gpointer user_data)
{
CtkEventStruct *event_struct = (CtkEventStruct *) arg1;
CtkXVideo *ctk_xvideo = CTK_XVIDEO(user_data);
gint i;
GtkWidget *b;
switch (event_struct->attribute) {
case NV_CTRL_XV_SYNC_TO_DISPLAY:
for (i = 0; i < 24; i++) {
b = ctk_xvideo->xv_sync_to_display_buttons[i];
if (!b) continue;
user_data = g_object_get_data(G_OBJECT(b), "xv_sync_to_display");
if (GPOINTER_TO_INT(user_data) == event_struct->value) {
xv_sync_to_display_update_radio_buttons(ctk_xvideo, i);
break;
}
}
break;
default:
break;
}
} /* xv_sync_to_display_update_received() */
static void reset_defaults(GtkButton *button, gpointer user_data)
{
CtkXVideo *ctk_xvideo = CTK_XVIDEO(user_data);
/*
* XXX should we expose separate buttons for each adaptor's
* defaults?
*/
NvCtrlSetAttribute(ctk_xvideo->handle,
NV_CTRL_ATTR_XV_OVERLAY_SET_DEFAULTS, 1);
NvCtrlSetAttribute(ctk_xvideo->handle,
NV_CTRL_ATTR_XV_TEXTURE_SET_DEFAULTS, 1);
NvCtrlSetAttribute(ctk_xvideo->handle,
NV_CTRL_ATTR_XV_BLITTER_SET_DEFAULTS, 1);
reset_slider(ctk_xvideo, ctk_xvideo->overlay_saturation,
NV_CTRL_ATTR_XV_OVERLAY_SATURATION);
reset_slider(ctk_xvideo, ctk_xvideo->overlay_contrast,
NV_CTRL_ATTR_XV_OVERLAY_CONTRAST);
reset_slider(ctk_xvideo, ctk_xvideo->overlay_brightness,
NV_CTRL_ATTR_XV_OVERLAY_BRIGHTNESS);
reset_slider(ctk_xvideo, ctk_xvideo->overlay_hue,
NV_CTRL_ATTR_XV_OVERLAY_HUE);
reset_check_button(ctk_xvideo, ctk_xvideo->texture_sync_to_blank,
NV_CTRL_ATTR_XV_TEXTURE_SYNC_TO_VBLANK);
reset_slider(ctk_xvideo, ctk_xvideo->texture_contrast,
NV_CTRL_ATTR_XV_TEXTURE_CONTRAST);
reset_slider(ctk_xvideo, ctk_xvideo->texture_brightness,
NV_CTRL_ATTR_XV_TEXTURE_BRIGHTNESS);
reset_slider(ctk_xvideo, ctk_xvideo->texture_hue,
NV_CTRL_ATTR_XV_TEXTURE_HUE);
reset_slider(ctk_xvideo, ctk_xvideo->texture_saturation,
NV_CTRL_ATTR_XV_TEXTURE_SATURATION);
reset_check_button(ctk_xvideo, ctk_xvideo->blitter_sync_to_blank,
NV_CTRL_ATTR_XV_BLITTER_SYNC_TO_VBLANK);
gtk_widget_set_sensitive(GTK_WIDGET(button), FALSE);
ctk_config_statusbar_message
(CTK_CONFIG(ctk_xvideo->ctk_config),
"Reset XVideo hardware defaults.");
}
/*
* Handler for NV_CTRL_XV_SYNC_TO_DISPLAY_ID events.
*/
static void xv_sync_to_display_id_handler(GObject *object,
CtrlEvent *event,
gpointer user_data)
{
CtkXVideo *ctk_xvideo = CTK_XVIDEO(user_data);
if (event->type != CTRL_EVENT_TYPE_INTEGER_ATTRIBUTE) {
return;
}
/*
* Find and enable the button for the correct display id, otherwise enable
* the unspecified option.
*/
if (!xv_sync_to_display_enable_index(ctk_xvideo, event->int_attr.value))
{
xv_sync_to_display_enable_index(ctk_xvideo,
NV_CTRL_XV_SYNC_TO_DISPLAY_ID_AUTO);
}
}
/*
* nv_ctrl_enabled_displays()
*/
static void nv_ctrl_enabled_displays(GtkObject *object, gpointer arg1,
gpointer user_data)
{
CtkXVideo *ctk_xvideo = CTK_XVIDEO(user_data);
CtkEventStruct *event_struct = (CtkEventStruct *) arg1;
int i, enabled, prev_enabled = 0;
int remove_devices_mask, add_devices_mask;
unsigned int mask;
gpointer udata;
GtkWidget *b;
enabled = event_struct->value;
/* Extract the previous value. */
for ( i = 0; i < 24; i++) {
b = ctk_xvideo->xv_sync_to_display_buttons[i];
if (b == NULL) continue;
udata = g_object_get_data(G_OBJECT(b),
"xv_sync_to_display");
prev_enabled |= GPOINTER_TO_INT(udata);
}
/* Remove devices that were previously enabled but are no
* longer enabled. */
remove_devices_mask = (prev_enabled & (~enabled));
/* Add devices that were not previously enabled */
add_devices_mask = (enabled & (~prev_enabled));
prev_enabled = enabled;
for (mask = 1; mask; mask <<= 1) {
if (mask & add_devices_mask)
xv_sync_to_display_radio_button_enabled_add(ctk_xvideo, mask);
if (mask & remove_devices_mask)
xv_sync_to_display_radio_button_remove(ctk_xvideo, mask);
}
sensitize_radio_buttons(ctk_xvideo);
gtk_widget_show_all(ctk_xvideo->xv_sync_to_display_button_box);
} /* nv_ctrl_enabled_displays() */
/*
* xv_sync_to_display_id_toggled() - callback function for changes to the
* sync_to_display radio button group; if the specified radio button is
* active, send xv_sync_to_display state to the server
*/
static void xv_sync_to_display_id_toggled(GtkWidget *widget,
gpointer user_data)
{
CtkXVideo *ctk_xvideo = CTK_XVIDEO(user_data);
CtrlTarget *ctrl_target = ctk_xvideo->ctrl_target;
gboolean enabled;
gint device_id;
enabled = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget));
if (!enabled) {
/* Ignore 'disable' events. */
return;
}
user_data = g_object_get_data(G_OBJECT(widget), "display_id");
device_id = GPOINTER_TO_INT(user_data);
NvCtrlSetAttribute(ctrl_target, NV_CTRL_XV_SYNC_TO_DISPLAY_ID, device_id);
post_xv_sync_to_display_update(ctk_xvideo, widget);
}
/*
* Handler for NV_CTRL_CURRENT_XV_SYNC_TO_DISPLAY_ID events.
*/
static void current_xv_sync_to_display_id_handler(GObject *object,
CtrlEvent *event,
gpointer user_data)
{
CtkXVideo *ctk_xvideo = CTK_XVIDEO(user_data);
gchar *current_sync_name;
if (event->type != CTRL_EVENT_TYPE_INTEGER_ATTRIBUTE) {
return;
}
/*
* Find and enable the button for the correct display id, otherwise enable
* the unspecified option.
*/
current_sync_name =
xv_sync_to_display_radio_button_label(ctk_xvideo, event->int_attr.value);
gtk_label_set_text(GTK_LABEL(ctk_xvideo->current_xv_sync_to_display_label),
current_sync_name);
g_free(current_sync_name);
}
static void xv_sync_to_display_changed(GtkWidget *widget, gpointer user_data)
{
CtkXVideo *ctk_xvideo = CTK_XVIDEO(user_data);
gboolean enabled;
gint value;
gchar *label;
enabled = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget));
if (enabled) {
user_data = g_object_get_data(G_OBJECT(widget), "xv_sync_to_display");
value = GPOINTER_TO_INT(user_data);
NvCtrlSetAttribute(ctk_xvideo->handle,
NV_CTRL_XV_SYNC_TO_DISPLAY, value);
gtk_label_get(GTK_LABEL(GTK_BIN(widget)->child), &label);
post_xv_sync_to_display_changed(ctk_xvideo, enabled, label);
}
}/* xv_sync_to_display_changed() */
GtkWidget* ctk_xvideo_new(NvCtrlAttributeHandle *handle,
CtkConfig *ctk_config,
CtkEvent *ctk_event)
{
GObject *object;
CtkXVideo *ctk_xvideo;
GtkWidget *banner;
GtkWidget *frame;
GtkWidget *alignment;
GtkWidget *hbox;
GtkWidget *label;
GtkWidget *vbox;
GtkWidget *button;
int sync_mask;
int xv_overlay_present, xv_texture_present, xv_blitter_present;
ReturnStatus ret;
/*
* before we do anything else, determine if any of the Xv adapters
* are present
*/
ret = NvCtrlGetAttribute(handle, NV_CTRL_ATTR_EXT_XV_OVERLAY_PRESENT,
&xv_overlay_present);
if (ret != NvCtrlSuccess) xv_overlay_present = FALSE;
ret = NvCtrlGetAttribute(handle, NV_CTRL_ATTR_EXT_XV_TEXTURE_PRESENT,
&xv_texture_present);
if (ret != NvCtrlSuccess) xv_texture_present = FALSE;
ret = NvCtrlGetAttribute(handle, NV_CTRL_ATTR_EXT_XV_BLITTER_PRESENT,
&xv_blitter_present);
if (ret != NvCtrlSuccess) xv_blitter_present = FALSE;
if (!xv_overlay_present && !xv_texture_present && !xv_blitter_present) {
return NULL;
}
/* create the XVideo widget */
object = g_object_new(CTK_TYPE_XVIDEO, NULL);
ctk_xvideo = CTK_XVIDEO(object);
ctk_xvideo->handle = handle;
ctk_xvideo->ctk_config = ctk_config;
ctk_xvideo->active_attributes = 0;
gtk_box_set_spacing(GTK_BOX(ctk_xvideo), 10);
/* Create button, but don't pack it, yet */
label = gtk_label_new("Reset Hardware Defaults");
hbox = gtk_hbox_new(FALSE, 0);
button = gtk_button_new();
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 15);
gtk_container_add(GTK_CONTAINER(button), hbox);
g_signal_connect(G_OBJECT(button), "clicked",
G_CALLBACK(reset_defaults), (gpointer) ctk_xvideo);
ctk_config_set_tooltip(ctk_config, button, __reset_button_help);
/* Video film banner */
banner = ctk_banner_image_new(BANNER_ARTWORK_XVIDEO);
gtk_box_pack_start(GTK_BOX(object), banner, FALSE, FALSE, 0);
/* XVideo Overlay sliders */
if (xv_overlay_present) {
frame = gtk_frame_new("Video Overlay Adaptor");
gtk_box_pack_start(GTK_BOX(object), frame, FALSE, FALSE, 0);
vbox = gtk_vbox_new(FALSE, 5);
gtk_container_set_border_width(GTK_CONTAINER(vbox), FRAME_PADDING);
gtk_container_add(GTK_CONTAINER(frame), vbox);
ctk_xvideo->overlay_saturation =
create_slider(ctk_xvideo, vbox, button, "Saturation",
__xv_overlay_saturation_help,
NV_CTRL_ATTR_XV_OVERLAY_SATURATION,
__XV_OVERLAY_SATURATION);
ctk_xvideo->overlay_contrast =
create_slider(ctk_xvideo, vbox, button, "Contrast",
__xv_overlay_contrast_help,
NV_CTRL_ATTR_XV_OVERLAY_CONTRAST,
__XV_OVERLAY_CONTRAST);
ctk_xvideo->overlay_brightness =
create_slider(ctk_xvideo, vbox, button, "Brightness",
__xv_overlay_brightness_help,
NV_CTRL_ATTR_XV_OVERLAY_BRIGHTNESS,
__XV_OVERLAY_BRIGHTNESS);
ctk_xvideo->overlay_hue =
create_slider(ctk_xvideo, vbox, button, "Hue",
__xv_overlay_hue_help,
NV_CTRL_ATTR_XV_OVERLAY_HUE,
__XV_OVERLAY_HUE);
}
/* XVideo Texture */
if (xv_texture_present) {
frame = gtk_frame_new("Video Texture Adaptor");
gtk_box_pack_start(GTK_BOX(object), frame, FALSE, FALSE, 0);
vbox = gtk_vbox_new(FALSE, 5);
gtk_container_set_border_width(GTK_CONTAINER(vbox), FRAME_PADDING);
gtk_container_add(GTK_CONTAINER(frame), vbox);
ctk_xvideo->texture_sync_to_blank =
create_check_button(ctk_xvideo, vbox, button, "Sync to VBlank",
__xv_texture_sync_to_vblank_help,
NV_CTRL_ATTR_XV_TEXTURE_SYNC_TO_VBLANK,
__XV_TEXTURE_SYNC_TO_VBLANK);
ctk_xvideo->texture_brightness =
create_slider(ctk_xvideo, vbox, button, "Brightness",
__xv_texture_brightness_help,
NV_CTRL_ATTR_XV_TEXTURE_BRIGHTNESS,
__XV_TEXTURE_BRIGHTNESS);
ctk_xvideo->texture_contrast =
create_slider(ctk_xvideo, vbox, button, "Contrast",
__xv_texture_contrast_help,
NV_CTRL_ATTR_XV_TEXTURE_CONTRAST,
__XV_TEXTURE_CONTRAST);
ctk_xvideo->texture_hue =
create_slider(ctk_xvideo, vbox, button, "Hue",
__xv_texture_hue_help,
NV_CTRL_ATTR_XV_TEXTURE_HUE,
__XV_TEXTURE_HUE);
ctk_xvideo->texture_saturation =
create_slider(ctk_xvideo, vbox, button, "Saturation",
__xv_texture_saturation_help,
NV_CTRL_ATTR_XV_TEXTURE_SATURATION,
__XV_TEXTURE_SATURATION);
}
/* XVideo Blitter */
if (xv_blitter_present) {
frame = gtk_frame_new("Video Blitter Adaptor Settings");
gtk_box_pack_start(GTK_BOX(object), frame, FALSE, FALSE, 0);
vbox = gtk_vbox_new(FALSE, 5);
gtk_container_set_border_width(GTK_CONTAINER(vbox), FRAME_PADDING);
gtk_container_add(GTK_CONTAINER(frame), vbox);
ctk_xvideo->blitter_sync_to_blank =
create_check_button(ctk_xvideo,
vbox,
button,
"Sync to VBlank",
__xv_blitter_sync_to_vblank_help,
NV_CTRL_ATTR_XV_BLITTER_SYNC_TO_VBLANK,
__XV_BLITTER_SYNC_TO_VBLANK);
}
/* Sync to display selection */
if (xv_texture_present || xv_blitter_present) {
ret = NvCtrlGetAttribute(handle,
NV_CTRL_XV_SYNC_TO_DISPLAY,
&sync_mask);
if (ret == NvCtrlSuccess) {
int enabled;
ret = NvCtrlGetAttribute(handle,
NV_CTRL_ENABLED_DISPLAYS,
&enabled);
if (ret == NvCtrlSuccess) {
GtkWidget *radio[24], *prev_radio;
int i, n, current = -1, mask;
char *name, *type;
gchar *name_str;
frame = gtk_frame_new("Sync to this display device");
gtk_box_pack_start(GTK_BOX(object), frame, FALSE, FALSE, 0);
vbox = gtk_vbox_new(FALSE, 5);
gtk_container_set_border_width(GTK_CONTAINER(vbox), FRAME_PADDING);
gtk_container_add(GTK_CONTAINER(frame), vbox);
ctk_xvideo->xv_sync_to_display_button_box = vbox;
for (n=0, i = 0; i < 24; i++) {
mask = 1 << i;
if (!(enabled & mask)) continue;
/* get the name of the display device */
ret = NvCtrlGetStringDisplayAttribute(handle, mask,
NV_CTRL_STRING_DISPLAY_DEVICE_NAME,
&name);
if ((ret != NvCtrlSuccess) || (!name)) {
name = g_strdup("Unknown");
}
/* get the display device type */
type = display_device_mask_to_display_device_name(mask);
name_str = g_strdup_printf("%s (%s)", name, type);
XFree(name);
free(type);
if (n==0) {
prev_radio = NULL;
} else {
prev_radio = radio[n-1];
}
radio[n] = xv_sync_to_display_radio_button_add(ctk_xvideo,
prev_radio,
name_str,
mask, n);
g_free(name_str);
ctk_config_set_tooltip(ctk_config, radio[n],
__xv_sync_to_display_help);
if (mask == sync_mask) {
current = n;
}
n++;
ctk_xvideo->active_attributes |= __XV_SYNC_TO_DISPLAY;
}
g_signal_connect(G_OBJECT(ctk_event),
CTK_EVENT_NAME(NV_CTRL_XV_SYNC_TO_DISPLAY),
G_CALLBACK(xv_sync_to_display_update_received),
(gpointer) ctk_xvideo);
g_signal_connect(G_OBJECT(ctk_event),
CTK_EVENT_NAME(NV_CTRL_ENABLED_DISPLAYS),
G_CALLBACK(nv_ctrl_enabled_displays),
(gpointer) ctk_xvideo);
sensitize_radio_buttons(ctk_xvideo);
if (current != -1)
xv_sync_to_display_update_radio_buttons(ctk_xvideo, current);
}
}
}
/* Reset button */
sensitize_radio_buttons(ctk_xvideo);
alignment = gtk_alignment_new(1, 1, 0, 0);
gtk_container_add(GTK_CONTAINER(alignment), button);
gtk_box_pack_start(GTK_BOX(object), alignment, TRUE, TRUE, 0);
/* finally, show the widget */
gtk_widget_show_all(GTK_WIDGET(ctk_xvideo));
return GTK_WIDGET(ctk_xvideo);
} /* ctk_xvideo_new() */
/*
* ctk_xvideo_new() - constructor for the XVideo widget
*/
GtkWidget* ctk_xvideo_new(CtrlTarget *ctrl_target,
CtkConfig *ctk_config,
CtkEvent *ctk_event)
{
GObject *object;
CtkXVideo *ctk_xvideo;
GtkWidget *banner;
GtkWidget *frame;
GtkWidget *alignment;
GtkWidget *vbox;
GtkWidget *hbox;
GtkWidget *label;
GtkWidget *hseparator;
int xv_overlay_present, xv_texture_present, xv_blitter_present;
int display_id;
gboolean show_page;
ReturnStatus ret;
gchar *current_sync_name;
/*
* before we do anything else, determine if any of the Xv adapters
* are present
*/
ret = NvCtrlGetAttribute(ctrl_target, NV_CTRL_ATTR_EXT_XV_OVERLAY_PRESENT,
&xv_overlay_present);
if (ret != NvCtrlSuccess) {
xv_overlay_present = FALSE;
}
ret = NvCtrlGetAttribute(ctrl_target, NV_CTRL_ATTR_EXT_XV_TEXTURE_PRESENT,
&xv_texture_present);
if (ret != NvCtrlSuccess) {
xv_texture_present = FALSE;
}
ret = NvCtrlGetAttribute(ctrl_target, NV_CTRL_ATTR_EXT_XV_BLITTER_PRESENT,
&xv_blitter_present);
if (ret != NvCtrlSuccess) {
xv_blitter_present = FALSE;
}
if (!xv_overlay_present && !xv_texture_present && !xv_blitter_present) {
return NULL;
}
/* If nothing to show, bail */
show_page = FALSE;
if (xv_texture_present || xv_blitter_present) {
ret = NvCtrlGetAttribute(ctrl_target,
NV_CTRL_XV_SYNC_TO_DISPLAY_ID,
&display_id);
if (ret == NvCtrlSuccess) {
show_page = TRUE;
}
}
if (!show_page) {
return NULL;
}
/* create the XVideo widget */
object = g_object_new(CTK_TYPE_XVIDEO, NULL);
ctk_xvideo = CTK_XVIDEO(object);
ctk_xvideo->ctrl_target = ctrl_target;
ctk_xvideo->ctk_config = ctk_config;
ctk_xvideo->active_attributes = 0;
gtk_box_set_spacing(GTK_BOX(ctk_xvideo), 10);
/* Video film banner */
banner = ctk_banner_image_new(BANNER_ARTWORK_XVIDEO);
gtk_box_pack_start(GTK_BOX(object), banner, FALSE, FALSE, 0);
/* Top Label */
hbox = gtk_hbox_new(FALSE, 5);
gtk_box_pack_start(GTK_BOX(object), hbox, FALSE, FALSE, 0);
label = gtk_label_new("Xvideo Settings");
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
hseparator = gtk_hseparator_new();
gtk_box_pack_start(GTK_BOX(hbox), hseparator, TRUE, TRUE, 0);
/* Current Sync Value */
ret = NvCtrlGetAttribute(ctrl_target,
NV_CTRL_CURRENT_XV_SYNC_TO_DISPLAY_ID,
&display_id);
if (ret == NvCtrlSuccess) {
hbox = gtk_hbox_new(FALSE, 5);
gtk_box_pack_start(GTK_BOX(object), hbox, FALSE, FALSE, 5);
label = gtk_label_new("Currently synced to display:");
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 5);
label = gtk_label_new("");
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 5);
current_sync_name = xv_sync_to_display_radio_button_label(ctk_xvideo,
display_id);
gtk_label_set_text(GTK_LABEL(label), current_sync_name);
g_free(current_sync_name);
ctk_xvideo->current_xv_sync_to_display_label = label;
} else {
ctk_xvideo->current_xv_sync_to_display_label = NULL;
}
/* Sync to display selection */
frame = gtk_frame_new("Sync to this display device");
gtk_box_pack_start(GTK_BOX(object), frame, FALSE, FALSE, 0);
vbox = gtk_vbox_new(FALSE, 5);
gtk_container_set_border_width(GTK_CONTAINER(vbox), FRAME_PADDING);
gtk_container_add(GTK_CONTAINER(frame), vbox);
ctk_xvideo->xv_sync_to_display_button_box = vbox;
xv_sync_to_display_rebuild_buttons(ctk_xvideo, FALSE);
g_signal_connect(G_OBJECT(ctk_event),
CTK_EVENT_NAME(NV_CTRL_XV_SYNC_TO_DISPLAY_ID),
G_CALLBACK(xv_sync_to_display_id_handler),
(gpointer) ctk_xvideo);
if (ctk_xvideo->current_xv_sync_to_display_label) {
g_signal_connect(G_OBJECT(ctk_event),
CTK_EVENT_NAME(NV_CTRL_CURRENT_XV_SYNC_TO_DISPLAY_ID),
G_CALLBACK(current_xv_sync_to_display_id_handler),
(gpointer) ctk_xvideo);
}
g_signal_connect(G_OBJECT(ctk_event),
CTK_EVENT_NAME(NV_CTRL_ENABLED_DISPLAYS),
G_CALLBACK(enabled_displays_handler),
(gpointer) ctk_xvideo);
alignment = gtk_alignment_new(1, 1, 0, 0);
gtk_box_pack_start(GTK_BOX(object), alignment, TRUE, TRUE, 0);
/* finally, show the widget */
gtk_widget_show_all(GTK_WIDGET(ctk_xvideo));
return GTK_WIDGET(ctk_xvideo);
}
