static GtkTreeStore *_local_create_treestore_2cols(GtkWidget *popup,
int x, int y)
{
GtkScrolledWindow *window = create_scrolled_window();
GtkBin *bin = NULL;
GtkViewport *view = NULL;
GtkTable *table = NULL;
GtkTreeView *treeview = NULL;
GtkTreeStore *treestore = NULL;
bin = GTK_BIN(&window->container);
view = GTK_VIEWPORT(bin->child);
bin = GTK_BIN(&view->bin);
table = GTK_TABLE(bin->child);
gtk_window_set_default_size(GTK_WINDOW(popup),
x, y);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(popup)->vbox),
GTK_WIDGET(window), TRUE, TRUE, 0);
treeview = create_treeview_2cols_attach_to_table(table);
treestore = GTK_TREE_STORE(gtk_tree_view_get_model(treeview));
return treestore;
}
extern GtkWidget *create_resv_entry(resv_desc_msg_t *resv_msg,
GtkTreeModel *model, GtkTreeIter *iter)
{
GtkScrolledWindow *window = create_scrolled_window();
GtkBin *bin = NULL;
GtkViewport *view = NULL;
GtkTable *table = NULL;
int i = 0, row = 0;
display_data_t *display_data = create_data_resv;
gtk_scrolled_window_set_policy(window,
GTK_POLICY_NEVER,
GTK_POLICY_AUTOMATIC);
bin = GTK_BIN(&window->container);
view = GTK_VIEWPORT(bin->child);
bin = GTK_BIN(&view->bin);
table = GTK_TABLE(bin->child);
gtk_table_resize(table, SORTID_CNT, 2);
gtk_table_set_homogeneous(table, FALSE);
for (i = 0; i < SORTID_CNT; i++) {
while (display_data++) {
if (display_data->id == -1)
break;
if (!display_data->name)
continue;
if (display_data->id != i)
continue;
display_admin_edit(
table, resv_msg, &row, model, iter,
display_data,
G_CALLBACK(_admin_edit_combo_box_resv),
G_CALLBACK(_admin_focus_out_resv),
_set_active_combo_resv);
break;
}
display_data = create_data_resv;
}
gtk_table_resize(table, row, 2);
return GTK_WIDGET(window);
}
void EntityList_constructWindow(GtkWindow* main_window)
{
ASSERT_MESSAGE(getEntityList().m_window == 0, "error");
GtkWindow* window = create_persistent_floating_window("Entity List", main_window);
gtk_window_add_accel_group(window, global_accel);
getEntityList().m_positionTracker.connect(window);
getEntityList().m_window = window;
{
GtkScrolledWindow* scr = create_scrolled_window(GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_container_add(GTK_CONTAINER(window), GTK_WIDGET(scr));
{
GtkWidget* view = gtk_tree_view_new();
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(view), FALSE);
GtkCellRenderer* renderer = gtk_cell_renderer_text_new();
GtkTreeViewColumn* column = gtk_tree_view_column_new();
gtk_tree_view_column_pack_start(column, renderer, TRUE);
gtk_tree_view_column_set_cell_data_func(column, renderer, entitylist_treeviewcolumn_celldatafunc, 0, 0);
GtkTreeSelection* select = gtk_tree_view_get_selection (GTK_TREE_VIEW(view));
gtk_tree_selection_set_mode(select, GTK_SELECTION_MULTIPLE);
g_signal_connect(G_OBJECT(view), "row_expanded", G_CALLBACK(entitylist_treeview_row_expanded), 0);
g_signal_connect(G_OBJECT(view), "row_collapsed", G_CALLBACK(entitylist_treeview_rowcollapsed), 0);
gtk_tree_view_append_column (GTK_TREE_VIEW (view), column);
gtk_widget_show(view);
gtk_container_add (GTK_CONTAINER(scr), view);
getEntityList().m_tree_view = GTK_TREE_VIEW(view);
}
}
EntityList_ConnectSignals(getEntityList().m_tree_view);
AttachEntityTreeModel();
}
void
create_cells_window (char* filename)
{
GtkWidget *window;
GtkWidget *scrolled_window;
GtkWidget *view;
sqlite3* db;
sqlite3_stmt* stmt;
int rc;
char** tables;
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
g_signal_connect (window, "delete_event", gtk_main_quit, NULL); /* dirty */
scrolled_window = create_scrolled_window();
gtk_container_add (GTK_CONTAINER (window), scrolled_window);
/* this is done with gtk_widget_show_all? */
/* gtk_widget_show (scrolled_window); */
rc = sqlite3_open_v2(filename, &db, SQLITE_OPEN_READONLY, NULL);
assert(! rc);
tables = get_tables(db);
int tn = 3;
printf("%s\n", tables[tn]);
rc = prepare_get_records(db, tables[tn], &stmt);
view = create_view_and_model(stmt);
gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (scrolled_window),
view);
gtk_widget_show_all (window);
return;
}
GtkWidget *
create_main_view(void) {
int i;
GtkWidget *vbox, *hbox;
GtkWidget *tool_button;
GtkWidget *scrolled_window;
struct {
const gchar *stock_id;
void *click_handler;
} tool_buttons[] = {
{ GTK_STOCK_GO_BACK, handle_back_clicked },
{ GTK_STOCK_GO_FORWARD, handle_forward_clicked },
{ GTK_STOCK_HOME, handle_home_clicked },
{ GTK_STOCK_GO_UP, handle_up_clicked }
};
vbox = gtk_vbox_new(FALSE, 0);
hbox = gtk_hbox_new(FALSE, 0);
path_entry = gtk_entry_new();
icon_view = create_icon_view();
scrolled_window = create_scrolled_window(icon_view);
g_signal_connect(G_OBJECT(path_entry), "insert-at-cursor", G_CALLBACK(handle_path_entered), NULL);
for (i = 0; i < NELEMS(tool_buttons); ++i) {
tool_button = (GtkWidget *) gtk_tool_button_new_from_stock(tool_buttons[i].stock_id);
g_signal_connect(G_OBJECT(tool_button), "clicked", G_CALLBACK(tool_buttons[i].click_handler), NULL);
gtk_box_pack_start(GTK_BOX(hbox), tool_button, FALSE, FALSE, 0);
}
gtk_box_pack_start(GTK_BOX(hbox), path_entry, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox), scrolled_window, TRUE, TRUE, 0);
return vbox;
}
void DoCommandListDlg(){
command_list_dialog_t dialog;
GtkWindow* window = create_modal_dialog_window( MainFrame_getWindow(), "Mapped Commands", dialog, -1, 400 );
g_signal_connect( G_OBJECT( window ), "key-press-event", (GCallback) accelerator_window_key_press, &dialog );
GtkAccelGroup* accel = gtk_accel_group_new();
gtk_window_add_accel_group( window, accel );
GtkHBox* hbox = create_dialog_hbox( 4, 4 );
gtk_container_add( GTK_CONTAINER( window ), GTK_WIDGET( hbox ) );
{
GtkScrolledWindow* scr = create_scrolled_window( GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC );
gtk_box_pack_start( GTK_BOX( hbox ), GTK_WIDGET( scr ), TRUE, TRUE, 0 );
{
GtkListStore* store = gtk_list_store_new( 4, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_BOOLEAN, G_TYPE_INT );
GtkWidget* view = gtk_tree_view_new_with_model( GTK_TREE_MODEL( store ) );
dialog.m_list = GTK_TREE_VIEW( view );
gtk_tree_view_set_enable_search( GTK_TREE_VIEW( view ), false ); // annoying
{
GtkCellRenderer* renderer = gtk_cell_renderer_text_new();
GtkTreeViewColumn* column = gtk_tree_view_column_new_with_attributes( "Command", renderer, "text", 0, "weight-set", 2, "weight", 3, NULL );
gtk_tree_view_append_column( GTK_TREE_VIEW( view ), column );
}
{
GtkCellRenderer* renderer = gtk_cell_renderer_text_new();
GtkTreeViewColumn* column = gtk_tree_view_column_new_with_attributes( "Key", renderer, "text", 1, "weight-set", 2, "weight", 3, NULL );
gtk_tree_view_append_column( GTK_TREE_VIEW( view ), column );
}
gtk_widget_show( view );
gtk_container_add( GTK_CONTAINER( scr ), view );
{
// Initialize dialog
StringOutputStream path( 256 );
path << SettingsPath_get() << "commandlist.txt";
globalOutputStream() << "Writing the command list to " << path.c_str() << "\n";
class BuildCommandList : public CommandVisitor
{
TextFileOutputStream m_commandList;
GtkListStore* m_store;
public:
BuildCommandList( const char* filename, GtkListStore* store ) : m_commandList( filename ), m_store( store ){
}
void visit( const char* name, Accelerator& accelerator ){
StringOutputStream modifiers;
modifiers << accelerator;
{
GtkTreeIter iter;
gtk_list_store_append( m_store, &iter );
gtk_list_store_set( m_store, &iter, 0, name, 1, modifiers.c_str(), 2, false, 3, 800, -1 );
}
if ( !m_commandList.failed() ) {
int l = strlen( name );
m_commandList << name;
while ( l++ < 25 )
m_commandList << ' ';
m_commandList << modifiers.c_str() << '\n';
}
}
} visitor( path.c_str(), store );
GlobalShortcuts_foreach( visitor );
}
g_object_unref( G_OBJECT( store ) );
}
}
GtkVBox* vbox = create_dialog_vbox( 4 );
gtk_box_pack_start( GTK_BOX( hbox ), GTK_WIDGET( vbox ), TRUE, TRUE, 0 );
{
GtkButton* editbutton = create_dialog_button( "Edit", (GCallback) accelerator_edit_button_clicked, &dialog );
gtk_box_pack_start( GTK_BOX( vbox ), GTK_WIDGET( editbutton ), FALSE, FALSE, 0 );
GtkButton* clearbutton = create_dialog_button( "Clear", (GCallback) accelerator_clear_button_clicked, &dialog );
gtk_box_pack_start( GTK_BOX( vbox ), GTK_WIDGET( clearbutton ), FALSE, FALSE, 0 );
GtkWidget *spacer = gtk_image_new();
gtk_widget_show( spacer );
gtk_box_pack_start( GTK_BOX( vbox ), GTK_WIDGET( spacer ), TRUE, TRUE, 0 );
GtkButton* button = create_modal_dialog_button( "Close", dialog.m_close_button );
gtk_box_pack_start( GTK_BOX( vbox ), GTK_WIDGET( button ), FALSE, FALSE, 0 );
widget_make_default( GTK_WIDGET( button ) );
gtk_widget_grab_default( GTK_WIDGET( button ) );
gtk_widget_add_accelerator( GTK_WIDGET( button ), "clicked", accel, GDK_Return, (GdkModifierType)0, (GtkAccelFlags)0 );
gtk_widget_add_accelerator( GTK_WIDGET( button ), "clicked", accel, GDK_Escape, (GdkModifierType)0, (GtkAccelFlags)0 );
}
modal_dialog_show( window, dialog );
gtk_widget_destroy( GTK_WIDGET( window ) );
}
/**
* gtk_source_completion_info_set_widget:
* @info: A #GtkSourceCompletionInfo
* @widget: A #GtkWidget
*
* Sets the content widget of the info window. If @widget does not fit within
* the size requirements of the window, a #GtkScrolledWindow will automatically
* be created and added to the window.
*
*/
void
gtk_source_completion_info_set_widget (GtkSourceCompletionInfo *info,
GtkWidget *widget)
{
GtkWidget *child;
g_return_if_fail (GTK_IS_SOURCE_COMPLETION_INFO (info));
g_return_if_fail (widget == NULL || GTK_IS_WIDGET (widget));
if (info->priv->widget == widget)
{
return;
}
if (info->priv->widget != NULL)
{
g_signal_handler_disconnect (info->priv->widget, info->priv->request_id);
gtk_container_remove (GTK_CONTAINER (gtk_widget_get_parent (info->priv->widget)),
info->priv->widget);
if (info->priv->scroll != NULL)
{
gtk_widget_destroy (info->priv->scroll);
info->priv->scroll = NULL;
}
}
info->priv->widget = widget;
if (widget != NULL)
{
/* Keep it alive */
if (g_object_is_floating (widget))
{
g_object_ref (widget);
}
info->priv->request_id = g_signal_connect_after (widget,
"size-request",
G_CALLBACK (widget_size_request_cb),
info);
/* See if it needs a viewport */
if (use_scrolled_window (info, widget))
{
create_scrolled_window (info);
child = widget;
if (needs_viewport (widget))
{
child = gtk_viewport_new (NULL, NULL);
gtk_viewport_set_shadow_type (GTK_VIEWPORT (child), GTK_SHADOW_NONE);
gtk_widget_show (child);
gtk_container_add (GTK_CONTAINER (child), widget);
}
gtk_container_add (GTK_CONTAINER (info->priv->scroll), child);
}
else
{
gtk_container_add (GTK_CONTAINER (info), widget);
}
gtk_widget_show (widget);
}
queue_resize (info);
}
int main(int argc, char **argv)
{
GtkWidget *menubar = NULL;
GtkWidget *table = NULL;
GtkWidget *combo = NULL;
GtkBin *bin = NULL;
GtkViewport *view = NULL;
int i=0;
log_options_t lopts = LOG_OPTS_STDERR_ONLY;
if (!getenv("SLURM_BITSTR_LEN"))
setenv("SLURM_BITSTR_LEN", "128", 1); /* More array info */
slurm_conf_init(NULL);
log_init(argv[0], lopts, SYSLOG_FACILITY_USER, NULL);
load_defaults();
cluster_flags = slurmdb_setup_cluster_flags();
cluster_dims = slurmdb_setup_cluster_dims();
_init_pages();
sview_thread_init(NULL);
gdk_threads_init();
gdk_threads_enter();
/* Initialize GTK */
gtk_init (&argc, &argv);
sview_mutex_new(&sview_mutex);
sview_mutex_new(&grid_mutex);
sview_cond_new(&grid_cond);
/* make sure the system is up */
grid_window = GTK_WIDGET(create_scrolled_window());
bin = GTK_BIN(>K_SCROLLED_WINDOW(grid_window)->container);
view = GTK_VIEWPORT(bin->child);
bin = GTK_BIN(&view->bin);
main_grid_table = GTK_TABLE(bin->child);
gtk_table_set_homogeneous(main_grid_table, true);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(grid_window),
GTK_POLICY_NEVER,
GTK_POLICY_AUTOMATIC);
/* fill in all static info for pages */
/* Make a window */
main_window = gtk_dialog_new();
g_signal_connect(G_OBJECT(main_window), "delete_event",
G_CALLBACK(_delete), NULL);
gtk_window_set_title(GTK_WINDOW(main_window), "Sview");
gtk_window_set_default_size(GTK_WINDOW(main_window),
working_sview_config.main_width,
working_sview_config.main_height);
gtk_container_set_border_width(
GTK_CONTAINER(GTK_DIALOG(main_window)->vbox), 1);
/* Create the main notebook, place the position of the tabs */
main_notebook = gtk_notebook_new();
g_signal_connect(G_OBJECT(main_notebook), "switch_page",
G_CALLBACK(_page_switched),
NULL);
table = gtk_table_new(1, 3, false);
gtk_table_set_homogeneous(GTK_TABLE(table), false);
gtk_container_set_border_width(GTK_CONTAINER(table), 1);
/* Create a menu */
menubar = _get_menubar_menu(main_window, main_notebook);
gtk_table_attach_defaults(GTK_TABLE(table), menubar, 0, 1, 0, 1);
if ((combo = _create_cluster_combo())) {
GtkWidget *label = gtk_label_new("Cluster ");
gtk_table_attach(GTK_TABLE(table), label, 1, 2, 0, 1,
GTK_FILL, GTK_SHRINK, 0, 0);
gtk_table_attach(GTK_TABLE(table), combo, 2, 3, 0, 1,
GTK_FILL, GTK_SHRINK, 0, 0);
}
gtk_notebook_popup_enable(GTK_NOTEBOOK(main_notebook));
gtk_notebook_set_scrollable(GTK_NOTEBOOK(main_notebook), true);
gtk_notebook_set_tab_pos(GTK_NOTEBOOK(main_notebook),
working_sview_config.tab_pos);
main_statusbar = gtk_statusbar_new();
gtk_statusbar_set_has_resize_grip(GTK_STATUSBAR(main_statusbar),
false);
/* Pack it all together */
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(main_window)->vbox),
table, false, false, 0);
table = gtk_table_new(1, 2, false);
gtk_table_attach(GTK_TABLE(table), grid_window, 0, 1, 0, 1,
GTK_SHRINK, GTK_EXPAND | GTK_FILL,
0, 0);
gtk_table_attach_defaults(GTK_TABLE(table), main_notebook, 1, 2, 0, 1);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(main_window)->vbox),
table, true, true, 0);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(main_window)->vbox),
main_statusbar, false, false, 0);
in_process_cursor = gdk_cursor_new(GDK_WATCH);
for(i=0; i<PAGE_CNT; i++) {
if (main_display_data[i].id == -1)
break;
create_page(GTK_NOTEBOOK(main_notebook),
&main_display_data[i]);
}
/* tell signal we are done adding */
popup_list = list_create(destroy_popup_info);
signal_params_list = list_create(destroy_signal_params);
gtk_widget_show_all(main_window);
adding = 0;
/* apply default settings */
if (!working_sview_config.show_grid)
gtk_widget_hide(grid_window);
for(i=0; i<PAGE_CNT; i++) {
GtkWidget *visible_tab = NULL;
if (main_display_data[i].id == -1)
break;
visible_tab = gtk_notebook_get_nth_page(
GTK_NOTEBOOK(main_notebook), i);
if (working_sview_config.page_visible[i]
|| (i == working_sview_config.default_page)
|| (i == TAB_PAGE))
gtk_widget_show(visible_tab);
else
gtk_widget_hide(visible_tab);
}
/* Set the default page. This has to be done after the
* gtk_widget_show_all since it, for some reason always sets
* 0 to be the default page and will just overwrite this. */
/* Also if we already are set at the current page we need to
start up the page thread, so just call the _page_switched
function. If we aren't already there, then set the current
page which will inturn call the _page_switched. If the
pages is already this the signal doesn't happen so handle
it here.
*/
if (gtk_notebook_get_current_page(GTK_NOTEBOOK(main_notebook))
== working_sview_config.default_page)
_page_switched(GTK_NOTEBOOK(main_notebook), NULL,
working_sview_config.default_page, NULL);
else
gtk_notebook_set_current_page(GTK_NOTEBOOK(main_notebook),
working_sview_config.
default_page);
/* Finished! */
gtk_main ();
gdk_threads_leave();
return 0;
}
extern int configure_defaults(void)
{
GtkScrolledWindow *window = create_scrolled_window();
GtkWidget *popup = gtk_dialog_new_with_buttons(
"Sview Defaults",
GTK_WINDOW(main_window),
GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
NULL);
GtkWidget *label = gtk_dialog_add_button(GTK_DIALOG(popup),
GTK_STOCK_OK, GTK_RESPONSE_OK);
GtkBin *bin = NULL;
GtkViewport *view = NULL;
GtkTable *table = NULL;
int i = 0, row = 0;
char tmp_char[100];
char *tmp_char_ptr;
display_data_t *display_data = display_data_defaults;
sview_config_t tmp_config;
int response = 0;
int rc = SLURM_SUCCESS;
uint32_t width = 150;
uint32_t height = 700;
apply_hidden_change = TRUE;
memcpy(&tmp_config, &default_sview_config, sizeof(sview_config_t));
gtk_window_set_default(GTK_WINDOW(popup), label);
gtk_dialog_add_button(GTK_DIALOG(popup),
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL);
/*
for(i=0;; i++) {
if (main_popup_positioner[i].width == -1)
break;
if (strstr("Sview Defaults", main_popup_positioner[i].name)) {
pos_x = main_popup_positioner[i].width;
pos_y = main_popup_positioner[i].height;
break;
}
}
*/
gtk_window_set_default_size(GTK_WINDOW(popup), width, height);
snprintf(tmp_char, sizeof(tmp_char),
"Default Settings for Sview");
label = gtk_label_new(tmp_char);
gtk_scrolled_window_set_policy(window,
GTK_POLICY_NEVER,
GTK_POLICY_AUTOMATIC);
bin = GTK_BIN(&window->container);
view = GTK_VIEWPORT(bin->child);
bin = GTK_BIN(&view->bin);
table = GTK_TABLE(bin->child);
gtk_table_resize(table, SORTID_CNT, 2);
gtk_table_set_homogeneous(table, FALSE);
for (i = 0; i < SORTID_CNT; i++) {
while (display_data++) {
if (display_data->id == -1)
break;
if (!display_data->name)
continue;
if (display_data->id != i)
continue;
_local_display_admin_edit(
table, &tmp_config, &row,
display_data);
break;
}
display_data = display_data_defaults;
}
gtk_table_resize(table, row, 2);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(popup)->vbox),
label, FALSE, FALSE, 0);
if (window)
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(popup)->vbox),
GTK_WIDGET(window), TRUE, TRUE, 0);
gtk_widget_show_all(popup);
response = gtk_dialog_run (GTK_DIALOG(popup));
if (response == GTK_RESPONSE_OK) {
tmp_char_ptr = g_strdup_printf(
"Defaults updated successfully");
if (global_edit_error)
tmp_char_ptr = global_edit_error_msg;
else if (!global_send_update_msg)
tmp_char_ptr = g_strdup_printf(
"No change detected.");
else {
int action = 0;
gdk_window_set_cursor(main_window->window,
in_process_cursor);
if (tmp_config.ruled_treeview
!= working_sview_config.ruled_treeview) {
/* get rid of each existing table */
cluster_change_block();
cluster_change_resv();
cluster_change_part();
cluster_change_job();
cluster_change_node();
cluster_change_front_end();
} else if (tmp_config.grid_topological !=
working_sview_config.grid_topological) {
apply_hidden_change = FALSE;
if (tmp_config.grid_topological) {
default_sview_config.grid_topological =
tmp_config.grid_topological;
if (!g_switch_nodes_maps)
rc = get_topo_conf();
if (rc != SLURM_SUCCESS) {
/*denied*/
tmp_char_ptr = g_strdup_printf(
"Valid topology not "
"detected");
tmp_config.grid_topological =
FALSE;
goto denied_change;
}
}
/*force fresh grid and
* node state check
* */
FREE_NULL_LIST(grid_button_list);
slurm_free_node_info_msg(g_node_info_ptr);
g_node_info_ptr = NULL;
}
/*apply change*/
memcpy(&default_sview_config, &tmp_config,
sizeof(sview_config_t));
memcpy(&working_sview_config, &tmp_config,
sizeof(sview_config_t));
/* set the current display to the default */
gtk_toggle_action_set_active(
default_sview_config.action_admin,
working_sview_config.admin_mode);
gtk_toggle_action_set_active(
default_sview_config.action_ruled,
working_sview_config.ruled_treeview);
gtk_toggle_action_set_active(
default_sview_config.action_grid,
working_sview_config.show_grid);
gtk_toggle_action_set_active(
default_sview_config.action_hidden,
working_sview_config.show_hidden);
apply_hidden_change = TRUE;
gtk_toggle_action_set_active(
default_sview_config.action_page_opts,
working_sview_config.save_page_opts);
#ifdef GTK2_USE_RADIO_SET
/* Since this value isn't a simple 0->n we
need to translate if we don't have the
newer gtk.
*/
action = working_sview_config.tab_pos;
#else
/* If using older gtk we need to translate the
tab position to that of the position in the
radio list.
*/
action = _trans_tab_pos(working_sview_config.tab_pos);
#endif
sview_radio_action_set_current_value(
default_sview_config.action_tab, action);
for (i=0; i<PAGE_CNT; i++) {
if (main_display_data[i].id == -1)
break;
if (!main_display_data[i].name
|| (i == TAB_PAGE))
continue;
toggle_tab_visiblity(NULL, main_display_data+i);
}
get_system_stats(main_grid_table);
/******************************************/
save_defaults(false);
}
denied_change:
display_edit_note(tmp_char_ptr);
g_free(tmp_char_ptr);
}
global_entry_changed = 0;
gtk_widget_destroy(popup);
if (main_window && main_window->window)
gdk_window_set_cursor(main_window->window, NULL);
return rc;
}
void DoCommandListDlg()
{
command_list_dialog_t dialog;
GtkWindow* window = create_modal_dialog_window(MainFrame_getWindow(), "Mapped Commands", dialog, -1, 400);
GtkAccelGroup* accel = gtk_accel_group_new();
gtk_window_add_accel_group(window, accel);
GtkHBox* hbox = create_dialog_hbox(4, 4);
gtk_container_add(GTK_CONTAINER(window), GTK_WIDGET(hbox));
{
GtkScrolledWindow* scr = create_scrolled_window(GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(scr), TRUE, TRUE, 0);
{
GtkListStore* store = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_STRING);
GtkWidget* view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store));
{
GtkCellRenderer* renderer = gtk_cell_renderer_text_new();
GtkTreeViewColumn* column = gtk_tree_view_column_new_with_attributes("Command", renderer, "text", 0, 0);
gtk_tree_view_append_column(GTK_TREE_VIEW(view), column);
}
{
GtkCellRenderer* renderer = gtk_cell_renderer_text_new();
GtkTreeViewColumn* column = gtk_tree_view_column_new_with_attributes("Key", renderer, "text", 1, 0);
gtk_tree_view_append_column(GTK_TREE_VIEW(view), column);
}
gtk_widget_show(view);
gtk_container_add(GTK_CONTAINER (scr), view);
{
// Initialize dialog
StringOutputStream path(256);
path << SettingsPath_get() << "commandlist.txt";
globalOutputStream() << "Writing the command list to " << path.c_str() << "\n";
class BuildCommandList : public CommandVisitor
{
TextFileOutputStream m_commandList;
GtkListStore* m_store;
public:
BuildCommandList(const char* filename, GtkListStore* store) : m_commandList(filename), m_store(store)
{
}
void visit(const char* name, Accelerator& accelerator)
{
StringOutputStream modifiers;
modifiers << accelerator;
{
GtkTreeIter iter;
gtk_list_store_append(m_store, &iter);
gtk_list_store_set(m_store, &iter, 0, name, 1, modifiers.c_str(), -1);
}
if(!m_commandList.failed())
{
m_commandList << makeLeftJustified(name, 25) << " " << modifiers.c_str() << '\n';
}
}
} visitor(path.c_str(), store);
GlobalShortcuts_foreach(visitor);
}
g_object_unref(G_OBJECT(store));
}
}
GtkVBox* vbox = create_dialog_vbox(4);
gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(vbox), FALSE, FALSE, 0);
{
GtkButton* button = create_modal_dialog_button("Close", dialog.m_close_button);
gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(button), FALSE, FALSE, 0);
widget_make_default(GTK_WIDGET(button));
gtk_widget_grab_focus(GTK_WIDGET(button));
gtk_widget_add_accelerator(GTK_WIDGET(button), "clicked", accel, GDK_Return, (GdkModifierType)0, (GtkAccelFlags)0);
gtk_widget_add_accelerator(GTK_WIDGET(button), "clicked", accel, GDK_Escape, (GdkModifierType)0, (GtkAccelFlags)0);
}
modal_dialog_show(window, dialog);
gtk_widget_destroy(GTK_WIDGET(window));
}
GtkWindow* BuildMenuDialog_construct(ModalDialog& modal, ProjectList& projectList)
{
GtkWindow* window = create_dialog_window(MainFrame_getWindow(), "Build Menu", G_CALLBACK(dialog_delete_callback), &modal, -1, 400);
GtkWidget* buildView = 0;
{
GtkTable* table1 = create_dialog_table(2, 2, 4, 4, 4);
gtk_container_add(GTK_CONTAINER(window), GTK_WIDGET(table1));
{
GtkVBox* vbox = create_dialog_vbox(4);
gtk_table_attach(table1, GTK_WIDGET(vbox), 1, 2, 0, 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (GTK_FILL), 0, 0);
{
GtkButton* button = create_dialog_button("OK", G_CALLBACK(dialog_button_ok), &modal);
gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(button), FALSE, FALSE, 0);
}
{
GtkButton* button = create_dialog_button("Cancel", G_CALLBACK(dialog_button_cancel), &modal);
gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(button), FALSE, FALSE, 0);
}
}
{
GtkFrame* frame = create_dialog_frame("Build menu");
gtk_table_attach(table1, GTK_WIDGET(frame), 0, 1, 0, 1,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0);
{
GtkScrolledWindow* scr = create_scrolled_window(GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC, 4);
gtk_container_add(GTK_CONTAINER(frame), GTK_WIDGET(scr));
{
GtkListStore* store = gtk_list_store_new(1, G_TYPE_STRING);
GtkWidget* view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store));
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(view), FALSE);
GtkCellRenderer* renderer = gtk_cell_renderer_text_new();
object_set_boolean_property(G_OBJECT(renderer), "editable", TRUE);
g_signal_connect(renderer, "edited", G_CALLBACK(project_cell_edited), &projectList);
GtkTreeViewColumn* column = gtk_tree_view_column_new_with_attributes("", renderer, "text", 0, 0);
gtk_tree_view_append_column(GTK_TREE_VIEW(view), column);
GtkTreeSelection* selection = gtk_tree_view_get_selection (GTK_TREE_VIEW(view));
gtk_tree_selection_set_mode(selection, GTK_SELECTION_BROWSE);
gtk_widget_show(view);
buildView = view;
projectList.m_store = store;
gtk_container_add(GTK_CONTAINER (scr), view);
g_signal_connect(G_OBJECT(view), "key_press_event", G_CALLBACK(project_key_press), &projectList);
g_object_unref(G_OBJECT(store));
}
}
}
{
GtkFrame* frame = create_dialog_frame("Commandline");
gtk_table_attach(table1, GTK_WIDGET(frame), 0, 1, 1, 2,
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
(GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0);
{
GtkScrolledWindow* scr = create_scrolled_window(GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC, 4);
gtk_container_add(GTK_CONTAINER(frame), GTK_WIDGET(scr));
{
GtkListStore* store = gtk_list_store_new(1, G_TYPE_STRING);
GtkWidget* view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store));
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(view), FALSE);
GtkCellRenderer* renderer = gtk_cell_renderer_text_new();
object_set_boolean_property(G_OBJECT(renderer), "editable", TRUE);
g_signal_connect(renderer, "edited", G_CALLBACK(commands_cell_edited), store);
GtkTreeViewColumn* column = gtk_tree_view_column_new_with_attributes("", renderer, "text", 0, 0);
gtk_tree_view_append_column(GTK_TREE_VIEW(view), column);
GtkTreeSelection* selection = gtk_tree_view_get_selection (GTK_TREE_VIEW(view));
gtk_tree_selection_set_mode(selection, GTK_SELECTION_BROWSE);
gtk_widget_show(view);
gtk_container_add(GTK_CONTAINER (scr), view);
g_object_unref(G_OBJECT(store));
g_signal_connect(G_OBJECT(view), "key_press_event", G_CALLBACK(commands_key_press), store);
g_signal_connect(G_OBJECT(gtk_tree_view_get_selection(GTK_TREE_VIEW(buildView))), "changed", G_CALLBACK(project_selection_changed), store);
}
}
}
}
BSPCommandList_Construct(projectList.m_store, g_build_project);
return window;
}
