GtkTextBuffer *ctk_config_create_help(CtkConfig *ctk_config, GtkTextTagTable *table)
{
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, "nvidia-settings Configuration Help");
ctk_help_data_list_print_sections(b, &i, ctk_config->help_data);
ctk_help_heading(b, &i, "Active Timers");
ctk_help_para(b, &i, "Some attributes are polled periodically "
"to ensure the reported values are up-to-date. "
"Each row in the 'Active Timers' table reflects "
"the configuration of one of these timers and "
"controls how frequently, if at all, a given "
"attribute is polled. The 'Description' field "
"describes the function of a timer, the 'Enabled' "
"field allows enabling/disabling it, the 'Time "
"Interval' field controls the delay between two "
"consecutive polls (in milliseconds). The Active "
"Timers table is only visible when timers are active.");
ctk_help_heading(b, &i, "Save Current Configuration");
ctk_help_para(b, &i, "%s", __save_current_config_help);
ctk_help_finish(b);
return b;
} /* create_help() */
/*****
*
* GPU overclocking help screen.
*
*/
GtkTextBuffer *ctk_clocks_create_help(GtkTextTagTable *table,
CtkClocks *ctk_object)
{
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, "Clock Frequency Overclocking Help");
ctk_help_para(b, &i,
"WARNING: Overclocking has the potential of destroying your "
"graphics card, CPU, RAM and any other component. It may "
"also reduce the life expectancy of your components and "
"void manufacturer warranties. DO THIS AT YOUR OWN RISK."
);
ctk_help_heading(b, &i, "Enabling Clock Frequencies");
ctk_help_para(b, &i, "%s", __enable_button_help);
ctk_help_para(b, &i,
"GPU Overclocking functionality is currently limited to "
"GeForce FX and newer non-mobile GPUs."
);
ctk_help_heading(b, &i, "2D/3D Clock Frequencies");
ctk_help_para(b, &i,
"The 2D clock frequencies are the standard clock "
"frequencies used when only 2D applications are running."
);
ctk_help_para(b, &i,
"The 3D clock frequencies are the performance clock "
"frequencies used when running 3D applications."
);
ctk_help_heading(b, &i, "Graphics Clock Frequency");
ctk_help_para(b, &i, "%s", __graphics_clock_help);
ctk_help_heading(b, &i, "Memory Clock Frequency");
ctk_help_para(b, &i, "%s", __mem_clock_help);
ctk_help_heading(b, &i, "Applying Custom Clock Frequencies");
ctk_help_para(b, &i, "%s", __apply_button_help);
ctk_help_heading(b, &i, "Auto Detect Optimal 3D Clock Frequencies");
ctk_help_para(b, &i, "%s", __detect_button_help);
ctk_help_heading(b, &i, "Canceling Optimal 3D Clock Frequency Auto-"
"detection.");
ctk_help_para(b, &i, "%s", __cancel_button_help);
ctk_help_para(b, &i,
"This button is only available if the Optimal "
"clocks are currently being probed.");
ctk_help_heading(b, &i, "Restoring Hardware Default Frequencies");
ctk_help_para(b, &i, "%s", __reset_button_help);
ctk_help_finish(b);
return b;
} /* ctk_clocks_create_help() */
GtkTextBuffer *ctk_ecc_create_help(GtkTextTagTable *table,
CtkEcc *ctk_ecc)
{
GtkTextIter i;
GtkTextBuffer *b;
b = gtk_text_buffer_new(table);
gtk_text_buffer_get_iter_at_offset(b, &i, 0);
ctk_help_heading(b, &i, "ECC Settings Help");
ctk_help_para(b, &i, "%s", __ecc_settings_help);
ctk_help_heading(b, &i, "ECC");
ctk_help_para(b, &i, "%s", __ecc_status_help);
if (ctk_ecc->sbit_error_available && ctk_ecc->dbit_error_available) {
ctk_help_heading(b, &i, "Single-bit ECC Errors");
ctk_help_para(b, &i, "%s", __sbit_error_help);
ctk_help_heading(b, &i, "Double-bit ECC Errors");
ctk_help_para(b, &i, "%s", __dbit_error_help);
}
if (ctk_ecc->aggregate_sbit_error_available &&
ctk_ecc->aggregate_dbit_error_available) {
ctk_help_heading(b, &i, "Aggregate Single-bit ECC Errors");
ctk_help_para(b, &i, "%s", __aggregate_sbit_error_help);
ctk_help_heading(b, &i, "Aggregate Double-bit ECC Errors");
ctk_help_para(b, &i, "%s", __aggregate_dbit_error_help);
}
ctk_help_heading(b, &i, "ECC Configuration");
ctk_help_para(b, &i, "%s", __configuration_status_help);
ctk_help_heading(b, &i, "Enable ECC");
ctk_help_para(b, &i, "%s", __ecc_status_help);
if (ctk_ecc->sbit_error_available && ctk_ecc->dbit_error_available) {
ctk_help_heading(b, &i, "Clear ECC Errors");
ctk_help_para(b, &i, "%s", __clear_button_help);
}
if (ctk_ecc->aggregate_sbit_error_available &&
ctk_ecc->aggregate_dbit_error_available) {
ctk_help_heading(b, &i, "Clear Aggregate ECC Errors");
ctk_help_para(b, &i, "%s", __clear_aggregate_button_help);
}
ctk_help_heading(b, &i, "Reset Default Configuration");
ctk_help_para(b, &i, "%s", __reset_default_config_button_help);
ctk_help_finish(b);
return b;
}
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() */
GtkTextBuffer *ctk_display_device_tv_create_help(GtkTextTagTable *table,
CtkDisplayDeviceTv
*ctk_display_device_tv)
{
GtkTextIter i;
GtkTextBuffer *b;
GtkTooltipsData *td;
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_tv->name);
ctk_help_heading(b, &i, "TV Overscan");
ctk_help_para(b, &i, __tv_overscan_help);
ctk_help_heading(b, &i, "TV Flicker Filter");
ctk_help_para(b, &i, __tv_flicker_filter_help);
ctk_help_heading(b, &i, "TV Brightness");
ctk_help_para(b, &i, __tv_brightness_help);
ctk_help_heading(b, &i, "TV Hue");
ctk_help_para(b, &i, __tv_hue_help);
ctk_help_heading(b, &i, "TV Contrast");
ctk_help_para(b, &i, __tv_contrast_help);
ctk_help_heading(b, &i, "TV Saturation");
ctk_help_para(b, &i, __tv_saturation_help);
ctk_help_heading(b, &i, "TV Encoder name");
ctk_help_para(b, &i, __tv_encoder_name_help);
ctk_help_heading(b, &i, "TV Refresh rate");
ctk_help_para(b, &i, __tv_refresh_rate_help);
add_image_sliders_help
(CTK_IMAGE_SLIDERS(ctk_display_device_tv->image_sliders), b, &i);
add_acquire_edid_help(b, &i);
td = gtk_tooltips_data_get(GTK_WIDGET(ctk_display_device_tv->reset_button));
ctk_help_reset_hardware_defaults (b, &i, td->tip_text);
ctk_help_finish(b);
return b;
} /* ctk_display_device_tv_create_help() */
GtkTextBuffer* ctk_gvo_sync_create_help(GtkTextTagTable *table,
CtkGvoSync *ctk_gvo_sync)
{
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, "GVO (Graphics to Video Out) Synchronization "
"options");
ctk_help_para(b, &i, "This page gives access to configuration of the "
"SDI synchronization options.");
ctk_help_heading(b, &i, "Input Video Format");
ctk_help_para(b, &i, "%s", __input_video_format_help);
ctk_help_heading(b, &i, "Input Video Format Detect");
ctk_help_para(b, &i, "%s", __input_video_format_detect_help);
ctk_help_heading(b, &i, "Composite Termination");
ctk_help_para(b, &i, "%s. This allows the composite signal to be daisy "
"chained from a server load.",
__composite_termination_help);
ctk_help_heading(b, &i, "Sync Mode");
ctk_help_para(b, &i, "%s", __sync_mode_help);
ctk_help_heading(b, &i, "Sync Format");
ctk_help_para(b, &i, "%s", __sync_format_help);
ctk_help_heading(b, &i, "Sync Status");
ctk_help_para(b, &i, "%s", __sync_status_help);
if ( ctk_gvo_sync->caps & NV_CTRL_GVO_CAPABILITIES_ADVANCE_SYNC_SKEW ) {
ctk_help_heading(b, &i, "HSync Advance");
ctk_help_para(b, &i, "%s", __hsync_advance_help);
ctk_help_heading(b, &i, "VSync Advance");
ctk_help_para(b, &i, "%s", __vsync_advance_help);
} else {
ctk_help_heading(b, &i, "HSync Delay");
ctk_help_para(b, &i, "%s", __hsync_delay_help);
ctk_help_heading(b, &i, "VSync Delay");
ctk_help_para(b, &i, "%s", __vsync_delay_help);
}
ctk_help_finish(b);
return b;
}
GtkTextBuffer *ctk_xvideo_create_help(GtkTextTagTable *table,
CtkXVideo *ctk_xvideo)
{
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, "X Server XVideo Settings Help");
ctk_help_para(b, &i, "The X Server XVideo Settings page uses the XVideo "
"X extension.");
if (ctk_xvideo->active_attributes & __XV_SYNC_TO_DISPLAY) {
ctk_help_heading(b, &i, "Sync to this display device");
ctk_help_para(b, &i, "%s", __xv_sync_to_display_help);
}
ctk_help_finish(b);
return b;
}
/*
* VCS help screen
*/
GtkTextBuffer *ctk_vcs_create_help(GtkTextTagTable *table,
CtkVcs *ctk_object)
{
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, "VCS (Visual Computing System) Help");
ctk_help_heading(b, &i, "Product Name");
ctk_help_para(b, &i, "This is the product name of the VCS.");
ctk_help_heading(b, &i, "Serial Number");
ctk_help_para(b, &i, "This is the unique serial number of the VCS.");
ctk_help_heading(b, &i, "Build Date");
ctk_help_para(b, &i, "This is the date the VCS was build, "
"shown in a 'week.year' format");
ctk_help_heading(b, &i, "Product ID");
ctk_help_para(b, &i, "This identifies the VCS configuration.");
ctk_help_heading(b, &i, "Firmware Version");
ctk_help_para(b, &i, "This is the firmware version currently running on "
"the VCS.");
ctk_help_heading(b, &i, "Hardware Version");
ctk_help_para(b, &i, "This is the hardware version of the VCS.");
ctk_help_finish(b);
return b;
}
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() */
GtkTextBuffer *ctk_xvideo_create_help(GtkTextTagTable *table,
CtkXVideo *ctk_xvideo)
{
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, "X Server XVideo Settings Help");
ctk_help_para(b, &i, "The X Server XVideo Settings page uses the XVideo "
"X extension.");
if (ctk_xvideo->active_attributes & __XV_OVERLAY_SATURATION) {
ctk_help_heading(b, &i, "Video Overlay Saturation");
ctk_help_para(b, &i, __xv_overlay_saturation_help);
}
if (ctk_xvideo->active_attributes & __XV_OVERLAY_CONTRAST) {
ctk_help_heading(b, &i, "Video Overlay Contrast");
ctk_help_para(b, &i, __xv_overlay_contrast_help);
}
if (ctk_xvideo->active_attributes & __XV_OVERLAY_BRIGHTNESS) {
ctk_help_heading(b, &i, "Video Overlay Brightness");
ctk_help_para(b, &i, __xv_overlay_brightness_help);
}
if (ctk_xvideo->active_attributes & __XV_OVERLAY_HUE) {
ctk_help_heading(b, &i, "Video Overlay Hue");
ctk_help_para(b, &i, __xv_overlay_hue_help);
}
if (ctk_xvideo->active_attributes & __XV_TEXTURE_SYNC_TO_VBLANK) {
ctk_help_heading(b, &i, "Video Texture Sync To VBlank");
ctk_help_para(b, &i, __xv_texture_sync_to_vblank_help);
}
if (ctk_xvideo->active_attributes & __XV_TEXTURE_BRIGHTNESS) {
ctk_help_heading(b, &i, "Video Texture Brightness");
ctk_help_para(b, &i, __xv_texture_brightness_help);
}
if (ctk_xvideo->active_attributes & __XV_TEXTURE_CONTRAST) {
ctk_help_heading(b, &i, "Video Texture Contrast");
ctk_help_para(b, &i, __xv_texture_contrast_help);
}
if (ctk_xvideo->active_attributes & __XV_TEXTURE_HUE) {
ctk_help_heading(b, &i, "Video Texture Hue");
ctk_help_para(b, &i, __xv_texture_hue_help);
}
if (ctk_xvideo->active_attributes & __XV_TEXTURE_SATURATION) {
ctk_help_heading(b, &i, "Video Texture Saturation");
ctk_help_para(b, &i, __xv_texture_saturation_help);
}
if (ctk_xvideo->active_attributes & __XV_BLITTER_SYNC_TO_VBLANK) {
ctk_help_heading(b, &i, "Video Blitter Sync To VBlank");
ctk_help_para(b, &i, __xv_blitter_sync_to_vblank_help);
}
if (ctk_xvideo->active_attributes & __XV_SYNC_TO_DISPLAY) {
ctk_help_heading(b, &i, "Sync to this display device");
ctk_help_para(b, &i, __xv_sync_to_display_help);
}
ctk_help_heading(b, &i, "Reset Hardware Defaults");
ctk_help_para(b, &i, __reset_button_help);
ctk_help_finish(b);
return b;
}
