/*****
*
* Signal handler - User clicked the 'reset hardware defaults' button.
*
*/
static void reset_clocks_clicked(GtkWidget *widget, gpointer user_data)
{
CtkClocks *ctk_object = CTK_CLOCKS(user_data);
int clocks;
ReturnStatus ret;
/* Get the default clock frequencies */
ret = NvCtrlGetAttribute(ctk_object->handle,
(ctk_object->clocks_being_modified==CLOCKS_2D) ?
NV_CTRL_GPU_DEFAULT_2D_CLOCK_FREQS :
NV_CTRL_GPU_DEFAULT_3D_CLOCK_FREQS,
&clocks);
if ( ret != NvCtrlSuccess )
goto fail;
/* Set clock frequencies to use default values */
ret = NvCtrlSetAttribute(ctk_object->handle,
(ctk_object->clocks_being_modified==CLOCKS_2D) ?
NV_CTRL_GPU_2D_CLOCK_FREQS :
NV_CTRL_GPU_3D_CLOCK_FREQS,
clocks);
if ( ret != NvCtrlSuccess )
goto fail;
/* Set slider positions */
set_clocks_value(ctk_object, clocks, ctk_object->clocks_being_modified);
ctk_config_statusbar_message(ctk_object->ctk_config,
"Reset %s clock frequency "
"hardware defaults.",
(ctk_object->clocks_being_modified==CLOCKS_2D)?
"2D":"3D");
/* Disable the apply button */
gtk_widget_set_sensitive(ctk_object->apply_button, False);
/* Disable the reset button */
gtk_widget_set_sensitive(ctk_object->reset_button, False);
return;
fail:
ctk_config_statusbar_message(ctk_object->ctk_config,
"Failed to reset clock frequencies!");
return;
} /* reset_clocks_clicked() */
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
post_dfp_scaling_update(CtkDisplayDeviceDfp *ctk_display_device_dfp,
gint value)
{
int scaling_target = GET_SCALING_TARGET(value);
int scaling_method = GET_SCALING_METHOD(value);
static const char *scaling_target_string_table[] = {
"Best Fit", /* NV_CTRL_GPU_SCALING_TARGET_FLATPANEL_BEST_FIT */
"Native", /* NV_CTRL_GPU_SCALING_TARGET_FLATPANEL_NATIVE */
};
static const char *scaling_method_string_table[] = {
"Stretched", /* NV_CTRL_GPU_SCALING_METHOD_STRETCHED */
"Centered", /* NV_CTRL_GPU_SCALING_METHOD_CENTERED */
"Aspect Ratio Scaled" /* NV_CTRL_GPU_SCALING_METHOD_ASPECT_SCALED */
};
if ((scaling_target < NV_CTRL_GPU_SCALING_TARGET_FLATPANEL_BEST_FIT) ||
(scaling_target > NV_CTRL_GPU_SCALING_TARGET_FLATPANEL_NATIVE)) return;
if ((scaling_method < NV_CTRL_GPU_SCALING_METHOD_STRETCHED) ||
(scaling_method > NV_CTRL_GPU_SCALING_METHOD_ASPECT_SCALED)) return;
ctk_config_statusbar_message(ctk_display_device_dfp->ctk_config,
"Set Flat Panel Scaling for %s to %s %s.",
ctk_display_device_dfp->name,
scaling_method_string_table[scaling_method -1],
scaling_target_string_table[scaling_target -1]);
} /* post_dfp_scaling_update() */
static void ecc_config_button_toggled(GtkWidget *widget,
gpointer user_data)
{
gboolean enabled;
CtkEcc *ctk_ecc = CTK_ECC(user_data);
CtrlTarget *ctrl_target = ctk_ecc->ctrl_target;
ReturnStatus ret;
enabled = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget));
/* show popup dialog when user first time click ECC config */
show_ecc_toggle_warning_dlg(ctk_ecc);
/* set the newly specified ECC value */
ret = NvCtrlSetAttribute(ctrl_target,
NV_CTRL_GPU_ECC_CONFIGURATION,
enabled);
if (ret != NvCtrlSuccess) {
ctk_config_statusbar_message(ctk_ecc->ctk_config,
"Failed to set ECC configuration!");
return;
}
ctk_ecc->ecc_configured = enabled;
gtk_widget_set_sensitive(ctk_ecc->reset_default_config_button, TRUE);
/* Update status bar message */
post_ecc_configuration_update(ctk_ecc);
} /* ecc_config_button_toggled() */
static void post_xv_sync_to_display_changed(CtkXVideo *ctk_xvideo,
gboolean enabled,
gchar *label)
{
ctk_config_statusbar_message(ctk_xvideo->ctk_config,
"XVideo application syncing to %s.",
label);
}
/****
*
* Updates widgets in relation to current overclocking state.
*
*/
static void overclocking_state_update_gui(CtkClocks *ctk_object)
{
ReturnStatus ret;
int value;
NVCTRLAttributeValidValuesRec range_detection;
gboolean probing_optimal = TRUE;
gboolean enabled;
/* We need to check the overclocking state status with
* the server every time someone tries to change the state
* because the set might have failed.
*/
ret = NvCtrlGetAttribute(ctk_object->handle,
NV_CTRL_GPU_OVERCLOCKING_STATE,
&value);
if ( ret != NvCtrlSuccess )
enabled = False;
else
enabled = (value==NV_CTRL_GPU_OVERCLOCKING_STATE_MANUAL)?True:False;
ctk_object->overclocking_enabled = enabled;
/* We need to also make sure the server is not busy probing
* for the optimal clocks.
*/
if ( enabled ) {
ret = NvCtrlGetValidAttributeValues(ctk_object->handle,
NV_CTRL_GPU_OPTIMAL_CLOCK_FREQS_DETECTION,
&range_detection);
if ( ret == NvCtrlSuccess ) {
ret = NvCtrlGetAttribute(ctk_object->handle,
NV_CTRL_GPU_OPTIMAL_CLOCK_FREQS_DETECTION_STATE,
&value);
if ( ret == NvCtrlSuccess ) {
probing_optimal =
(value == NV_CTRL_GPU_OPTIMAL_CLOCK_FREQS_DETECTION_STATE_BUSY);
}
ctk_object->probing_optimal = probing_optimal;
ctk_object->auto_detection_available = TRUE;
}
}
/* Sync the gui to be able to modify the clocks */
sync_gui_to_modify_clocks(ctk_object, ctk_object->clocks_being_modified);
/* Update the status bar */
ctk_config_statusbar_message(ctk_object->ctk_config,
"GPU overclocking %sabled.",
enabled?"en":"dis");
} /* overclocking_state_update_gui() */
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.");
}
static void post_composite_termination_toggled(CtkGvoSync *ctk_gvo_sync,
gboolean enabled)
{
/* update the statusbar */
ctk_config_statusbar_message(ctk_gvo_sync->ctk_config,
"Composite Termination %s.",
enabled ? "Enabled" : "Disabled");
} /* post_composite_termination_toggled() */
/*
* Updates the status bar for when a change occured.
*/
static void post_xv_sync_to_display_update(CtkXVideo *ctk_xvideo,
GtkWidget *active_button)
{
const gchar *label;
label = gtk_button_get_label(GTK_BUTTON(active_button));
ctk_config_statusbar_message(ctk_xvideo->ctk_config,
"XVideo application syncing to %s.",
label);
}
static void post_scale_value_changed(GtkAdjustment *adjustment,
CtkImageSliders *ctk_image_sliders,
gint value)
{
char *name = g_object_get_data(G_OBJECT(adjustment), "attribute name");
gtk_widget_set_sensitive(ctk_image_sliders->reset_button, TRUE);
ctk_config_statusbar_message(ctk_image_sliders->ctk_config,
"%s set to %d.", name, value);
} /* post_scale_value_changed() */
static void reset_button_clicked(GtkButton *button, gpointer user_data)
{
CtkDisplayDeviceDfp *ctk_display_device_dfp =
CTK_DISPLAY_DEVICE_DFP(user_data);
gint value;
ctk_image_sliders_reset
(CTK_IMAGE_SLIDERS(ctk_display_device_dfp->image_sliders));
/*
* if scaling is active, send the default scaling value to the
* server and update the radio button group
*/
if (ctk_display_device_dfp->active_attributes & __SCALING) {
value =
MAKE_SCALING_VALUE(ctk_display_device_dfp->default_scaling_target,
ctk_display_device_dfp->default_scaling_method);
NvCtrlSetDisplayAttribute(ctk_display_device_dfp->handle,
ctk_display_device_dfp->display_device_mask,
NV_CTRL_GPU_SCALING, value);
dfp_scaling_setup(ctk_display_device_dfp);
}
/* Reset the color configuration */
if (ctk_display_device_dfp->color_controls) {
ctk_color_controls_reset
(CTK_COLOR_CONTROLS(ctk_display_device_dfp->color_controls));
}
/* Reset the dithering configuration */
if (ctk_display_device_dfp->dithering_controls) {
ctk_dithering_controls_reset
(CTK_DITHERING_CONTROLS(ctk_display_device_dfp->dithering_controls));
}
/* Update the reset button */
gtk_widget_set_sensitive(ctk_display_device_dfp->reset_button, FALSE);
/* status bar message */
ctk_config_statusbar_message(ctk_display_device_dfp->ctk_config,
"Reset hardware defaults for %s.",
ctk_display_device_dfp->name);
} /* reset_button_clicked() */
static void post_adjustment_value_changed(GtkAdjustment *adjustment,
CtkDisplayDeviceTv
*ctk_display_device_tv,
gint value)
{
char *name = g_object_get_data(G_OBJECT(adjustment), "attribute name");
gtk_widget_set_sensitive(ctk_display_device_tv->reset_button, TRUE);
ctk_config_statusbar_message(ctk_display_device_tv->ctk_config,
"%s set to %d.", name, value);
} /* post_adjustment_value_changed() */
static void reset_default_config_button_clicked(GtkWidget *widget,
gpointer user_data)
{
gboolean status;
ReturnStatus ret;
CtkEcc *ctk_ecc = CTK_ECC(user_data);
CtrlTarget *ctrl_target = ctk_ecc->ctrl_target;
/* get default status and set it to ECC configuration */
ret = NvCtrlGetAttribute(ctrl_target,
NV_CTRL_GPU_ECC_DEFAULT_CONFIGURATION,
&status);
if (ret != NvCtrlSuccess) {
ctk_config_statusbar_message(ctk_ecc->ctk_config,
"Failed to get default configuration!");
return;
}
ret = NvCtrlSetAttribute(ctrl_target,
NV_CTRL_GPU_ECC_CONFIGURATION,
status);
if (ret != NvCtrlSuccess) {
ctk_config_statusbar_message(ctk_ecc->ctk_config,
"Failed to set default configuration!");
return;
}
ctk_ecc->ecc_configured = status;
/* update ECC configuration button status */
ecc_set_config_status(ctk_ecc);
/* show popup dialog*/
show_ecc_toggle_warning_dlg(ctk_ecc);
gtk_widget_set_sensitive(ctk_ecc->reset_default_config_button, FALSE);
ctk_config_statusbar_message(ctk_ecc->ctk_config,
"Set to default configuration.");
} /* reset_default_config_button_clicked() */
static void clear_aggregate_ecc_errors_button_clicked(GtkWidget *widget,
gpointer user_data)
{
CtkEcc *ctk_ecc = CTK_ECC(user_data);
CtrlTarget *ctrl_target = ctk_ecc->ctrl_target;
NvCtrlSetAttribute(ctrl_target,
NV_CTRL_GPU_ECC_RESET_ERROR_STATUS,
NV_CTRL_GPU_ECC_RESET_ERROR_STATUS_AGGREGATE);
ctk_config_statusbar_message(ctk_ecc->ctk_config,
"ECC aggregate errors cleared.");
} /* clear_aggregate_ecc_errors_button_clicked() */
static gint detect_input_done(gpointer data)
{
CtkGvoSync *ctk_gvo_sync = CTK_GVO_SYNC(data);
/* disable REACQUIRE */
NvCtrlSetAttribute(ctk_gvo_sync->handle,
NV_CTRL_GVO_INPUT_VIDEO_FORMAT_REACQUIRE,
NV_CTRL_GVO_INPUT_VIDEO_FORMAT_REACQUIRE_FALSE);
/* reprobe */
ctk_gvo_banner_probe((gpointer)(ctk_gvo_sync->gvo_parent->banner));
/* un-press the detect button */
g_signal_handlers_block_by_func
(G_OBJECT(ctk_gvo_sync->input_video_format_detect_button),
G_CALLBACK(detect_input_toggled),
(gpointer) ctk_gvo_sync);
gtk_toggle_button_set_active
(GTK_TOGGLE_BUTTON(ctk_gvo_sync->input_video_format_detect_button), FALSE);
g_signal_handlers_unblock_by_func
(G_OBJECT(ctk_gvo_sync->input_video_format_detect_button),
G_CALLBACK(detect_input_toggled),
(gpointer) ctk_gvo_sync);
/* update the status bar */
ctk_config_statusbar_message(ctk_gvo_sync->ctk_config,
"Done detecting incoming signal.");
/* restore sensitivity */
gtk_widget_set_sensitive(ctk_gvo_sync->frame, TRUE);
/* restore the cursor */
gdk_window_set_cursor((GTK_WIDGET(ctk_gvo_sync->parent_window))->window,
NULL);
/* ungrab the server */
gtk_grab_remove(ctk_gvo_sync->input_video_format_detect_button);
return FALSE;
} /* detect_input_done() */
/*****
*
* Signal handler - Called when overclocking becomes busy due to
* an NV-CONTROL client probing for the optimal clocks.
*
*/
static void auto_detection_state_received(GtkObject *object,
gpointer arg1, gpointer user_data)
{
CtkEventStruct *event_struct = (CtkEventStruct *) arg1;
CtkClocks *ctk_object = CTK_CLOCKS(user_data);
/* Update GUI with probing status */
ctk_object->probing_optimal =
(event_struct->value == NV_CTRL_GPU_OPTIMAL_CLOCK_FREQS_DETECTION_STATE_BUSY);
sync_gui_sensitivity(ctk_object);
/* Update the status bar */
if ( ctk_object->probing_optimal ) {
ctk_config_statusbar_message(ctk_object->ctk_config, "%s",
__detect_wait_msg);
} else {
ctk_config_statusbar_message(ctk_object->ctk_config, "%s",
__canceled_msg);
}
} /* auto_detection_state_received() */
static void reset_sliders(CtkDisplayDeviceTv *ctk_display_device_tv)
{
/* retrieve all existing settings */
reset_slider(ctk_display_device_tv, ctk_display_device_tv->overscan);
reset_slider(ctk_display_device_tv, ctk_display_device_tv->flicker_filter);
reset_slider(ctk_display_device_tv, ctk_display_device_tv->brightness);
reset_slider(ctk_display_device_tv, ctk_display_device_tv->hue);
reset_slider(ctk_display_device_tv, ctk_display_device_tv->contrast);
reset_slider(ctk_display_device_tv, ctk_display_device_tv->saturation);
ctk_config_statusbar_message(ctk_display_device_tv->ctk_config,
"Reset TV Hardware defaults for %s.",
ctk_display_device_tv->name);
} /* reset_sliders() */
static void show_quit_dialog_toggled(GtkWidget *widget, gpointer user_data)
{
CtkConfig *ctk_config = CTK_CONFIG(user_data);
gboolean active = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget));
if (active) {
ctk_config->conf->booleans |= CONFIG_PROPERTIES_SHOW_QUIT_DIALOG;
} else {
ctk_config->conf->booleans &= ~CONFIG_PROPERTIES_SHOW_QUIT_DIALOG;
}
ctk_config_statusbar_message(ctk_config,
"Quit confirmation dialog %s.",
active ? "enabled" : "disabled");
}
static void tooltips_toggled(GtkWidget *widget, gpointer user_data)
{
CtkConfig *ctk_config = CTK_CONFIG(user_data);
gboolean active = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget));
if (active) {
gtk_tooltips_enable(ctk_config->tooltips.object);
ctk_config->conf->booleans |= CONFIG_PROPERTIES_TOOLTIPS;
} else {
gtk_tooltips_disable(ctk_config->tooltips.object);
ctk_config->conf->booleans &= ~CONFIG_PROPERTIES_TOOLTIPS;
}
ctk_config_statusbar_message(ctk_config, "Tooltips %s.",
active ? "enabled" : "disabled");
}
static void slider_text_entries_toggled(GtkWidget *widget, gpointer user_data)
{
CtkConfig *ctk_config = CTK_CONFIG(user_data);
gboolean active = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget));
if (active) {
ctk_config->conf->booleans |= CONFIG_PROPERTIES_SLIDER_TEXT_ENTRIES;
} else {
ctk_config->conf->booleans &= ~CONFIG_PROPERTIES_SLIDER_TEXT_ENTRIES;
}
ctk_config_statusbar_message(ctk_config,
"Slider text entries %s.",
active ? "enabled" : "disabled");
g_signal_emit(ctk_config, signals[0], 0);
}
static void post_ecc_configuration_update(CtkEcc *ctk_ecc)
{
gboolean configured = ctk_ecc->ecc_configured;
gboolean enabled = ctk_ecc->ecc_enabled;
const char *conf_string = configured ? "enabled" : "disabled";
char message[128];
if (configured != enabled) {
snprintf(message, sizeof(message), "ECC will be %s after reboot.",
conf_string);
} else {
snprintf(message, sizeof(message), "ECC %s.", conf_string);
}
ctk_config_statusbar_message(ctk_ecc->ctk_config, "%s", message);
} /* post_ecc_configuration_update() */
static void display_name_toggled(GtkWidget *widget, gpointer user_data)
{
CtkConfig *ctk_config = CTK_CONFIG(user_data);
gboolean active = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget));
if (active) {
ctk_config->conf->booleans |=
CONFIG_PROPERTIES_INCLUDE_DISPLAY_NAME_IN_CONFIG_FILE;
} else {
ctk_config->conf->booleans &=
~CONFIG_PROPERTIES_INCLUDE_DISPLAY_NAME_IN_CONFIG_FILE;
}
ctk_config_statusbar_message(ctk_config,
"Including X Display Names in Config File %s.",
active ? "enabled" : "disabled");
}
static void timer_enable_toggled(GtkCellRendererToggle *cell,
gchar *path_string,
gpointer user_data)
{
CtkConfig *ctk_config = CTK_CONFIG(user_data);
GtkTreeModel *model = GTK_TREE_MODEL(ctk_config->list_store);
GtkTreePath *path;
GtkTreeIter iter;
guint handle;
GSourceFunc function;
gpointer data;
TimerConfigProperty *timer_config;
gboolean owner_enabled;
path = gtk_tree_path_new_from_string(path_string);
gtk_tree_model_get_iter(model, &iter, path);
gtk_tree_path_free(path);
gtk_tree_model_get(model, &iter,
TIMER_CONFIG_COLUMN, &timer_config,
OWNER_ENABLE_COLUMN, &owner_enabled,
HANDLE_COLUMN, &handle,
FUNCTION_COLUMN, &function,
DATA_COLUMN, &data,
-1);
timer_config->user_enabled ^= 1;
/* Start/stop the timer only when the owner widget has enabled it */
if (owner_enabled) {
if (timer_config->user_enabled) {
handle = g_timeout_add(timer_config->interval, function, data);
gtk_list_store_set(ctk_config->list_store, &iter,
HANDLE_COLUMN, handle, -1);
} else {
g_source_remove(handle);
}
}
ctk_config_statusbar_message(ctk_config, "Timer \"%s\" %s.",
timer_config->description,
timer_config->user_enabled ?
"enabled" : "disabled");
}
/*****
*
* Callback Function - This function gets called when the GPU Overclocking
* page gets selected from the tree view.
*
*/
void ctk_clocks_select(GtkWidget *widget)
{
CtkClocks *ctk_object = CTK_CLOCKS(widget);
ReturnStatus ret;
int value;
/* See if we're busy probing for optimal clocks so we can tell the user */
ret = NvCtrlGetAttribute(ctk_object->handle,
NV_CTRL_GPU_OPTIMAL_CLOCK_FREQS_DETECTION_STATE,
&value);
if ( ret == NvCtrlSuccess &&
value == NV_CTRL_GPU_OPTIMAL_CLOCK_FREQS_DETECTION_STATE_BUSY ) {
ctk_config_statusbar_message(ctk_object->ctk_config, "%s",
__detect_wait_msg);
}
}
static void update_rules_on_profile_name_change_toggled(GtkWidget *widget,
gpointer user_data)
{
CtkConfig *ctk_config = CTK_CONFIG(user_data);
gboolean active = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget));
if (active) {
ctk_config->conf->booleans |=
CONFIG_PROPERTIES_UPDATE_RULES_ON_PROFILE_NAME_CHANGE;
} else {
ctk_config->conf->booleans &=
~CONFIG_PROPERTIES_UPDATE_RULES_ON_PROFILE_NAME_CHANGE;
}
ctk_config_statusbar_message(ctk_config,
"Updating rules when an application profile "
"name changes is %s.",
active ? "enabled" : "disabled");
}
static void post_sync_mode_menu_changed(CtkGvoSync *ctk_gvo_sync, gint value)
{
char *name;
/* Update the UI */
update_input_video_format_text_entry(ctk_gvo_sync);
update_gvo_sync_sensitivity(ctk_gvo_sync);
switch (value) {
case NV_CTRL_GVO_SYNC_MODE_FREE_RUNNING: name = "Free Running"; break;
case NV_CTRL_GVO_SYNC_MODE_GENLOCK: name = "GenLock"; break;
case NV_CTRL_GVO_SYNC_MODE_FRAMELOCK: name = "FrameLock"; break;
default: return;
}
ctk_config_statusbar_message(ctk_gvo_sync->ctk_config,
"Sync Mode set to %s.", name);
} /* post_sync_mode_menu_changed() */
static
void post_dithering_depth_update(CtkDitheringControls *ctk_dithering_controls,
gint dithering_depth)
{
static const char *dither_depth_table[] = {
"Auto", /* NV_CTRL_DITHERING_DEPTH_AUTO */
"6 bpc", /* NV_CTRL_DITHERING_DEPTH_6_BITS */
"8 bpc" /* NV_CTRL_DITHERING_DEPTH_8_BITS */
};
if (dithering_depth < NV_CTRL_DITHERING_DEPTH_AUTO ||
dithering_depth > NV_CTRL_DITHERING_DEPTH_8_BITS) {
return;
}
gtk_widget_set_sensitive(ctk_dithering_controls->reset_button, TRUE);
ctk_config_statusbar_message(ctk_dithering_controls->ctk_config,
"Dithering depth set to %s for %s.",
dither_depth_table[dithering_depth],
ctk_dithering_controls->name);
}
static
void post_dithering_config_update(CtkDitheringControls *ctk_dithering_controls,
gint dithering_config)
{
static const char *dither_config_table[] = {
"Auto", /* NV_CTRL_DITHERING_AUTO */
"Enabled", /* NV_CTRL_DITHERING_ENABLED */
"Disabled" /* NV_CTRL_DITHERING_DISABLED */
};
if (dithering_config < NV_CTRL_DITHERING_AUTO ||
dithering_config > NV_CTRL_DITHERING_DISABLED) {
return;
}
gtk_widget_set_sensitive(ctk_dithering_controls->reset_button, TRUE);
ctk_config_statusbar_message(ctk_dithering_controls->ctk_config,
"Dithering set to %s for %s.",
dither_config_table[dithering_config],
ctk_dithering_controls->name);
}
static void reset_button_clicked(GtkButton *button, gpointer user_data)
{
CtkDisplayDevice *ctk_object = CTK_DISPLAY_DEVICE(user_data);
/* Disable the reset button here and allow the controls below to (re)enable
* it if need be,.
*/
gtk_widget_set_sensitive(ctk_object->reset_button, FALSE);
ctk_color_controls_reset(CTK_COLOR_CONTROLS(ctk_object->color_controls));
ctk_dithering_controls_reset
(CTK_DITHERING_CONTROLS(ctk_object->dithering_controls));
ctk_image_sliders_reset(CTK_IMAGE_SLIDERS(ctk_object->image_sliders));
ctk_config_statusbar_message(ctk_object->ctk_config,
"Reset hardware defaults for %s.",
ctk_object->name);
} /* reset_button_clicked() */
static void detect_input_toggled(GtkToggleButton *togglebutton,
CtkGvoSync *ctk_gvo_sync)
{
gboolean enabled;
enabled = gtk_toggle_button_get_active(togglebutton);
if (!enabled) return;
/* grab the server */
gtk_grab_add(ctk_gvo_sync->input_video_format_detect_button);
/* change the cursor */
gdk_window_set_cursor
((GTK_WIDGET(ctk_gvo_sync->parent_window))->window,
ctk_gvo_sync->wait_cursor);
/* make all other widgets insensitive */
gtk_widget_set_sensitive(ctk_gvo_sync->frame, FALSE);
/* enable REACQUIRE */
NvCtrlSetAttribute(ctk_gvo_sync->handle,
NV_CTRL_GVO_INPUT_VIDEO_FORMAT_REACQUIRE,
NV_CTRL_GVO_INPUT_VIDEO_FORMAT_REACQUIRE_TRUE);
/* update the statusbar */
ctk_config_statusbar_message(ctk_gvo_sync->ctk_config,
"Detecting incoming signal...");
/* register the "done" function */
g_timeout_add(DEFAULT_DETECT_INPUT_TIME_INTERVAL,
detect_input_done, (gpointer) ctk_gvo_sync);
} /* detect_input_toggled() */