static GtkWidget * add_scale(CtkConfig *ctk_config,
int attribute,
char *name,
const char *help,
gint value_type,
gint default_value,
gpointer callback_data)
{
GtkObject *adj;
GtkWidget *scale;
adj = gtk_adjustment_new(0, 0, 10, 1, 1, 0);
g_object_set_data(G_OBJECT(adj), "attribute",
GINT_TO_POINTER(attribute));
g_object_set_data(G_OBJECT(adj), "attribute name", name);
g_object_set_data(G_OBJECT(adj), "attribute default value",
GINT_TO_POINTER(default_value));
g_signal_connect(G_OBJECT(adj), "value_changed",
G_CALLBACK(scale_value_changed),
(gpointer) callback_data);
scale = ctk_scale_new(GTK_ADJUSTMENT(adj), name, ctk_config, value_type);
ctk_config_set_tooltip(ctk_config, CTK_SCALE_TOOLTIP_WIDGET(scale),
help);
return scale;
} /* add_scale() */
static GtkWidget * add_scale(CtkDisplayDeviceTv *ctk_display_device_tv,
int attribute, char *name, const char *help)
{
GtkObject *adj;
GtkWidget *scale;
adj = gtk_adjustment_new(0, 0, 10, 1, 1, 0);
g_object_set_data(G_OBJECT(adj), "attribute",
GINT_TO_POINTER(attribute));
g_object_set_data(G_OBJECT(adj), "attribute name", name);
g_object_set_data(G_OBJECT(adj), "attribute active",
GINT_TO_POINTER(0));
g_signal_connect(G_OBJECT(adj), "value_changed",
G_CALLBACK(adjustment_value_changed),
(gpointer) ctk_display_device_tv);
scale = ctk_scale_new(GTK_ADJUSTMENT(adj), name,
ctk_display_device_tv->ctk_config,
G_TYPE_INT);
if (help) {
ctk_config_set_tooltip(ctk_display_device_tv->ctk_config,
CTK_SCALE_TOOLTIP_WIDGET(scale), help);
}
gtk_box_pack_start(GTK_BOX(ctk_display_device_tv), scale,
FALSE, FALSE, 0);
return scale;
} /* add_scale() */
static GtkWidget *create_slider(CtkXVideo *ctk_xvideo,
GtkWidget *vbox,
GtkWidget *button,
const gchar *name,
const char *help,
gint attribute,
unsigned int bit)
{
GtkObject *adjustment;
GtkWidget *scale, *widget;
gint min, max, val, step_incr, page_incr;
NVCTRLAttributeValidValuesRec range;
ReturnStatus ret;
/* get the attribute value */
ret = NvCtrlGetAttribute(ctk_xvideo->handle, attribute, &val);
if (ret != NvCtrlSuccess) return NULL;
/* get the range for the attribute */
NvCtrlGetValidAttributeValues(ctk_xvideo->handle, attribute, &range);
if (range.type != ATTRIBUTE_TYPE_RANGE) return NULL;
min = range.u.range.min;
max = range.u.range.max;
step_incr = ((max) - (min))/250;
if (step_incr <= 0) step_incr = 1;
page_incr = ((max) - (min))/25;
if (page_incr <= 0) page_incr = 1;
/* create the slider */
adjustment = gtk_adjustment_new(val, min, max,
step_incr, page_incr, 0.0);
g_object_set_data(G_OBJECT(adjustment), "xvideo_attribute",
GINT_TO_POINTER(attribute));
g_signal_connect(G_OBJECT(adjustment), "value_changed",
G_CALLBACK(slider_changed),
(gpointer) ctk_xvideo);
g_signal_connect_swapped(G_OBJECT(adjustment), "value_changed",
G_CALLBACK(set_button_sensitive),
(gpointer) button);
scale = ctk_scale_new(GTK_ADJUSTMENT(adjustment), name,
ctk_xvideo->ctk_config, G_TYPE_INT);
gtk_box_pack_start(GTK_BOX(vbox), scale, TRUE, TRUE, 0);
ctk_xvideo->active_attributes |= bit;
widget = CTK_SCALE(scale)->gtk_scale;
ctk_config_set_tooltip(ctk_xvideo->ctk_config, widget, help);
return scale;
} /* create_slider() */
/*****
*
* Main CTK widget creation.
*
*/
GtkWidget* ctk_clocks_new(NvCtrlAttributeHandle *handle,
CtkConfig *ctk_config,
CtkEvent *ctk_event)
{
GObject *object;
CtkClocks *ctk_object;
GtkObject *adjustment;
GtkWidget *alignment;
GtkWidget *scale;
CtkDropDownMenu *menu;
GtkWidget *label;
GtkWidget *frame;
GtkWidget *banner;
GtkWidget *hbox;
GtkWidget *vbox;
ReturnStatus ret; /* NvCtrlxxx function return value */
int value, i = 0;
int clocks_2D;
NVCTRLAttributeValidValuesRec ranges_2D;
NVCTRLAttributeValidValuesRec range_detection;
int clocks_3D;
NVCTRLAttributeValidValuesRec ranges_3D;
Bool overclocking_enabled;
Bool auto_detection_available = FALSE;
Bool probing_optimal = FALSE;
Bool can_access_2d_clocks;
Bool can_access_3d_clocks;
/* Make sure we have a handle */
g_return_val_if_fail(handle != NULL, NULL);
/* If we can't query the overclocking state, don't load the page */
ret = NvCtrlGetAttribute(handle, NV_CTRL_GPU_OVERCLOCKING_STATE,
&value);
if ( ret != NvCtrlSuccess )
return NULL;
overclocking_enabled =
(value==NV_CTRL_GPU_OVERCLOCKING_STATE_MANUAL)?True:False;
/* Check if overclocking is busy */
if ( overclocking_enabled ) {
ret = NvCtrlGetValidAttributeValues(handle,
NV_CTRL_GPU_OPTIMAL_CLOCK_FREQS_DETECTION,
&range_detection);
if ( ret == NvCtrlSuccess ) {
ret = NvCtrlGetAttribute(handle,
NV_CTRL_GPU_OPTIMAL_CLOCK_FREQS_DETECTION_STATE,
&value);
if ( ret != NvCtrlSuccess )
return NULL;
probing_optimal =
(value == NV_CTRL_GPU_OPTIMAL_CLOCK_FREQS_DETECTION_STATE_BUSY);
auto_detection_available = TRUE;
}
}
/* Can we access the 2D clocks? */
can_access_2d_clocks = True;
ret = NvCtrlGetAttribute(handle, NV_CTRL_GPU_2D_CLOCK_FREQS, &clocks_2D);
if ( ret != NvCtrlSuccess )
can_access_2d_clocks = False;
ret = NvCtrlGetValidAttributeValues(handle, NV_CTRL_GPU_2D_CLOCK_FREQS,
&ranges_2D);
if ( ret != NvCtrlSuccess )
can_access_2d_clocks = False;
/* Can we access the 3D clocks? */
can_access_3d_clocks = True;
ret = NvCtrlGetAttribute(handle, NV_CTRL_GPU_3D_CLOCK_FREQS, &clocks_3D);
if ( ret != NvCtrlSuccess )
can_access_3d_clocks = False;
ret = NvCtrlGetValidAttributeValues(handle, NV_CTRL_GPU_3D_CLOCK_FREQS,
&ranges_3D);
if ( ret != NvCtrlSuccess )
can_access_3d_clocks = False;
/* If we can't access either of the clocks, don't load the page */
if ( !can_access_2d_clocks && !can_access_3d_clocks )
return NULL;
/* Create the ctk object */
object = g_object_new(CTK_TYPE_CLOCKS, NULL);
ctk_object = CTK_CLOCKS(object);
/* Cache the handle and configuration */
ctk_object->handle = handle;
ctk_object->ctk_config = ctk_config;
ctk_object->overclocking_enabled = overclocking_enabled;
ctk_object->auto_detection_available = auto_detection_available;
ctk_object->probing_optimal = probing_optimal;
/* Create the Clock menu widget */
menu = (CtkDropDownMenu *)
ctk_drop_down_menu_new(CTK_DROP_DOWN_MENU_FLAG_READONLY);
i = 0;
if ( can_access_2d_clocks ) {
ctk_drop_down_menu_append_item(menu, "2D Clock Frequencies", i++);
}
if ( can_access_3d_clocks ) {
ctk_drop_down_menu_append_item(menu, "3D Clock Frequencies", i++);
}
ctk_object->clock_menu = GTK_WIDGET(menu);
g_signal_connect(G_OBJECT(ctk_object->clock_menu), "changed",
G_CALLBACK(clock_menu_changed),
(gpointer) ctk_object);
ctk_config_set_tooltip(ctk_config, ctk_object->clock_menu,
__clock_menu_help);
gtk_widget_set_sensitive(ctk_object->clock_menu,
overclocking_enabled && !probing_optimal);
/* Create the Graphics clock frequency slider widget */
if ( can_access_2d_clocks ) {
adjustment =
gtk_adjustment_new(GET_GPU_CLOCK(clocks_2D),
GET_GPU_CLOCK(ranges_2D.u.range.min),
GET_GPU_CLOCK(ranges_2D.u.range.max),
1, 5, 0.0);
ctk_object->clocks_being_modified = CLOCKS_2D;
} else {
adjustment =
gtk_adjustment_new(GET_GPU_CLOCK(clocks_3D),
GET_GPU_CLOCK(ranges_3D.u.range.min),
GET_GPU_CLOCK(ranges_3D.u.range.max),
1, 5, 0.0);
ctk_object->clocks_being_modified = CLOCKS_3D;
}
scale = ctk_scale_new(GTK_ADJUSTMENT(adjustment), "GPU (MHz)",
ctk_config, G_TYPE_INT);
ctk_object->gpu_clk_scale = scale;
g_signal_connect(adjustment, "value_changed",
G_CALLBACK(adjustment_value_changed),
(gpointer) ctk_object);
ctk_config_set_tooltip(ctk_config,
CTK_SCALE(ctk_object->gpu_clk_scale)->gtk_scale,
__graphics_clock_help);
gtk_widget_set_sensitive(ctk_object->gpu_clk_scale,
overclocking_enabled && !probing_optimal);
/* Create the Memory clock frequency slider widget */
if ( can_access_2d_clocks ) {
adjustment =
gtk_adjustment_new(GET_MEM_CLOCK(clocks_2D),
GET_MEM_CLOCK(ranges_2D.u.range.min),
GET_MEM_CLOCK(ranges_2D.u.range.max),
1, 5, 0.0);
} else {
adjustment =
gtk_adjustment_new(GET_MEM_CLOCK(clocks_3D),
GET_MEM_CLOCK(ranges_3D.u.range.min),
GET_MEM_CLOCK(ranges_3D.u.range.max),
1, 5, 0.0);
}
scale = ctk_scale_new(GTK_ADJUSTMENT(adjustment), "Memory (MHz)",
ctk_config, G_TYPE_INT);
ctk_object->mem_clk_scale = scale;
g_signal_connect(adjustment, "value_changed",
G_CALLBACK(adjustment_value_changed),
(gpointer) ctk_object);
ctk_config_set_tooltip(ctk_config,
CTK_SCALE(ctk_object->mem_clk_scale)->gtk_scale,
__mem_clock_help);
gtk_widget_set_sensitive(ctk_object->mem_clk_scale,
overclocking_enabled && !probing_optimal);
/* Create the Enable Overclocking checkbox widget */
ctk_object->enable_checkbox =
gtk_check_button_new_with_label("Enable Overclocking");
gtk_toggle_button_set_active
(GTK_TOGGLE_BUTTON(ctk_object->enable_checkbox),
overclocking_enabled);
gtk_widget_set_sensitive(ctk_object->enable_checkbox,
overclocking_enabled && !probing_optimal);
g_signal_connect(G_OBJECT(ctk_object->enable_checkbox), "toggled",
G_CALLBACK(overclocking_state_toggled),
(gpointer) ctk_object);
ctk_config_set_tooltip(ctk_config, ctk_object->enable_checkbox,
__enable_button_help);
gtk_widget_set_sensitive(ctk_object->enable_checkbox, !probing_optimal);
/* Create the Apply button widget */
ctk_object->apply_button =
gtk_button_new_with_label("Apply");
g_signal_connect(G_OBJECT(ctk_object->apply_button), "clicked",
G_CALLBACK(apply_clocks_clicked),
(gpointer) ctk_object);
ctk_config_set_tooltip(ctk_config, ctk_object->apply_button,
__apply_button_help);
gtk_widget_set_sensitive(ctk_object->apply_button, False);
/* Create the Auto Detect button widget */
ctk_object->detect_button =
gtk_button_new_with_label("Auto Detect");
g_signal_connect(G_OBJECT(ctk_object->detect_button), "clicked",
G_CALLBACK(detect_clocks_clicked),
(gpointer) ctk_object);
ctk_config_set_tooltip(ctk_config, ctk_object->detect_button,
__detect_button_help);
if ( ctk_object->clocks_being_modified == CLOCKS_2D ) {
gtk_widget_set_sensitive(ctk_object->detect_button, False);
} else {
gtk_widget_set_sensitive(ctk_object->detect_button,
overclocking_enabled &&
auto_detection_available && !probing_optimal);
}
/* Create the Reset hardware button widget */
ctk_object->reset_button =
gtk_button_new_with_label("Reset Hardware Defaults");
g_signal_connect(G_OBJECT(ctk_object->reset_button), "clicked",
G_CALLBACK(reset_clocks_clicked),
(gpointer) ctk_object);
ctk_config_set_tooltip(ctk_config, ctk_object->reset_button,
__reset_button_help);
gtk_widget_set_sensitive(ctk_object->reset_button, False);
/* Create the auto detect dialog */
ctk_object->detect_dialog =
gtk_dialog_new_with_buttons("Auto Detect Optimal 3D Clock Frequencies?",
GTK_WINDOW(gtk_widget_get_parent(GTK_WIDGET(ctk_object))),
GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT | GTK_DIALOG_NO_SEPARATOR,
GTK_STOCK_OK,
GTK_RESPONSE_ACCEPT,
GTK_STOCK_CANCEL,
GTK_RESPONSE_REJECT,
NULL
);
label = gtk_label_new(__detect_confirm_msg);
hbox = gtk_hbox_new(TRUE, 15);
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 15);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(ctk_object->detect_dialog)->vbox),
hbox, FALSE, FALSE, 15);
/*
* Now that we've created all the widgets we care about, we're
* ready to compose the panel
*/
/* Set container properties of the ctk object */
gtk_box_set_spacing(GTK_BOX(ctk_object), 10);
banner = ctk_banner_image_new(BANNER_ARTWORK_CLOCK);
gtk_box_pack_start(GTK_BOX(object), banner, FALSE, FALSE, 0);
/* Add Overclocking checkbox */
hbox = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(object), hbox, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox), ctk_object->enable_checkbox,
FALSE, FALSE, 0);
/* Add Clock frequency frame */
frame = gtk_frame_new("Clock Frequencies");
vbox = gtk_vbox_new(FALSE, 0);
hbox = gtk_hbox_new(FALSE, 0);
gtk_container_set_border_width(GTK_CONTAINER(vbox), FRAME_PADDING);
gtk_box_pack_start(GTK_BOX(object), frame, FALSE, FALSE, 0);
gtk_container_add(GTK_CONTAINER(frame), vbox);
gtk_box_pack_start(GTK_BOX(hbox), ctk_object->clock_menu,
FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox), hbox,
FALSE, FALSE, 5);
gtk_box_pack_start(GTK_BOX(vbox), ctk_object->gpu_clk_scale,
FALSE, FALSE, 5);
gtk_box_pack_start(GTK_BOX(vbox), ctk_object->mem_clk_scale,
FALSE, FALSE, 5);
/* Add the Apply, Auto Detect, and Reset buttons */
hbox = gtk_hbox_new(FALSE, 5);
gtk_box_pack_start(GTK_BOX(hbox), ctk_object->apply_button,
FALSE, FALSE, 0);
gtk_container_add(GTK_CONTAINER(hbox), ctk_object->detect_button);
gtk_container_add(GTK_CONTAINER(hbox), ctk_object->reset_button);
alignment = gtk_alignment_new(1, 1, 0, 0);
gtk_container_add(GTK_CONTAINER(alignment), hbox);
gtk_box_pack_start(GTK_BOX(object), alignment, TRUE, TRUE, 0);
/* Setup the initial gui state */
sync_gui_to_modify_clocks(ctk_object, ctk_object->clocks_being_modified);
/* Handle events from other NV-CONTROL clients */
g_signal_connect(G_OBJECT(ctk_event),
CTK_EVENT_NAME(NV_CTRL_GPU_OVERCLOCKING_STATE),
G_CALLBACK(overclocking_state_received),
(gpointer) ctk_object);
g_signal_connect(G_OBJECT(ctk_event),
CTK_EVENT_NAME(NV_CTRL_GPU_2D_CLOCK_FREQS),
G_CALLBACK(clocks_received),
(gpointer) ctk_object);
g_signal_connect(G_OBJECT(ctk_event),
CTK_EVENT_NAME(NV_CTRL_GPU_3D_CLOCK_FREQS),
G_CALLBACK(clocks_received),
(gpointer) ctk_object);
g_signal_connect(G_OBJECT(ctk_event),
CTK_EVENT_NAME(NV_CTRL_GPU_OPTIMAL_CLOCK_FREQS),
G_CALLBACK(clocks_received),
(gpointer) ctk_object);
g_signal_connect(G_OBJECT(ctk_event),
CTK_EVENT_NAME(NV_CTRL_GPU_OPTIMAL_CLOCK_FREQS_DETECTION_STATE),
G_CALLBACK(auto_detection_state_received),
(gpointer) ctk_object);
/* Show the widget */
gtk_widget_show_all(GTK_WIDGET(ctk_object));
return GTK_WIDGET(ctk_object);
} /* ctk_clocks_new() */
