/*
* Updates the display device page to reflect the current
* configuration of the display device.
*/
static void display_device_setup(CtkDisplayDevice *ctk_object)
{
CtrlTarget *ctrl_target = ctk_object->ctrl_target;
/* 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);
update_display_enabled_flag(ctrl_target, &ctk_object->display_enabled);
/* Update info */
update_device_info(ctk_object);
ctk_edid_setup(CTK_EDID(ctk_object->edid));
/* Update controls */
ctk_color_controls_setup(CTK_COLOR_CONTROLS(ctk_object->color_controls));
ctk_dithering_controls_setup
(CTK_DITHERING_CONTROLS(ctk_object->dithering_controls));
ctk_image_sliders_setup(CTK_IMAGE_SLIDERS(ctk_object->image_sliders));
} /* display_device_setup() */
static void dithering_depth_menu_changed(GtkOptionMenu *dithering_depth_menu,
gpointer user_data)
{
CtkDitheringControls *ctk_dithering_controls =
CTK_DITHERING_CONTROLS(user_data);
gint history, dithering_depth = NV_CTRL_DITHERING_DEPTH_AUTO;
history = gtk_option_menu_get_history(dithering_depth_menu);
dithering_depth = map_dithering_depth_menu_idx_to_nvctrl(history);
NvCtrlSetAttribute(ctk_dithering_controls->handle,
NV_CTRL_DITHERING_DEPTH,
dithering_depth);
g_signal_handlers_block_by_func
(G_OBJECT(ctk_dithering_controls->dithering_depth_menu),
G_CALLBACK(dithering_depth_menu_changed),
(gpointer) ctk_dithering_controls);
gtk_option_menu_set_history
(GTK_OPTION_MENU(ctk_dithering_controls->dithering_depth_menu),
dithering_depth);
g_signal_handlers_unblock_by_func
(G_OBJECT(ctk_dithering_controls->dithering_depth_menu),
G_CALLBACK(dithering_depth_menu_changed),
(gpointer) ctk_dithering_controls);
/* reflecting the change in configuration to other widgets & reset button */
ctk_dithering_controls_setup(ctk_dithering_controls);
post_dithering_depth_update(ctk_dithering_controls, dithering_depth);
} /* dithering_depth_menu_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() */
GtkTextBuffer *ctk_display_device_create_help(GtkTextTagTable *table,
CtkDisplayDevice *ctk_object)
{
GtkTextIter i;
GtkTextBuffer *b;
gchar *tip_text;
int j;
b = gtk_text_buffer_new(table);
gtk_text_buffer_get_iter_at_offset(b, &i, 0);
ctk_help_title(b, &i, "%s Help", ctk_object->name);
ctk_help_heading(b, &i, "Device Information");
ctk_help_para(b, &i, "%s", __info_help);
for (j = 0; j < ARRAY_LEN(__info_entry_data); j++) {
InfoEntryData *entryData = __info_entry_data+j;
InfoEntry *entry = ctk_object->info_entries+j;
if (entry->present) {
ctk_help_term(b, &i, "%s", entryData->str);
ctk_help_para(b, &i, "%s", *entryData->tooltip);
}
}
add_acquire_edid_help(b, &i);
add_color_controls_help
(CTK_COLOR_CONTROLS(ctk_object->color_controls), b, &i);
add_dithering_controls_help
(CTK_DITHERING_CONTROLS(ctk_object->dithering_controls), b, &i);
add_image_sliders_help
(CTK_IMAGE_SLIDERS(ctk_object->image_sliders), b, &i);
if (ctk_object->color_correction_available) {
ctk_color_correction_tab_help(b, &i, "X Server Color Correction", TRUE);
}
tip_text = ctk_widget_get_tooltip_text(GTK_WIDGET(ctk_object->reset_button));
ctk_help_reset_hardware_defaults(b, &i, tip_text);
g_free(tip_text);
ctk_help_finish(b);
return b;
} /* ctk_display_device_create_help() */
/*
* When dithering configuration is enabled/disabled,
* we should update the GUI to reflect the current state & mode.
*/
static void dithering_update_received(GtkObject *object, gpointer arg1,
gpointer user_data)
{
CtkDitheringControls *ctk_object = CTK_DITHERING_CONTROLS(user_data);
CtkEventStruct *event_struct = (CtkEventStruct *) arg1;
ctk_dithering_controls_setup(ctk_object);
/* update status bar message */
switch (event_struct->attribute) {
case NV_CTRL_DITHERING:
post_dithering_config_update(ctk_object, event_struct->value); break;
case NV_CTRL_DITHERING_MODE:
post_dithering_mode_update(ctk_object, event_struct->value); break;
case NV_CTRL_DITHERING_DEPTH:
post_dithering_depth_update(ctk_object, event_struct->value); break;
}
} /* dithering_update_received() */
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 dithering_mode_menu_changed(GtkOptionMenu *dithering_mode_menu,
gpointer user_data)
{
CtkDitheringControls *ctk_dithering_controls =
CTK_DITHERING_CONTROLS(user_data);
gint history, dithering_mode = NV_CTRL_DITHERING_MODE_AUTO;
history = gtk_option_menu_get_history(dithering_mode_menu);
dithering_mode = ctk_dithering_controls->dithering_mode_table[history];
NvCtrlSetAttribute(ctk_dithering_controls->handle,
NV_CTRL_DITHERING_MODE,
dithering_mode);
dithering_mode = map_nvctrl_value_to_table(ctk_dithering_controls,
dithering_mode);
g_signal_handlers_block_by_func
(G_OBJECT(ctk_dithering_controls->dithering_mode_menu),
G_CALLBACK(dithering_mode_menu_changed),
(gpointer) ctk_dithering_controls);
gtk_option_menu_set_history
(GTK_OPTION_MENU(ctk_dithering_controls->dithering_mode_menu),
dithering_mode);
g_signal_handlers_unblock_by_func
(G_OBJECT(ctk_dithering_controls->dithering_mode_menu),
G_CALLBACK(dithering_mode_menu_changed),
(gpointer) ctk_dithering_controls);
/* reflecting the change in mode to other widgets & reset button */
ctk_dithering_controls_setup(ctk_dithering_controls);
post_dithering_mode_update(ctk_dithering_controls, dithering_mode);
} /* dithering_mode_menu_changed() */
static Bool update_dithering_info(gpointer user_data)
{
CtkDitheringControls *ctk_dithering_controls =
CTK_DITHERING_CONTROLS(user_data);
ReturnStatus ret;
gint val;
ret = NvCtrlGetAttribute(ctk_dithering_controls->handle,
NV_CTRL_DITHERING, &val);
if (ret != NvCtrlSuccess) {
/* Dithering is not currently available */
return FALSE;
}
if (val == NV_CTRL_DITHERING_ENABLED ||
val == NV_CTRL_DITHERING_AUTO) {
gtk_widget_set_sensitive(ctk_dithering_controls->dithering_mode_box,
TRUE);
gtk_widget_set_sensitive(ctk_dithering_controls->dithering_depth_box,
TRUE);
} else if (val == NV_CTRL_DITHERING_DISABLED) {
gtk_widget_set_sensitive(ctk_dithering_controls->dithering_mode_box,
FALSE);
gtk_widget_set_sensitive(ctk_dithering_controls->dithering_depth_box,
FALSE);
}
/* current dithering */
ret = NvCtrlGetAttribute(ctk_dithering_controls->handle,
NV_CTRL_CURRENT_DITHERING, &val);
if (ret != NvCtrlSuccess) {
val = NV_CTRL_CURRENT_DITHERING_DISABLED;
}
if (val == NV_CTRL_CURRENT_DITHERING_ENABLED) {
gtk_label_set_text(GTK_LABEL(ctk_dithering_controls->dithering_config_txt),
"Enabled");
} else {
gtk_label_set_text(GTK_LABEL(ctk_dithering_controls->dithering_config_txt),
"Disabled");
}
/* dithering mode */
ret = NvCtrlGetAttribute(ctk_dithering_controls->handle,
NV_CTRL_DITHERING_MODE, &val);
if (ret != NvCtrlSuccess) {
val = NV_CTRL_DITHERING_MODE_AUTO;
}
val = map_nvctrl_value_to_table(ctk_dithering_controls, val);
g_signal_handlers_block_by_func
(G_OBJECT(ctk_dithering_controls->dithering_mode_menu),
G_CALLBACK(dithering_mode_menu_changed),
(gpointer) ctk_dithering_controls);
gtk_option_menu_set_history
(GTK_OPTION_MENU(ctk_dithering_controls->dithering_mode_menu), val);
g_signal_handlers_unblock_by_func
(G_OBJECT(ctk_dithering_controls->dithering_mode_menu),
G_CALLBACK(dithering_mode_menu_changed),
(gpointer) ctk_dithering_controls);
/* current dithering mode */
ret = NvCtrlGetAttribute(ctk_dithering_controls->handle,
NV_CTRL_CURRENT_DITHERING_MODE, &val);
if (ret != NvCtrlSuccess) {
val = NV_CTRL_CURRENT_DITHERING_MODE_NONE;
}
switch (val) {
case NV_CTRL_CURRENT_DITHERING_MODE_DYNAMIC_2X2:
gtk_label_set_text(GTK_LABEL(ctk_dithering_controls->dithering_mode_txt),
"Dynamic 2x2");
break;
case NV_CTRL_CURRENT_DITHERING_MODE_STATIC_2X2:
gtk_label_set_text(GTK_LABEL(ctk_dithering_controls->dithering_mode_txt),
"Static 2x2");
break;
case NV_CTRL_CURRENT_DITHERING_MODE_TEMPORAL:
gtk_label_set_text(GTK_LABEL(ctk_dithering_controls->dithering_mode_txt),
"Temporal");
break;
default:
case NV_CTRL_CURRENT_DITHERING_MODE_NONE:
gtk_label_set_text(GTK_LABEL(ctk_dithering_controls->dithering_mode_txt),
"None");
break;
}
/* dithering depth */
ret = NvCtrlGetAttribute(ctk_dithering_controls->handle,
NV_CTRL_DITHERING_DEPTH, &val);
if (ret != NvCtrlSuccess) {
val = NV_CTRL_DITHERING_DEPTH_AUTO;
}
g_signal_handlers_block_by_func
(G_OBJECT(ctk_dithering_controls->dithering_depth_menu),
G_CALLBACK(dithering_depth_menu_changed),
(gpointer) ctk_dithering_controls);
gtk_option_menu_set_history
(GTK_OPTION_MENU(ctk_dithering_controls->dithering_depth_menu), val);
g_signal_handlers_unblock_by_func
(G_OBJECT(ctk_dithering_controls->dithering_depth_menu),
G_CALLBACK(dithering_depth_menu_changed),
(gpointer) ctk_dithering_controls);
/* current dithering depth */
ret = NvCtrlGetAttribute(ctk_dithering_controls->handle,
NV_CTRL_CURRENT_DITHERING_DEPTH, &val);
if (ret != NvCtrlSuccess) {
val = NV_CTRL_CURRENT_DITHERING_DEPTH_NONE;
}
switch (val) {
case NV_CTRL_CURRENT_DITHERING_DEPTH_6_BITS:
gtk_label_set_text(GTK_LABEL(ctk_dithering_controls->dithering_depth_txt),
"6 bpc");
break;
case NV_CTRL_CURRENT_DITHERING_DEPTH_8_BITS:
gtk_label_set_text(GTK_LABEL(ctk_dithering_controls->dithering_depth_txt),
"8 bpc");
break;
default:
case NV_CTRL_CURRENT_DITHERING_DEPTH_NONE:
gtk_label_set_text(GTK_LABEL(ctk_dithering_controls->dithering_depth_txt),
"None");
break;
}
return TRUE;
} /* update_dithering_info() */
GtkWidget* ctk_dithering_controls_new(NvCtrlAttributeHandle *handle,
CtkConfig *ctk_config,
CtkEvent *ctk_event,
GtkWidget *reset_button,
char *name)
{
GObject *object;
CtkDitheringControls *ctk_dithering_controls;
GtkWidget *frame, *vbox, *hbox, *label;
GtkWidget *menu, *table, *menu_item = NULL, *separator;
/* create the object */
object = g_object_new(CTK_TYPE_DITHERING_CONTROLS, NULL);
if (!object) {
return NULL;
}
ctk_dithering_controls = CTK_DITHERING_CONTROLS(object);
ctk_dithering_controls->handle = handle;
ctk_dithering_controls->ctk_config = ctk_config;
ctk_dithering_controls->reset_button = reset_button;
ctk_dithering_controls->name = strdup(name);
/* create main dithering box & frame */
hbox = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(object), hbox, FALSE, FALSE, FRAME_PADDING);
ctk_dithering_controls->dithering_controls_box = hbox;
frame = gtk_frame_new("Dithering Controls");
gtk_box_pack_start(GTK_BOX(hbox), frame, FALSE, FALSE, 0);
table = gtk_table_new(5, 4, FALSE);
gtk_container_add(GTK_CONTAINER(frame), table);
gtk_table_set_row_spacings(GTK_TABLE(table), 5);
gtk_table_set_col_spacings(GTK_TABLE(table), 15);
gtk_container_set_border_width(GTK_CONTAINER(table), 5);
/* Build Dithering widgets & pack them in table */
/* dropdown list for dithering configuration */
menu = gtk_menu_new();
menu_item = gtk_menu_item_new_with_label("Auto");
gtk_menu_shell_append(GTK_MENU_SHELL(menu), menu_item);
gtk_widget_show(menu_item);
menu_item = gtk_menu_item_new_with_label("Enabled");
gtk_menu_shell_append(GTK_MENU_SHELL(menu), menu_item);
gtk_widget_show(menu_item);
menu_item = gtk_menu_item_new_with_label("Disabled");
gtk_menu_shell_append(GTK_MENU_SHELL(menu), menu_item);
gtk_widget_show(menu_item);
ctk_dithering_controls->dithering_config_menu = gtk_option_menu_new();
gtk_option_menu_set_menu
(GTK_OPTION_MENU(ctk_dithering_controls->dithering_config_menu),
menu);
ctk_config_set_tooltip(ctk_config,
ctk_dithering_controls->dithering_config_menu,
__dithering_config_help);
g_signal_connect(G_OBJECT(ctk_dithering_controls->dithering_config_menu),
"changed", G_CALLBACK(dithering_config_menu_changed),
(gpointer) ctk_dithering_controls);
/* Packing label & dropdown */
hbox = gtk_hbox_new(FALSE, 0);
gtk_table_attach(GTK_TABLE(table), hbox, 0, 1, 0, 1,
GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0);
label = gtk_label_new("Dithering: ");
gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f);
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
hbox = gtk_hbox_new(FALSE, 0);
gtk_table_attach(GTK_TABLE(table), hbox, 1, 2, 0, 1,
GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0);
gtk_box_pack_start(GTK_BOX(hbox),
ctk_dithering_controls->dithering_config_menu,
FALSE, FALSE, 0);
/* Build CurrentDithering widget */
hbox = gtk_hbox_new(FALSE, 0);
gtk_table_attach(GTK_TABLE(table), hbox, 2, 3, 0, 1,
GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0);
label = gtk_label_new("Current Dithering: ");
gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f);
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
hbox = gtk_hbox_new(FALSE, 0);
gtk_table_attach(GTK_TABLE(table), hbox, 3, 4, 0, 1,
GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0);
label = gtk_label_new(NULL);
ctk_dithering_controls->dithering_config_txt = label;
gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f);
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
/* H-bar 1 */
vbox = gtk_vbox_new(FALSE, 0);
separator = gtk_hseparator_new();
gtk_box_pack_start(GTK_BOX(vbox), separator, FALSE, FALSE, 0);
gtk_table_attach(GTK_TABLE(table), vbox, 0, 4, 1, 2,
GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0);
/* dropdown list for dithering modes - populated in setup */
ctk_dithering_controls->dithering_mode_menu = gtk_option_menu_new();
ctk_config_set_tooltip(ctk_config,
ctk_dithering_controls->dithering_mode_menu,
__dithering_mode_help);
g_signal_connect(G_OBJECT(ctk_dithering_controls->dithering_mode_menu),
"changed", G_CALLBACK(dithering_mode_menu_changed),
(gpointer) ctk_dithering_controls);
/* pack the label & drop down */
hbox = gtk_hbox_new(FALSE, 0);
gtk_table_attach(GTK_TABLE(table), hbox, 0, 1, 2, 3,
GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0);
label = gtk_label_new("Mode: ");
gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f);
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
hbox = gtk_hbox_new(FALSE, 0);
ctk_dithering_controls->dithering_mode_box = hbox;
gtk_table_attach(GTK_TABLE(table), hbox, 1, 2, 2, 3,
GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0);
gtk_box_pack_start(GTK_BOX(hbox),
ctk_dithering_controls->dithering_mode_menu,
FALSE, FALSE, 0);
/* Build CurrentMode widget */
hbox = gtk_hbox_new(FALSE, 0);
gtk_table_attach(GTK_TABLE(table), hbox, 2, 3, 2, 3,
GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0);
label = gtk_label_new("Current Mode: ");
gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f);
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
hbox = gtk_hbox_new(FALSE, 0);
gtk_table_attach(GTK_TABLE(table), hbox, 3, 4, 2, 3,
GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0);
label = gtk_label_new(NULL);
ctk_dithering_controls->dithering_mode_txt = label;
gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f);
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
/* H-bar 2 */
vbox = gtk_vbox_new(FALSE, 0);
separator = gtk_hseparator_new();
gtk_box_pack_start(GTK_BOX(vbox), separator, FALSE, FALSE, 0);
gtk_table_attach(GTK_TABLE(table), vbox, 0, 4, 3, 4,
GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0);
/* dithering depth */
menu = gtk_menu_new();
menu_item = gtk_menu_item_new_with_label("Auto");
gtk_menu_shell_append(GTK_MENU_SHELL(menu), menu_item);
gtk_widget_show(menu_item);
menu_item = gtk_menu_item_new_with_label("6 bpc");
gtk_menu_shell_append(GTK_MENU_SHELL(menu), menu_item);
gtk_widget_show(menu_item);
menu_item = gtk_menu_item_new_with_label("8 bpc");
gtk_menu_shell_append(GTK_MENU_SHELL(menu), menu_item);
gtk_widget_show(menu_item);
ctk_dithering_controls->dithering_depth_menu = gtk_option_menu_new();
gtk_option_menu_set_menu
(GTK_OPTION_MENU(ctk_dithering_controls->dithering_depth_menu),
menu);
ctk_config_set_tooltip(ctk_config,
ctk_dithering_controls->dithering_depth_menu,
__dithering_depth_help);
g_signal_connect(G_OBJECT(ctk_dithering_controls->dithering_depth_menu),
"changed", G_CALLBACK(dithering_depth_menu_changed),
(gpointer) ctk_dithering_controls);
/* Packing label & dropdown */
hbox = gtk_hbox_new(FALSE, 0);
gtk_table_attach(GTK_TABLE(table), hbox, 0, 1, 4, 5,
GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0);
label = gtk_label_new("Depth: ");
gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f);
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
hbox = gtk_hbox_new(FALSE, 0);
ctk_dithering_controls->dithering_depth_box = hbox;
gtk_table_attach(GTK_TABLE(table), hbox, 1, 2, 4, 5,
GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0);
gtk_box_pack_start(GTK_BOX(hbox),
ctk_dithering_controls->dithering_depth_menu,
FALSE, FALSE, 0);
/* Build CurrentDitheringDepth widget */
hbox = gtk_hbox_new(FALSE, 0);
gtk_table_attach(GTK_TABLE(table), hbox, 2, 3, 4, 5,
GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0);
label = gtk_label_new("Current Depth: ");
gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f);
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
hbox = gtk_hbox_new(FALSE, 0);
gtk_table_attach(GTK_TABLE(table), hbox, 3, 4, 4, 5,
GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0);
label = gtk_label_new(NULL);
ctk_dithering_controls->dithering_depth_txt = label;
gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f);
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
gtk_widget_show_all(GTK_WIDGET(object));
ctk_dithering_controls_setup(ctk_dithering_controls);
g_signal_connect(G_OBJECT(ctk_event),
CTK_EVENT_NAME(NV_CTRL_DITHERING),
G_CALLBACK(dithering_update_received),
(gpointer) ctk_dithering_controls);
g_signal_connect(G_OBJECT(ctk_event),
CTK_EVENT_NAME(NV_CTRL_DITHERING_MODE),
G_CALLBACK(dithering_update_received),
(gpointer) ctk_dithering_controls);
g_signal_connect(G_OBJECT(ctk_event),
CTK_EVENT_NAME(NV_CTRL_DITHERING_DEPTH),
G_CALLBACK(dithering_update_received),
(gpointer) ctk_dithering_controls);
g_signal_connect(G_OBJECT(ctk_event),
CTK_EVENT_NAME(NV_CTRL_CURRENT_DITHERING),
G_CALLBACK(dithering_update_received),
(gpointer) ctk_dithering_controls);
g_signal_connect(G_OBJECT(ctk_event),
CTK_EVENT_NAME(NV_CTRL_CURRENT_DITHERING_MODE),
G_CALLBACK(dithering_update_received),
(gpointer) ctk_dithering_controls);
g_signal_connect(G_OBJECT(ctk_event),
CTK_EVENT_NAME(NV_CTRL_CURRENT_DITHERING_DEPTH),
G_CALLBACK(dithering_update_received),
(gpointer) ctk_dithering_controls);
return GTK_WIDGET(object);
} /* ctk_dithering_controls_new() */
GtkTextBuffer *ctk_display_device_dfp_create_help(GtkTextTagTable *table,
CtkDisplayDeviceDfp
*ctk_display_device_dfp)
{
GtkTextIter i;
GtkTextBuffer *b;
b = gtk_text_buffer_new(table);
gtk_text_buffer_get_iter_at_offset(b, &i, 0);
ctk_help_title(b, &i, "%s Help", ctk_display_device_dfp->name);
ctk_help_heading(b, &i, "Flat Panel Information");
ctk_help_para(b, &i, __info_help);
ctk_help_term(b, &i, "Chip Location");
ctk_help_para(b, &i, "Report whether the flat panel is driven by "
"the on-chip controller (internal), or a "
"separate controller chip elsewhere on the "
"graphics board (external).");
ctk_help_term(b, &i, "Link");
ctk_help_para(b, &i, "Report whether the specified display device "
"is driven by a single link or dual link DVI "
"connection.");
ctk_help_term(b, &i, "Signal");
ctk_help_para(b, &i, "Report whether the flat panel is driven by "
"an LVDS, TMDS, or DisplayPort signal.");
ctk_help_term(b, &i, "Native Resolution");
ctk_help_para(b, &i, __native_res_help);
ctk_help_term(b, &i, "Best Fit Resolution");
ctk_help_para(b, &i, __best_fit_res_help);
ctk_help_term(b, &i, "Frontend Resolution");
ctk_help_para(b, &i, __frontend_res_help);
ctk_help_term(b, &i, "Backend Resolution");
ctk_help_para(b, &i, __backend_res_help);
ctk_help_term(b, &i, "Refresh Rate");
ctk_help_para(b, &i, __refresh_rate_help);
ctk_help_heading(b, &i, "Flat Panel Scaling");
ctk_help_para(b, &i, __scaling_help);
ctk_help_term(b, &i, "Force Full GPU Scaling");
ctk_help_para(b, &i, __force_gpu_scaling_help);
ctk_help_term(b, &i, "Scaling");
ctk_help_para(b, &i, "Reports whether the GPU and/or DFP are actively "
"scaling the current resolution.");
ctk_help_term(b, &i, "Stretched");
ctk_help_para(b, &i, "The image will be expanded to fit the entire "
"flat panel.");
ctk_help_term(b, &i, "Centered");
ctk_help_para(b, &i, "The image will only occupy the number of pixels "
"needed and be centered on the flat panel. Setting this "
"will disable image sharpening for the display device.");
ctk_help_term(b, &i, "Aspect Ratio Scaled");
ctk_help_para(b, &i, "The image will be scaled (retaining the original "
"aspect ratio) to expand and fit as much of the entire "
"flat panel as possible.");
if (ctk_display_device_dfp->color_controls) {
add_color_controls_help
(CTK_COLOR_CONTROLS(ctk_display_device_dfp->color_controls), b, &i);
}
if (ctk_display_device_dfp->dithering_controls) {
add_dithering_controls_help
(CTK_DITHERING_CONTROLS(ctk_display_device_dfp->dithering_controls), b, &i);
}
add_image_sliders_help
(CTK_IMAGE_SLIDERS(ctk_display_device_dfp->image_sliders), b, &i);
if (ctk_display_device_dfp->edid) {
add_acquire_edid_help(b, &i);
}
ctk_help_reset_hardware_defaults(b, &i, ctk_display_device_dfp->name);
ctk_help_finish(b);
return b;
} /* ctk_display_device_dfp_create_help() */
