GtkWidget* ctk_ecc_new(CtrlTarget *ctrl_target,
CtkConfig *ctk_config,
CtkEvent *ctk_event)
{
GObject *object;
CtkEcc *ctk_ecc;
GtkWidget *hbox, *hbox2, *vbox, *hsep, *hseparator, *table;
GtkWidget *banner, *label, *eventbox;
int64_t sbit_error;
int64_t aggregate_sbit_error;
int64_t dbit_error;
int64_t aggregate_dbit_error;
gint ecc_config_supported;
gint val, row = 0;
gboolean sbit_error_available;
gboolean aggregate_sbit_error_available;
gboolean dbit_error_available;
gboolean aggregate_dbit_error_available;
gboolean ecc_enabled;
gboolean ecc_default_status;
ReturnStatus ret;
gchar *ecc_enabled_string;
gchar *str = NULL;
/* make sure we have a handle */
g_return_val_if_fail((ctrl_target != NULL) &&
(ctrl_target->h != NULL), NULL);
/*
* check if ECC support available.
*/
ret = NvCtrlGetAttribute(ctrl_target,
NV_CTRL_GPU_ECC_SUPPORTED,
&val);
if (ret != NvCtrlSuccess || val != NV_CTRL_GPU_ECC_SUPPORTED_TRUE) {
return NULL;
}
/* create the CtkEcc object */
object = g_object_new(CTK_TYPE_ECC, NULL);
ctk_ecc = CTK_ECC(object);
ctk_ecc->ctrl_target = ctrl_target;
ctk_ecc->ctk_config = ctk_config;
ctk_ecc->ecc_toggle_warning_dlg_shown = FALSE;
sbit_error_available = TRUE;
dbit_error_available = TRUE;
aggregate_sbit_error_available = TRUE;
aggregate_dbit_error_available = TRUE;
sbit_error = 0;
dbit_error = 0;
aggregate_sbit_error = 0;
aggregate_dbit_error = 0;
/* Query ECC Status */
ret = NvCtrlGetAttribute(ctrl_target, NV_CTRL_GPU_ECC_STATUS,
&val);
if (ret != NvCtrlSuccess || val == NV_CTRL_GPU_ECC_STATUS_DISABLED) {
ecc_enabled = FALSE;
ecc_enabled_string = "Disabled";
} else {
ecc_enabled = TRUE;
ecc_enabled_string = "Enabled";
}
ctk_ecc->ecc_enabled = ecc_enabled;
/* Query ECC Configuration */
ret = NvCtrlGetAttribute(ctrl_target, NV_CTRL_GPU_ECC_CONFIGURATION,
&val);
if (ret != NvCtrlSuccess ||
val == NV_CTRL_GPU_ECC_CONFIGURATION_DISABLED) {
ctk_ecc->ecc_configured = FALSE;
} else {
ctk_ecc->ecc_configured = TRUE;
}
/* get default status */
ret = NvCtrlGetAttribute(ctrl_target,
NV_CTRL_GPU_ECC_DEFAULT_CONFIGURATION,
&val);
if (ret != NvCtrlSuccess ||
val == NV_CTRL_GPU_ECC_DEFAULT_CONFIGURATION_DISABLED) {
ecc_default_status = FALSE;
} else {
ecc_default_status = TRUE;
}
/* Query ECC errors */
ret = NvCtrlGetAttribute64(ctrl_target,
NV_CTRL_GPU_ECC_SINGLE_BIT_ERRORS,
&sbit_error);
if (ret != NvCtrlSuccess) {
sbit_error_available = FALSE;
}
ret = NvCtrlGetAttribute64(ctrl_target,
NV_CTRL_GPU_ECC_DOUBLE_BIT_ERRORS,
&dbit_error);
if (ret != NvCtrlSuccess) {
dbit_error_available = FALSE;
}
ret = NvCtrlGetAttribute64(ctrl_target,
NV_CTRL_GPU_ECC_AGGREGATE_SINGLE_BIT_ERRORS,
&aggregate_sbit_error);
if (ret != NvCtrlSuccess) {
aggregate_sbit_error_available = FALSE;
}
ret = NvCtrlGetAttribute64(ctrl_target,
NV_CTRL_GPU_ECC_AGGREGATE_DOUBLE_BIT_ERRORS,
&aggregate_dbit_error);
if (ret != NvCtrlSuccess) {
aggregate_dbit_error_available = FALSE;
}
ctk_ecc->sbit_error_available = sbit_error_available;
ctk_ecc->aggregate_sbit_error_available = aggregate_sbit_error_available;
ctk_ecc->dbit_error_available = dbit_error_available;
ctk_ecc->aggregate_dbit_error_available = aggregate_dbit_error_available;
/* Query ECC configuration supported */
ret = NvCtrlGetAttribute(ctrl_target,
NV_CTRL_GPU_ECC_CONFIGURATION_SUPPORTED,
&ecc_config_supported);
if (ret != NvCtrlSuccess) {
ecc_config_supported = 0;
}
/* set container properties for the CtkEcc widget */
gtk_box_set_spacing(GTK_BOX(ctk_ecc), 5);
/* banner */
banner = ctk_banner_image_new(BANNER_ARTWORK_GPU);
gtk_box_pack_start(GTK_BOX(object), banner, FALSE, FALSE, 0);
vbox = gtk_vbox_new(FALSE, 5);
gtk_box_pack_start(GTK_BOX(object), vbox, TRUE, TRUE, 0);
hbox = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
label = gtk_label_new("ECC Status");
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, 5);
table = gtk_table_new(1, 2, FALSE);
gtk_box_pack_start(GTK_BOX(vbox), table, FALSE, FALSE, 0);
gtk_table_set_row_spacings(GTK_TABLE(table), 3);
gtk_table_set_col_spacings(GTK_TABLE(table), 15);
gtk_container_set_border_width(GTK_CONTAINER(table), 5);
/* ECC Status */
hbox2 = gtk_hbox_new(FALSE, 0);
gtk_table_attach(GTK_TABLE(table), hbox2, 0, 1, row, row+1,
GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0);
label = gtk_label_new("ECC:");
gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f);
gtk_box_pack_start(GTK_BOX(hbox2), label, FALSE, FALSE, 0);
eventbox = gtk_event_box_new();
gtk_table_attach(GTK_TABLE(table), eventbox, 1, 2, row, row+1,
GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0);
label = gtk_label_new(ecc_enabled_string);
gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f);
gtk_container_add(GTK_CONTAINER(eventbox), label);
ctk_config_set_tooltip(ctk_config, eventbox, __ecc_status_help);
ctk_ecc->status = label;
row += 3;
/* Add ECC Errors */
if (sbit_error_available && dbit_error_available) {
ctk_ecc->sbit_error =
add_table_int_row(ctk_config, table, __sbit_error_help,
"Single-bit ECC Errors:", sbit_error,
row, ecc_enabled);
row += 1; // add vertical padding between rows
ctk_ecc->dbit_error =
add_table_int_row(ctk_config, table, __dbit_error_help,
"Double-bit ECC Errors:", dbit_error,
row, ecc_enabled);
row += 3; // add vertical padding between rows
}
if (aggregate_sbit_error_available && aggregate_dbit_error_available) {
ctk_ecc->aggregate_sbit_error =
add_table_int_row(ctk_config, table, __aggregate_sbit_error_help,
"Aggregate Single-bit ECC Errors:",
aggregate_sbit_error, row, ecc_enabled);
row += 1; // add vertical padding between rows
ctk_ecc->aggregate_dbit_error =
add_table_int_row(ctk_config, table, __aggregate_dbit_error_help,
"Aggregate Double-bit ECC Errors:",
aggregate_dbit_error, row, ecc_enabled);
}
/* ECC configuration settings */
hbox = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
label = gtk_label_new("ECC Configuration");
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
hsep = gtk_hseparator_new();
gtk_box_pack_start(GTK_BOX(hbox), hsep, TRUE, TRUE, 5);
hbox2 = gtk_hbox_new(FALSE, 0);
ctk_ecc->configuration_status =
gtk_check_button_new_with_label("Enable ECC");
gtk_box_pack_start(GTK_BOX(hbox2),
ctk_ecc->configuration_status, FALSE, FALSE, 0);
gtk_container_set_border_width(GTK_CONTAINER(hbox2), 5);
gtk_box_pack_start(GTK_BOX(vbox), hbox2, FALSE, FALSE, 0);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(ctk_ecc->configuration_status),
ctk_ecc->ecc_configured);
ctk_config_set_tooltip(ctk_config, ctk_ecc->configuration_status,
__configuration_status_help);
g_signal_connect(G_OBJECT(ctk_ecc->configuration_status), "clicked",
G_CALLBACK(ecc_config_button_toggled),
(gpointer) ctk_ecc);
g_signal_connect(G_OBJECT(ctk_event),
CTK_EVENT_NAME(NV_CTRL_GPU_ECC_CONFIGURATION),
G_CALLBACK(ecc_configuration_update_received),
(gpointer) ctk_ecc);
gtk_widget_set_sensitive(ctk_ecc->configuration_status, ecc_config_supported);
hbox = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(ctk_ecc), hbox, FALSE, FALSE, 0);
/* Add buttons */
if (sbit_error_available && dbit_error_available) {
ctk_ecc->clear_button = gtk_button_new_with_label("Clear ECC Errors");
gtk_box_pack_end(GTK_BOX(hbox), ctk_ecc->clear_button, FALSE, FALSE, 0);
ctk_config_set_tooltip(ctk_config, ctk_ecc->clear_button,
__clear_button_help);
gtk_widget_set_sensitive(ctk_ecc->clear_button, ecc_enabled);
g_signal_connect(G_OBJECT(ctk_ecc->clear_button), "clicked",
G_CALLBACK(clear_ecc_errors_button_clicked),
(gpointer) ctk_ecc);
}
if (aggregate_sbit_error_available && aggregate_dbit_error_available) {
ctk_ecc->clear_aggregate_button =
gtk_button_new_with_label("Clear Aggregate ECC Errors");
gtk_box_pack_end(GTK_BOX(hbox), ctk_ecc->clear_aggregate_button,
FALSE, FALSE, 0);
ctk_config_set_tooltip(ctk_config, ctk_ecc->clear_button,
__clear_aggregate_button_help);
gtk_widget_set_sensitive(ctk_ecc->clear_aggregate_button, ecc_enabled);
g_signal_connect(G_OBJECT(ctk_ecc->clear_aggregate_button),
"clicked",
G_CALLBACK(clear_aggregate_ecc_errors_button_clicked),
(gpointer) ctk_ecc);
}
ctk_ecc->reset_default_config_button =
gtk_button_new_with_label("Reset Default Configuration");
eventbox = gtk_event_box_new();
gtk_container_add(GTK_CONTAINER(eventbox),
ctk_ecc->reset_default_config_button);
gtk_box_pack_end(GTK_BOX(hbox), eventbox, FALSE, FALSE, 5);
ctk_config_set_tooltip(ctk_config, ctk_ecc->reset_default_config_button,
__reset_default_config_button_help);
gtk_widget_set_sensitive(ctk_ecc->reset_default_config_button,
ecc_config_supported &&
(ecc_enabled != ecc_default_status));
g_signal_connect(G_OBJECT(ctk_ecc->reset_default_config_button),
"clicked",
G_CALLBACK(reset_default_config_button_clicked),
(gpointer) ctk_ecc);
/* Register a timer callback to update Ecc status info */
str = g_strdup_printf("ECC Settings (GPU %d)",
NvCtrlGetTargetId(ctrl_target));
ctk_config_add_timer(ctk_ecc->ctk_config,
DEFAULT_UPDATE_ECC_STATUS_INFO_TIME_INTERVAL,
str,
(GSourceFunc) update_ecc_info,
(gpointer) ctk_ecc);
g_free(str);
gtk_widget_show_all(GTK_WIDGET(ctk_ecc));
update_ecc_info(ctk_ecc);
return GTK_WIDGET(ctk_ecc);
}
/*
* CTK VCS (Visual Computing System) widget creation
*
*/
GtkWidget* ctk_vcs_new(NvCtrlAttributeHandle *handle,
CtkConfig *ctk_config)
{
GObject *object;
CtkVcs *ctk_object;
GtkWidget *label;
GtkWidget *vbox;
GtkWidget *hbox;
GtkWidget *event;
GtkWidget *banner;
GtkWidget *hseparator;
GtkWidget *table;
GtkWidget *scrollWin;
GtkWidget *checkbutton;
gchar *product_name;
gchar *serial_number;
gchar *build_date;
gchar *product_id;
gchar *firmware_version;
gchar *hardware_version;
gint current_row;
gboolean high_perf_mode;
ReturnStatus ret;
gchar *s;
char *psu_str = NULL;
PSUEntry psuEntry;
GtkWidget *vbox_scroll, *hbox_scroll;
/*
* get the static string data that we will display below
*/
/* Product Name */
ret = NvCtrlGetStringAttribute(handle,
NV_CTRL_STRING_VCSC_PRODUCT_NAME,
&product_name);
if (ret != NvCtrlSuccess) {
product_name = g_strdup("Unable to determine");
}
/* Serial Number */
ret = NvCtrlGetStringAttribute(handle,
NV_CTRL_STRING_VCSC_SERIAL_NUMBER,
&serial_number);
if (ret != NvCtrlSuccess) {
serial_number = g_strdup("Unable to determine");
}
/* Build Date */
ret = NvCtrlGetStringAttribute(handle,
NV_CTRL_STRING_VCSC_BUILD_DATE,
&build_date);
if (ret != NvCtrlSuccess) {
build_date = g_strdup("Unable to determine");
}
/* Product ID */
ret = NvCtrlGetStringAttribute(handle,
NV_CTRL_STRING_VCSC_PRODUCT_ID,
&product_id);
if (ret != NvCtrlSuccess) {
product_id = g_strdup("Unable to determine");
}
/* Firmware Version */
ret = NvCtrlGetStringAttribute(handle,
NV_CTRL_STRING_VCSC_FIRMWARE_VERSION,
&firmware_version);
if (ret != NvCtrlSuccess) {
firmware_version = g_strdup("Unable to determine");
}
/* Hardware Version */
ret = NvCtrlGetStringAttribute(handle,
NV_CTRL_STRING_VCSC_HARDWARE_VERSION,
&hardware_version);
if (ret != NvCtrlSuccess) {
hardware_version = g_strdup("Unable to determine");
}
/* now, create the object */
object = g_object_new(CTK_TYPE_VCS, NULL);
ctk_object = CTK_VCS(object);
/* cache the attribute handle */
ctk_object->handle = handle;
ctk_object->ctk_config = ctk_config;
/* set container properties of the object */
gtk_box_set_spacing(GTK_BOX(ctk_object), 10);
/* banner */
banner = ctk_banner_image_new(BANNER_ARTWORK_VCS);
gtk_box_pack_start(GTK_BOX(ctk_object), banner, FALSE, FALSE, 0);
/*
* This displays basic System information, including
* display name, Operating system type and the NVIDIA driver version.
*/
vbox = gtk_vbox_new(FALSE, 5);
gtk_box_pack_start(GTK_BOX(ctk_object), vbox, TRUE, TRUE, 0);
/* General purpose error dialog */
ctk_object->error_dialog = create_error_dialog(ctk_object);
if (NvCtrlGetAttribute(ctk_object->handle, NV_CTRL_VCSC_HIGH_PERF_MODE,
&high_perf_mode) == NvCtrlSuccess) {
hbox = gtk_hbox_new(FALSE, 0);
checkbutton = gtk_check_button_new_with_label("Enable High Performance Mode");
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkbutton), high_perf_mode);
g_signal_connect(G_OBJECT(checkbutton), "toggled",
G_CALLBACK(vcs_perf_checkbox_toggled),
(gpointer) ctk_object);
gtk_box_pack_start(GTK_BOX(hbox), checkbutton, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
}
/* Create the Scrolling Window */
scrollWin = gtk_scrolled_window_new(NULL, NULL);
hbox_scroll = gtk_hbox_new(FALSE, 0);
vbox_scroll = gtk_vbox_new(FALSE, 5);
event = gtk_event_box_new();
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrollWin),
GTK_POLICY_NEVER, GTK_POLICY_ALWAYS);
gtk_widget_modify_fg(event, GTK_STATE_NORMAL, &(event->style->text[GTK_STATE_NORMAL]));
gtk_widget_modify_bg(event, GTK_STATE_NORMAL, &(event->style->base[GTK_STATE_NORMAL]));
gtk_container_add(GTK_CONTAINER(event), hbox_scroll);
gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scrollWin),
event);
gtk_box_pack_start(GTK_BOX(hbox_scroll), vbox_scroll, TRUE, TRUE, 5);
gtk_widget_set_size_request(scrollWin, -1, 50);
gtk_box_pack_start(GTK_BOX(vbox), scrollWin, TRUE, TRUE, 0);
hbox = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox_scroll), hbox, FALSE, FALSE, 0);
label = gtk_label_new("VCS Information");
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, 5);
table = gtk_table_new(5, 2, FALSE);
gtk_box_pack_start(GTK_BOX(vbox_scroll), table, FALSE, FALSE, 0);
gtk_table_set_row_spacings(GTK_TABLE(table), 3);
gtk_table_set_col_spacings(GTK_TABLE(table), 15);
gtk_container_set_border_width(GTK_CONTAINER(table), 5);
add_table_row(table, 0,
0, 0.5, "Product Name:", 0, 0.5, product_name);
add_table_row(table, 1,
0, 0.5, "Serial Number:", 0, 0.5, serial_number);
add_table_row(table, 2,
0, 0.5, "Build Date:", 0, 0.5, build_date);
add_table_row(table, 3,
0, 0.5, "Product ID:", 0, 0.5, product_id);
add_table_row(table, 4,
0, 0.5, "Firmware version:", 0, 0.5, firmware_version);
add_table_row(table, 5,
0, 0.5, "Hardware version:", 0, 0.5, hardware_version);
g_free(product_name);
g_free(serial_number);
g_free(build_date);
g_free(product_id);
g_free(firmware_version);
g_free(hardware_version);
/* Query Canoas 2.0 specific details */
if ((NvCtrlGetAttribute(ctk_object->handle, NV_CTRL_VCSC_HIGH_PERF_MODE,
&high_perf_mode) == NvCtrlSuccess) &&
(NvCtrlGetStringAttribute(ctk_object->handle,
NV_CTRL_STRING_VCSC_PSU_INFO,
&psu_str) == NvCtrlSuccess)) {
GtkWidget *vbox_padding;
/* Show the additonal queried information */
/* Populate scrolling window with data */
vbox_padding = gtk_vbox_new(FALSE, 0);
hbox = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox_scroll), vbox_padding, FALSE, FALSE, 1);
gtk_box_pack_start(GTK_BOX(vbox_scroll), hbox, FALSE, FALSE, 0);
label = gtk_label_new("VCS Thermal Information");
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, 5);
table = gtk_table_new(3, 2, FALSE);
gtk_box_pack_start(GTK_BOX(vbox_scroll), table, FALSE, FALSE, 0);
gtk_table_set_row_spacings(GTK_TABLE(table), 3);
gtk_table_set_col_spacings(GTK_TABLE(table), 15);
gtk_container_set_border_width(GTK_CONTAINER(table), 5);
label = gtk_label_new("Intake Temperature:");
gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f);
gtk_table_attach(GTK_TABLE(table), label, 0, 1, 0, 1,
GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0);
label = gtk_label_new(NULL);
gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f);
gtk_table_attach(GTK_TABLE(table), label, 1, 2, 0, 1,
GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0);
ctk_object->intake_temp = label;
label = gtk_label_new("Exhaust Temperature:");
/* This is the current largest label. Get its size */
gtk_widget_size_request(label, &ctk_object->req);
gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f);
gtk_table_attach(GTK_TABLE(table), label, 0, 1, 1, 2,
GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0);
label = gtk_label_new(NULL);
gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f);
gtk_table_attach(GTK_TABLE(table), label, 1, 2, 1, 2,
GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0);
ctk_object->exhaust_temp = label;
label = gtk_label_new("Board Temperature:");
gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f);
gtk_table_attach(GTK_TABLE(table), label, 0, 1, 2, 3,
GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0);
label = gtk_label_new(NULL);
gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f);
gtk_table_attach(GTK_TABLE(table), label, 1, 2, 2, 3,
GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0);
ctk_object->board_temp = label;
/* Populate table for PSU information */
psuEntry.psu_current = -1;
psuEntry.psu_power = -1;
psuEntry.psu_voltage = -1;
psuEntry.psu_state = -1;
if (psu_str) {
parse_token_value_pairs(psu_str, apply_psu_entry_token, &psuEntry);
}
vbox_padding = gtk_vbox_new(FALSE, 0);
hbox = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox_scroll), vbox_padding, FALSE, FALSE, 1);
gtk_box_pack_start(GTK_BOX(vbox_scroll), hbox, FALSE, FALSE, 0);
label = gtk_label_new("VCS Power Supply Unit Information");
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, 5);
table = gtk_table_new(4, 2, FALSE);
gtk_box_pack_start(GTK_BOX(vbox_scroll), table, FALSE, FALSE, 0);
gtk_table_set_row_spacings(GTK_TABLE(table), 3);
gtk_table_set_col_spacings(GTK_TABLE(table), 15);
gtk_container_set_border_width(GTK_CONTAINER(table), 5);
label = gtk_label_new("PSU State:");
gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f);
gtk_widget_set_size_request(label, ctk_object->req.width, -1);
gtk_table_attach(GTK_TABLE(table), label, 0, 1, 0, 1,
GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0);
label = gtk_label_new(NULL);
gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f);
gtk_table_attach(GTK_TABLE(table), label, 1, 2, 0, 1,
GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0);
ctk_object->psu_state = label;
label = gtk_label_new("PSU Current:");
gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f);
gtk_widget_set_size_request(label, ctk_object->req.width, -1);
gtk_table_attach(GTK_TABLE(table), label, 0, 1, 1, 2,
GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0);
label = gtk_label_new(NULL);
gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f);
gtk_table_attach(GTK_TABLE(table), label, 1, 2, 1, 2,
GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0);
ctk_object->psu_current = label;
current_row = 2;
if (psuEntry.psu_power != -1) {
label = gtk_label_new("PSU Power:");
gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f);
gtk_widget_set_size_request(label, ctk_object->req.width, -1);
gtk_table_attach(GTK_TABLE(table), label, 0, 1,
current_row, current_row + 1,
GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0);
label = gtk_label_new(NULL);
gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f);
gtk_table_attach(GTK_TABLE(table), label, 1, 2,
current_row, current_row + 1,
GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0);
ctk_object->psu_power = label;
current_row++;
}
if (psuEntry.psu_voltage != -1) {
label = gtk_label_new("PSU Voltage:");
gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f);
gtk_widget_set_size_request(label, ctk_object->req.width, -1);
gtk_table_attach(GTK_TABLE(table), label, 0, 1,
current_row, current_row + 1,
GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0);
label = gtk_label_new(NULL);
gtk_misc_set_alignment(GTK_MISC(label), 0.0f, 0.5f);
gtk_table_attach(GTK_TABLE(table), label, 1, 2,
current_row, current_row + 1,
GTK_FILL, GTK_FILL | GTK_EXPAND, 5, 0);
ctk_object->psu_voltage = label;
}
/* Create container for fan status table */
vbox_padding = gtk_vbox_new(FALSE, 0);
hbox = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox_scroll), vbox_padding, FALSE, FALSE, 1);
gtk_box_pack_start(GTK_BOX(vbox_scroll), hbox, FALSE, FALSE, 0);
label = gtk_label_new("VCS Fan Status");
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, 5);
hbox = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox_scroll), hbox, FALSE, FALSE, 0);
ctk_object->fan_status_container = hbox;
/* Register a timer callback to update the dynamic information */
s = g_strdup_printf("VCS Monitor (VCS %d)",
NvCtrlGetTargetId(ctk_object->handle));
ctk_config_add_timer(ctk_object->ctk_config,
DEFAULT_UPDATE_VCS_INFO_TIME_INTERVAL,
s,
(GSourceFunc) update_vcs_info,
(gpointer) ctk_object);
g_free(s);
update_vcs_info(ctk_object);
}
gtk_widget_show_all(GTK_WIDGET(object));
return GTK_WIDGET(object);
}
