int
main (int argc, char *argv[])
{
GooCanvasItemModel *model;
GdkPixbuf *pixbuf;
/* Initialize GTK+. */
gtk_init (&argc, &argv);
pixbuf = gtk_icon_theme_load_icon (gtk_icon_theme_get_default (),
"dialog-warning", 48, 0, NULL);
model = create_model (pixbuf);
/* Create 2 windows to show off multiple views. */
create_window (model);
#if 1
create_window (model);
#endif
g_object_unref (model);
gtk_main ();
return 0;
}
void fx_search_initialize(FxSearch *search , GtkTreeModel *model
, const char *str , int x , int y)
{
GtkWidget *frame;
search->window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_decorated(GTK_WINDOW(search->window) , FALSE);
gtk_window_set_type_hint(GTK_WINDOW(search->window), GDK_WINDOW_TYPE_HINT_DIALOG);
// gtk_widget_set_name(search->window , "mainwindow");
gtk_window_set_default_size(GTK_WINDOW(search->window) , 240 , 60);
gtk_window_set_skip_taskbar_hint (GTK_WINDOW(search->window), TRUE);
gtk_window_move(GTK_WINDOW(search->window) , x , y);
g_signal_connect(search->window , "focus-out-event"
, GTK_SIGNAL_FUNC(window_focus_out) , search);
frame = gtk_frame_new(NULL);
gtk_frame_set_shadow_type(GTK_FRAME(frame) , GTK_SHADOW_ETCHED_IN);
GtkTreeModel *nmodel = create_model(model , str);
search->view = gtk_tree_view_new_with_model(nmodel);
gtk_widget_set_usize(search->view , 320 , 0);
create_column(search->view , search->fxmain);
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(search->view) , FALSE);
//gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (search->view), TRUE);
gtk_tree_view_set_hover_selection(GTK_TREE_VIEW(search->view) , TRUE);
gtk_container_add(GTK_CONTAINER(search->window) , frame);
gtk_container_add(GTK_CONTAINER(frame) , search->view);
g_signal_connect(search->view , "row-activated" , G_CALLBACK(row_activate_func) , search);
g_signal_connect(search->view , "button-press-event" , G_CALLBACK(button_press_func) , search);
g_signal_connect(search->view , "key-press-event" , G_CALLBACK(key_press_func) , search);
gtk_widget_show_all(search->window);
}
void
table_create (void)
{
GtkWidget *runlevel_table = gst_dialog_get_widget (tool->main_dialog, "services_list");
GtkTreeModel *model;
GtkTreeSelection *selection;
model = create_model ();
gtk_tree_view_set_model (GTK_TREE_VIEW (runlevel_table), model);
g_object_unref (G_OBJECT (model));
add_columns (GTK_TREE_VIEW (runlevel_table));
table_popup_menu_create (GTK_TREE_VIEW (runlevel_table));
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (runlevel_table));
gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE);
}
gboolean update_directory_listing (GtkWidget *widget,
GdkEvent *event,
gpointer data) {
// HTREEITEM hItem[5],rItem;
GtkTreeModel* model;
if(CheckCameraOpen()==FALSE)
return FALSE;
EnableControls(FALSE);
model = create_model();
Log(DEBUGGING, "model created.");
FreeAllocatedFiles(root_directory);
root_directory = NULL;
gtk_tree_view_set_model(GTK_TREE_VIEW(m_directory_tree), GTK_TREE_MODEL(model));
gtk_tree_view_expand_all(GTK_TREE_VIEW(m_directory_tree));
Log(NOTICE, "directory tree created successfully");
EnableControls(TRUE);
return TRUE;
}
static GtkWidget *
RollsTree(const int n, evalcontext * pec, const matchstate * pms)
{
GtkTreeModel *pm;
GtkWidget *ptv;
int i;
GtkCellRenderer *renderer;
static const char *aszColumn[] = {
N_("Roll"),
N_("Move"),
N_("Equity")
};
pm = create_model(n, pec, pms);
if (fInterrupt) {
return NULL;
}
ptv = gtk_tree_view_new_with_model(pm);
g_object_unref(G_OBJECT(pm));
/* add columns */
for (i = 0; i < 3; ++i) {
renderer = gtk_cell_renderer_text_new();
g_object_set(G_OBJECT(renderer), "xalign", 0.0, NULL);
gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(ptv),
-1, gettext(aszColumn[i]), renderer, "text", i, NULL);
}
if (fInterrupt) {
gtk_widget_destroy(ptv);
return NULL;
}
return ptv;
}
/**
* move_row:
* @unused: unused... :-)
* @upwards: a pointer encapsulating TRUE if the row has to be moved upwards, else FALSE
*
* Shifts a row upwards or downwards
*/
static void
move_row (gpointer unused, gpointer upwards)
{
gint pos = get_sel_row_num ();
gboolean up = GPOINTER_TO_INT (upwards);
GtkTreePath *path = gtk_tree_path_new ();
if (pos == (up ? 0 : (grg_entries_n_el () - 1)))
return;
grg_entries_nth (pos);
if (up)
grg_entries_raise ();
else
grg_entries_sink ();
model = create_model ();
gtk_tree_view_set_model (GTK_TREE_VIEW (treeview), model);
gtk_tree_path_append_index (path, pos + (up ? -1 : 1));
gtk_tree_view_set_cursor (GTK_TREE_VIEW (treeview), path, NULL,
FALSE);
gtk_tree_path_free (path);
update_saveable (GRG_SAVE_ACTIVE);
}
bool NeuronFactory::create(std::string model_type, NeuronParams* np, Neuron* &n) {
std::string library_name = getLibraryName(model_type);
void* handle;
if (handles.find(library_name) != handles.end()) {
handle = handles.find(library_name)->second;
} else {
std::cerr << "Unknown Model Type: \"" << model_type << "\"" << std::endl;
return false;
}
// reset errors
dlerror();
// load the symbols
create_t* create_model = (create_t*) dlsym(handle, "create");
const char* dlsym_error = dlerror();
if (dlsym_error) {
std::cerr << "Cannot load symbol create: " << dlsym_error << std::endl;
std::cerr << "This does not appear to be a valid dtnet neuron model library." << std::endl;
return false;
}
// create an instance of the class
n = create_model();
// copy in the parameters pass in if they are not null.
if (np != NULL) n->params = *np;
n->model = model_type;
this->models[n] = library_name;
return true;
}
void run(std::string tree_filename, std::string fasta_filename, std::string model_name) {
Model Mod; // The model
Counts data; // the counts
Parameters Par; // the parameters
std::vector<double> br; // branch lengths
double eps = 1e-8; // The threshold for the EM algorithm.
Parameters Parsim; // used for simulating data.
std::vector<double> brsim; // branch lengths of simulated data.
std::vector<std::vector<double> > Cov; // Covariance matrix
std::vector<double> variances; // The variances
bool simulate;
bool nonident;
std::string parameters_filename;
std::string covariances_filename;
// initialize random number generator with time(0).
random_initialize();
parameters_filename = strip_extension(fasta_filename) + ".dat";
covariances_filename = strip_extension(fasta_filename) + ".cov";
// Creates the pointers to the model-specific functions.
Mod = create_model(model_name);
std::cout << "Model: " << Mod.name << std::endl;
// Reads the tree.
Tree T = read_tree(tree_filename);
// Prints the Tree
std::cout << "Tree:" << std::endl;
print_tree(T);
// Check for possible nonidentifiability issues.
nonident = nonident_warning(T);
// Initialize the parameters for simulation of K81 data for testing
Parsim = create_parameters(T);
if (fasta_filename == ":test") { // if fasta file is :test generate random data.
simulate = true;
// Warn
std::cout << "WARNING: Using simulated data " << std::endl << std::endl;
// Generate random parameters
random_parameters_length(T, Mod, Parsim);
// Simulate the data
data = random_fake_counts(T, 1000, Parsim);
// Prints branch-lengths for future check.
branch_lengths(Parsim, brsim);
std::cout << "Simulated branch lengths:" << std::endl;
print_vector(brsim);
} else { // otherwise read the data
simulate = false;
// Read the counts.
std::cout << "Reading fasta file:" << std::endl;
read_counts(T, data, fasta_filename);
add_pseudocounts(0.01, data);
std::cout << std::endl;
}
// Check whether the data and the tree match.
if (T.nalpha != data.nalpha || T.nleaves != data.nspecies) {
throw std::invalid_argument("The order of the sequences or their number and the phylogenetic tree do not match.");
}
//Par = create_parameters(T);
//print_parameters(Par);
//print_vector(Par.r);
//clock_t
long start_time, end_time;
// Runs the EM algorithm. Par is used as initial parameters.
// After execution, Par contains the MLE computed by the algorithm.
// for local max over multiple iterations
Parameters Parmax = Par;
Model Modmax = Mod;
float likelL = 0.0;
float likelMax = -1000000.0;
float timerec;
float timemax;
int outfiles; //whether to save output
std::cout << "Starting the EM algorithm: " << std::endl;
int s;
int S = 0; //count of cases with neg branches
int iter;
int iterMax;
for (int it_runs = 0; it_runs < 10; it_runs++) {
Par = create_parameters(T);
Mod = create_model(model_name);
std::cout << it_runs << ", " ;
start_time = clock();
std::tie(likelL, iter) = EMalgorithm(T, Mod, Par, data, eps);
end_time = clock();
//print_parameters(Par);
// Choses the best permutation.
guess_permutation(T, Mod, Par);
branch_lengths(Par, br);
//print_vector(br);
s = find_negative(br);
S +=s;
timerec = ((float)end_time - start_time) / CLOCKS_PER_SEC;
//assign the 1st iter time value, inc ase it's the best
if (it_runs == 0){
timemax = timerec;
iterMax = iter;
}
if (likelL > likelMax){
Parmax = Par;
Modmax = Mod;
timemax = timerec;
likelMax = likelL;
iterMax = iter;
}
}
// If parameters are not identifiable, the computation of the covariance matrix will
// fail as the Fisher info matrix will not be invertible.
if (!nonident) {
// Compute the covariance matrix using observed Fisher.
full_MLE_observed_covariance_matrix(T, Modmax, Parmax, data, Cov);
variances.resize(Cov.size());
for(unsigned int i=0; i < Cov.size(); i++) {
variances[i] = Cov[i][i];
}
// OUTPUT Save the sigmas into a file
//save_sigmas_to(covariances_filename, Cov);
}
std::cout << std::endl;
std::cout << "Finished." << std::endl;
std::cout << "Likelihood: " << log_likelihood(T, Parmax, data) << std::endl ;
std::cout << "Time: " << timemax << std::endl << std::endl;
std::cout << "negative branches: " << S << std::endl;
std::cout << "Iter: " << iterMax << std::endl;
//std::cout << "Branch lengths: " << std::endl;
//print_vector(br);
outfiles = 0;
if (!nonident && outfiles) {
std::cout << "Parameter variances: " << std::endl;
print_vector(variances);
}
std::cout << "Newick Tree:" << std::endl;
print_newick_tree(T, br);
// if is a simulation, print the L2 distance !
if (simulate) {
std::cout << "L2 distance: " << parameters_distance(Par, Parsim) << std::endl;
std::cout << "KL divergence: " << KL_divergence(T, Par, Parsim) << std::endl;
std::cout << std::endl;
}
// if it is not a simulation, store the parameters in a file !
if (!simulate && outfiles) {
std::fstream st;
st.precision(15);
st.setf(std::ios::fixed,std::ios::floatfield);
st.open(parameters_filename.c_str(), std::ios::out);
print_parameters(Par, st);
}
}
GtkWidget *
do_tree_store (GtkWidget *do_widget)
{
static GtkWidget *window = NULL;
if (!window)
{
GtkWidget *vbox;
GtkWidget *sw;
GtkWidget *treeview;
GtkTreeModel *model;
/* create window, etc */
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_display (GTK_WINDOW (window),
gtk_widget_get_display (do_widget));
gtk_window_set_title (GTK_WINDOW (window), "Tree Store");
g_signal_connect (window, "destroy",
G_CALLBACK (gtk_widget_destroyed), &window);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 8);
g_object_set (vbox, "margin", 8, NULL);
gtk_container_add (GTK_CONTAINER (window), vbox);
gtk_box_pack_start (GTK_BOX (vbox),
gtk_label_new ("Jonathan's Holiday Card Planning Sheet"));
sw = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw),
GTK_SHADOW_ETCHED_IN);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_box_pack_start (GTK_BOX (vbox), sw);
/* create model */
model = create_model ();
/* create tree view */
treeview = gtk_tree_view_new_with_model (model);
gtk_widget_set_vexpand (treeview, TRUE);
g_object_unref (model);
gtk_tree_selection_set_mode (gtk_tree_view_get_selection (GTK_TREE_VIEW (treeview)),
GTK_SELECTION_MULTIPLE);
add_columns (GTK_TREE_VIEW (treeview));
gtk_container_add (GTK_CONTAINER (sw), treeview);
/* expand all rows after the treeview widget has been realized */
g_signal_connect (treeview, "realize",
G_CALLBACK (gtk_tree_view_expand_all), NULL);
gtk_window_set_default_size (GTK_WINDOW (window), 650, 400);
}
if (!gtk_widget_get_visible (window))
gtk_widget_show (window);
else
gtk_widget_destroy (window);
return window;
}
int
main (int argc, char *argv[])
{
GtkWidget *window;
GtkWidget *box;
GtkWidget *drawing_area;
GtkWidget *button;
GtkWidget *label;
GtkWidget *tooltip_window;
GtkWidget *tooltip_button;
GtkWidget *tree_view;
GtkTreeViewColumn *column;
GtkWidget *text_view;
GtkTextBuffer *buffer;
GtkTextIter iter;
GtkTextTag *tag;
gchar *text, *markup;
gtk_init (&argc, &argv);
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (window), "Tooltips test");
gtk_container_set_border_width (GTK_CONTAINER (window), 10);
g_signal_connect (window, "delete_event",
G_CALLBACK (gtk_main_quit), NULL);
box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 3);
gtk_container_add (GTK_CONTAINER (window), box);
/* A check button using the tooltip-markup property */
button = gtk_check_button_new_with_label ("This one uses the tooltip-markup property");
gtk_widget_set_tooltip_text (button, "Hello, I am a static tooltip.");
gtk_box_pack_start (GTK_BOX (box), button, FALSE, FALSE, 0);
text = gtk_widget_get_tooltip_text (button);
markup = gtk_widget_get_tooltip_markup (button);
g_assert (g_str_equal ("Hello, I am a static tooltip.", text));
g_assert (g_str_equal ("Hello, I am a static tooltip.", markup));
g_free (text); g_free (markup);
/* A check button using the query-tooltip signal */
button = gtk_check_button_new_with_label ("I use the query-tooltip signal");
g_object_set (button, "has-tooltip", TRUE, NULL);
g_signal_connect (button, "query-tooltip",
G_CALLBACK (query_tooltip_cb), NULL);
gtk_box_pack_start (GTK_BOX (box), button, FALSE, FALSE, 0);
/* A label */
button = gtk_label_new ("I am just a label");
gtk_label_set_selectable (GTK_LABEL (button), FALSE);
gtk_widget_set_tooltip_text (button, "Label & and tooltip");
gtk_box_pack_start (GTK_BOX (box), button, FALSE, FALSE, 0);
text = gtk_widget_get_tooltip_text (button);
markup = gtk_widget_get_tooltip_markup (button);
g_assert (g_str_equal ("Label & and tooltip", text));
g_assert (g_str_equal ("Label & and tooltip", markup));
g_free (text); g_free (markup);
/* A selectable label */
button = gtk_label_new ("I am a selectable label");
gtk_label_set_selectable (GTK_LABEL (button), TRUE);
gtk_widget_set_tooltip_markup (button, "<b>Another</b> Label tooltip");
gtk_box_pack_start (GTK_BOX (box), button, FALSE, FALSE, 0);
text = gtk_widget_get_tooltip_text (button);
markup = gtk_widget_get_tooltip_markup (button);
g_assert (g_str_equal ("Another Label tooltip", text));
g_assert (g_str_equal ("<b>Another</b> Label tooltip", markup));
g_free (text); g_free (markup);
/* Another one, with a custom tooltip window */
button = gtk_check_button_new_with_label ("This one has a custom tooltip window!");
gtk_box_pack_start (GTK_BOX (box), button, FALSE, FALSE, 0);
tooltip_window = gtk_window_new (GTK_WINDOW_POPUP);
tooltip_button = gtk_label_new ("blaat!");
gtk_container_add (GTK_CONTAINER (tooltip_window), tooltip_button);
gtk_widget_show (tooltip_button);
gtk_widget_set_tooltip_window (button, GTK_WINDOW (tooltip_window));
g_signal_connect (button, "query-tooltip",
G_CALLBACK (query_tooltip_custom_cb), NULL);
g_object_set (button, "has-tooltip", TRUE, NULL);
/* An insensitive button */
button = gtk_button_new_with_label ("This one is insensitive");
gtk_widget_set_sensitive (button, FALSE);
g_object_set (button, "tooltip-text", "Insensitive!", NULL);
gtk_box_pack_start (GTK_BOX (box), button, FALSE, FALSE, 0);
/* Testcases from Kris without a tree view don't exist. */
tree_view = gtk_tree_view_new_with_model (create_model ());
gtk_widget_set_size_request (tree_view, 200, 240);
gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (tree_view),
0, "Test",
gtk_cell_renderer_text_new (),
"text", 0,
NULL);
g_object_set (tree_view, "has-tooltip", TRUE, NULL);
g_signal_connect (tree_view, "query-tooltip",
G_CALLBACK (query_tooltip_tree_view_cb), NULL);
g_signal_connect (gtk_tree_view_get_selection (GTK_TREE_VIEW (tree_view)),
"changed", G_CALLBACK (selection_changed_cb), tree_view);
/* Set a tooltip on the column */
column = gtk_tree_view_get_column (GTK_TREE_VIEW (tree_view), 0);
gtk_tree_view_column_set_clickable (column, TRUE);
g_object_set (gtk_tree_view_column_get_button (column), "tooltip-text", "Header", NULL);
gtk_box_pack_start (GTK_BOX (box), tree_view, FALSE, FALSE, 2);
/* And a text view for Matthias */
buffer = gtk_text_buffer_new (NULL);
gtk_text_buffer_get_end_iter (buffer, &iter);
gtk_text_buffer_insert (buffer, &iter, "Hello, the text ", -1);
tag = gtk_text_buffer_create_tag (buffer, "bold", NULL);
g_object_set (tag, "weight", PANGO_WEIGHT_BOLD, NULL);
gtk_text_buffer_get_end_iter (buffer, &iter);
gtk_text_buffer_insert_with_tags (buffer, &iter, "in bold", -1, tag, NULL);
gtk_text_buffer_get_end_iter (buffer, &iter);
gtk_text_buffer_insert (buffer, &iter, " has a tooltip!", -1);
text_view = gtk_text_view_new_with_buffer (buffer);
gtk_widget_set_size_request (text_view, 200, 50);
g_object_set (text_view, "has-tooltip", TRUE, NULL);
g_signal_connect (text_view, "query-tooltip",
G_CALLBACK (query_tooltip_text_view_cb), tag);
gtk_box_pack_start (GTK_BOX (box), text_view, FALSE, FALSE, 2);
/* Drawing area */
drawing_area = gtk_drawing_area_new ();
gtk_widget_set_size_request (drawing_area, 320, 240);
g_object_set (drawing_area, "has-tooltip", TRUE, NULL);
g_signal_connect (drawing_area, "draw",
G_CALLBACK (drawing_area_draw), NULL);
g_signal_connect (drawing_area, "query-tooltip",
G_CALLBACK (query_tooltip_drawing_area_cb), NULL);
gtk_box_pack_start (GTK_BOX (box), drawing_area, FALSE, FALSE, 2);
button = gtk_label_new ("Custom tooltip I");
label = gtk_label_new ("See, custom");
g_object_ref_sink (label);
g_object_set (button, "has-tooltip", TRUE, NULL);
g_signal_connect (button, "query-tooltip",
G_CALLBACK (query_tooltip_label_cb), label);
gtk_box_pack_start (GTK_BOX (box), button, FALSE, FALSE, 2);
button = gtk_label_new ("Custom tooltip II");
label = gtk_label_new ("See, custom, too");
g_object_ref_sink (label);
g_object_set (button, "has-tooltip", TRUE, NULL);
gtk_box_pack_start (GTK_BOX (box), button, FALSE, FALSE, 2);
g_signal_connect (button, "query-tooltip",
G_CALLBACK (query_tooltip_label_cb), label);
/* Done! */
gtk_widget_show_all (window);
gtk_main ();
return 0;
}
/* main */
int main(int argc, char *argv[])
{
GtkWidget *window;
GtkWidget *table;
GtkWidget *button;
GtkCellRenderer *cell;
Data data;
/* initialition */
gtk_init(&argc, &argv);
/* main window */
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(window), "GtkComboBox");
gtk_widget_set_size_request(window, 640, 320);
gtk_window_set_resizable(GTK_WINDOW(window), FALSE);
gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
gtk_container_set_border_width(GTK_CONTAINER(window), 10);
g_signal_connect(window, "destroy", G_CALLBACK(gtk_main_quit), NULL);
/* table */
table = gtk_table_new(4, 3, FALSE);
gtk_container_add(GTK_CONTAINER(window), table);
/* create combox box */
data.combo = gtk_combo_box_new();
g_signal_connect(data.combo, "changed", G_CALLBACK(cb_changed), &data);
gtk_table_attach(GTK_TABLE(table), data.combo, 0, 3, 0, 1,
GTK_EXPAND|GTK_FILL, GTK_SHRINK, 0, 0);
/* create data store */
data.store = create_model(&data);
/* add data store to combo box */
gtk_combo_box_set_model(GTK_COMBO_BOX(data.combo), data.store);
g_object_unref(data.store);
/* create pixbuf cell renderer */
cell = gtk_cell_renderer_pixbuf_new();
gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(data.combo), cell, FALSE);
gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(data.combo), cell,
"stock-id", PIXBUF_C,
"visible", PIXBUF_VIS_C,
NULL);
/* create text cell renderer */
cell = gtk_cell_renderer_text_new();
gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(data.combo), cell, FALSE);
gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(data.combo), cell,
"text", TEXT_C,
"visible", TEXT_VIS_C,
"foreground", TEXT_COL_C,
NULL);
/* create progress cell renderer */
cell = gtk_cell_renderer_progress_new();
gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(data.combo), cell, FALSE);
gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(data.combo), cell,
"value", PROGRESS_C,
"visible", PROGRESS_VIS_C,
NULL);
/* create check buttons for controling visibility */
data.vis_pixbuf = gtk_check_button_new_with_label("image visible");
gtk_table_attach(GTK_TABLE(table), data.vis_pixbuf, 0, 1, 1, 2,
GTK_EXPAND|GTK_FILL, GTK_SHRINK, 0, 0);
data.vis_text = gtk_check_button_new_with_label("text visible");
gtk_table_attach(GTK_TABLE(table), data.vis_text, 1, 2, 1, 2,
GTK_EXPAND|GTK_FILL, GTK_SHRINK, 0, 0);
data.vis_progress = gtk_check_button_new_with_label("progress visible");
gtk_table_attach(GTK_TABLE(table), data.vis_progress, 2, 3, 1, 2,
GTK_EXPAND|GTK_FILL, GTK_SHRINK, 0, 0);
/* create entries for modifying values */
data.e_pixbuf = gtk_entry_new();
gtk_table_attach(GTK_TABLE(table), data.e_pixbuf, 0, 1, 2, 3,
GTK_EXPAND|GTK_FILL, GTK_SHRINK, 0, 0);
data.e_text = gtk_entry_new();
gtk_table_attach(GTK_TABLE(table), data.e_text, 1, 2, 2, 3,
GTK_EXPAND|GTK_FILL, GTK_SHRINK, 0, 0);
data.e_progress = gtk_spin_button_new_with_range(0, 100, 1);
gtk_spin_button_set_numeric(GTK_SPIN_BUTTON(data.e_progress), TRUE);
gtk_table_attach(GTK_TABLE(table), data.e_progress, 2, 3, 2, 3,
GTK_EXPAND|GTK_FILL, GTK_SHRINK, 0, 0);
/* create button for applying changes */
button = gtk_button_new_from_stock(GTK_STOCK_APPLY);
g_signal_connect(button, "clicked", G_CALLBACK(cb_clicked), &data);
gtk_table_attach(GTK_TABLE(table), button, 0, 3, 3, 4,
GTK_EXPAND|GTK_FILL, GTK_SHRINK, 0, 0);
/* manually call cb_changed function to set controllers to right state */
cb_changed(GTK_COMBO_BOX(data.combo), &data);
gtk_widget_show_all(window);
gtk_main();
return 0;
}
int main( int argc, char *argv[])
{
gtk_init(&argc, &argv);
//applet_widget_init(PACKAGE, VERSION, argc, argv, NULL, 0, NULL);
GError **error;
GtkWidget *window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
//GtkWidget *view = create_tree();
GtkWidget *vbox = gtk_vbox_new(FALSE, 8);
//GtkWidget *iconbox = gtk_hbox_new(FALSE, 8);
GtkWidget *iconbox = gtk_toolbar_new ();
GdkPixbuf *session_pixbuf;
GtkToolItem *session_icon;
GdkPixbuf *system_pixbuf;
GtkToolItem *system_icon;
GtkWidget *service_name_list = gtk_scrolled_window_new(NULL, NULL);
GtkTreeModel *model;
GtkWidget *treeview;
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
gtk_window_set_title(GTK_WINDOW(window), "DBus-Xray" );
g_signal_connect (window, "destroy", G_CALLBACK (gtk_widget_destroyed), &window);
gtk_container_set_border_width (GTK_CONTAINER (window), 8);
gtk_container_add (GTK_CONTAINER (window), vbox);
gtk_box_pack_start(GTK_BOX(vbox), gtk_label_new( "System and Session Service Name List") , FALSE, FALSE, 0);
session_icon = gtk_tool_button_new( NULL, "Session List" );
gtk_tool_button_set_icon_name( GTK_TOOL_BUTTON( session_icon ), "config-users" );
system_icon = gtk_tool_button_new( NULL, "System List" );
gtk_tool_button_set_icon_name( GTK_TOOL_BUTTON( session_icon ), "ksysguard" );
gtk_toolbar_insert (GTK_TOOLBAR (iconbox), system_icon , -1);
gtk_toolbar_insert (GTK_TOOLBAR (iconbox), session_icon , -1);
gtk_box_pack_start(GTK_BOX(vbox), iconbox , FALSE, FALSE, 0);
//gtk_box_pack_start(GTK_BOX(iconbox), gtk_icon_new("system"), FALSE, FALSE, 0);
//gtk_box_pack_start(GTK_BOX(iconbox), gtk_icon_new("session"), FALSE, FALSE, 0);
// need to update to non-fix path search
//session_pixbuf = gdk_pixbuf_new_from_file ("/usr/share/icons/Tango/scalable/apps/system-users.svg", error);
//system_pixbuf = gdk_pixbuf_new_from_file ("/usr/share/icons/Tango/scalable/apps/ksysguard.svg", error);
//gtk_box_pack_start(GTK_BOX(vbox), service_name_list, FALSE, FALSE, 0);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (service_name_list), GTK_SHADOW_ETCHED_IN);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (service_name_list), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
gtk_box_pack_start (GTK_BOX (vbox), service_name_list , TRUE, TRUE, 0);
/* create tree model */
model = create_model ();
/* create tree view */
treeview = gtk_tree_view_new_with_model (model);
gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (treeview), TRUE);
//gtk_tree_view_set_search_column (GTK_TREE_VIEW (treeview), COLUMN_DESCRIPTION);
// g_object_unref (model);
gtk_container_add (GTK_CONTAINER (service_name_list), treeview);
/* column for fixed toggles */
renderer = gtk_cell_renderer_text_new ();
//g_signal_connect (renderer, "toggled", G_CALLBACK (fixed_toggled), model);
column = gtk_tree_view_column_new_with_attributes ("Index",
renderer,
"text", INDEX,
NULL);
gtk_tree_view_column_set_sizing (GTK_TREE_VIEW_COLUMN (column),
GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_column_set_fixed_width (GTK_TREE_VIEW_COLUMN (column), 100);
gtk_tree_view_append_column (treeview, column);
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("Service Name",
renderer,
"text",
SERVICE_NAME,
NULL);
gtk_tree_view_column_set_sort_column_id (column, SERVICE_NAME );
gtk_tree_view_append_column (treeview, column);
gtk_widget_show_all(window);
gtk_main();
return 0;
}
GtkWidget *
do_tree_store (GtkWidget *do_widget)
{
if (!window)
{
GtkWidget *vbox;
GtkWidget *sw;
GtkWidget *treeview;
GtkTreeModel *model;
/* create window, etc */
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_screen (GTK_WINDOW (window),
gtk_widget_get_screen (do_widget));
gtk_window_set_title (GTK_WINDOW (window), "Card planning sheet");
g_signal_connect (window, "destroy",
G_CALLBACK (gtk_widget_destroyed), &window);
vbox = gtk_vbox_new (FALSE, 8);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 8);
gtk_container_add (GTK_CONTAINER (window), vbox);
gtk_box_pack_start (GTK_BOX (vbox),
gtk_label_new ("Jonathan's Holiday Card Planning Sheet"),
FALSE, FALSE, 0);
sw = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw),
GTK_SHADOW_ETCHED_IN);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_box_pack_start (GTK_BOX (vbox), sw, TRUE, TRUE, 0);
/* create model */
model = create_model ();
/* create tree view */
treeview = gtk_tree_view_new_with_model (model);
g_object_unref (model);
gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (treeview), TRUE);
gtk_tree_selection_set_mode (gtk_tree_view_get_selection (GTK_TREE_VIEW (treeview)),
GTK_SELECTION_MULTIPLE);
add_columns (GTK_TREE_VIEW (treeview));
gtk_container_add (GTK_CONTAINER (sw), treeview);
/* expand all rows after the treeview widget has been realized */
g_signal_connect (treeview, "realize",
G_CALLBACK (gtk_tree_view_expand_all), NULL);
gtk_window_set_default_size (GTK_WINDOW (window), 650, 400);
}
if (!GTK_WIDGET_VISIBLE (window))
gtk_widget_show_all (window);
else
{
gtk_widget_destroy (window);
window = NULL;
}
return window;
}
/* The main GUI function for saving multi-paged PDFs */
static gboolean
gui_multi (void)
{
GtkWidget *window;
GtkWidget *vbox;
GtkWidget *file_label;
GtkWidget *file_entry;
GtkWidget *file_browse;
GtkWidget *file_hbox;
GtkWidget *vectorize_c;
GtkWidget *ignore_hidden_c;
GtkWidget *apply_c;
GtkWidget *scroll;
GtkWidget *page_view;
GtkWidget *h_but_box;
GtkWidget *del;
GtkWidget *h_box;
GtkWidget *img_combo;
GtkWidget *add_image;
gboolean run;
const gchar *temp;
gimp_ui_init (PLUG_IN_BINARY, FALSE);
window = gimp_export_dialog_new ("PDF", PLUG_IN_ROLE, SAVE_MULTI_PROC);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10);
gtk_box_pack_start (GTK_BOX (gimp_export_dialog_get_content_area (window)),
vbox, TRUE, TRUE, 0);
gtk_container_set_border_width (GTK_CONTAINER (window), 12);
file_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 5);
file_label = gtk_label_new (_("Save to:"));
file_entry = gtk_entry_new ();
if (file_name != NULL)
gtk_entry_set_text (GTK_ENTRY (file_entry), file_name);
file_browse = gtk_button_new_with_label (_("Browse..."));
file_choose = gtk_file_chooser_dialog_new (_("Multipage PDF export"),
GTK_WINDOW (window), GTK_FILE_CHOOSER_ACTION_SAVE,
"gtk-save", GTK_RESPONSE_OK,
"gtk-cancel", GTK_RESPONSE_CANCEL,
NULL);
gtk_box_pack_start (GTK_BOX (file_hbox), file_label, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (file_hbox), file_entry, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (file_hbox), file_browse, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox), file_hbox, TRUE, TRUE, 0);
page_view = gtk_icon_view_new ();
model = create_model ();
gtk_icon_view_set_model (GTK_ICON_VIEW (page_view), model);
gtk_icon_view_set_reorderable (GTK_ICON_VIEW (page_view), TRUE);
gtk_icon_view_set_selection_mode (GTK_ICON_VIEW (page_view), GTK_SELECTION_MULTIPLE);
gtk_icon_view_set_pixbuf_column (GTK_ICON_VIEW (page_view), THUMB);
gtk_icon_view_set_text_column (GTK_ICON_VIEW (page_view), PAGE_NUMBER);
gtk_icon_view_set_tooltip_column (GTK_ICON_VIEW (page_view), IMAGE_NAME);
scroll = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_set_size_request (scroll, -1, 300);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll), GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
gtk_container_add (GTK_CONTAINER (scroll), page_view);
gtk_box_pack_start (GTK_BOX (vbox), scroll, TRUE, TRUE, 0);
h_but_box = gtk_button_box_new (GTK_ORIENTATION_HORIZONTAL);
gtk_button_box_set_layout (GTK_BUTTON_BOX (h_but_box), GTK_BUTTONBOX_START);
del = gtk_button_new_with_label (_("Remove the selected pages"));
gtk_box_pack_start (GTK_BOX (h_but_box), del, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (vbox), h_but_box, FALSE, FALSE, 0);
h_box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 5);
img_combo = gimp_image_combo_box_new (NULL, NULL);
gtk_box_pack_start (GTK_BOX (h_box), img_combo, FALSE, FALSE, 0);
add_image = gtk_button_new_with_label (_("Add this image"));
gtk_box_pack_start (GTK_BOX (h_box), add_image, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox), h_box, FALSE, FALSE, 0);
ignore_hidden_c = gtk_check_button_new_with_label (_("Omit hidden layers and layers with zero opacity"));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (ignore_hidden_c), optimize.ignore_hidden);
gtk_box_pack_end (GTK_BOX (vbox), ignore_hidden_c, FALSE, FALSE, 0);
vectorize_c = gtk_check_button_new_with_label (_("Convert bitmaps to vector graphics where possible"));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (vectorize_c), optimize.vectorize);
gtk_box_pack_end (GTK_BOX (vbox), vectorize_c, FALSE, FALSE, 0);
apply_c = gtk_check_button_new_with_label (_("Apply layer masks before saving"));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (apply_c), optimize.apply_masks);
gtk_box_pack_end (GTK_BOX (vbox), apply_c, FALSE, FALSE, 0);
gimp_help_set_help_data (apply_c, _("Keeping the masks will not change the output"), NULL);
gtk_widget_show_all (window);
g_signal_connect (G_OBJECT (file_browse), "clicked",
G_CALLBACK (choose_file_call), G_OBJECT (file_entry));
g_signal_connect (G_OBJECT (add_image), "clicked",
G_CALLBACK (add_image_call), G_OBJECT (img_combo));
g_signal_connect (G_OBJECT (del), "clicked",
G_CALLBACK (del_image_call), G_OBJECT (page_view));
g_signal_connect (G_OBJECT (model), "row-deleted",
G_CALLBACK (remove_call), NULL);
run = gtk_dialog_run (GTK_DIALOG (window)) == GTK_RESPONSE_OK;
run &= get_image_list ();
temp = gtk_entry_get_text (GTK_ENTRY (file_entry));
g_stpcpy (file_name, temp);
optimize.ignore_hidden = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (ignore_hidden_c));
optimize.vectorize = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (vectorize_c));
optimize.apply_masks = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (apply_c));
gtk_widget_destroy (window);
return run;
}
int
main (int argc, char **argv)
{
int i;
GtkWidget *window;
GtkWidget *vbox;
GtkWidget *combo_box;
GtkWidget *sw;
GtkWidget *tree_view;
GtkWidget *button;
gtk_init (&argc, &argv);
/* Window and box */
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_default_size (GTK_WINDOW (window), 640, 480);
g_signal_connect (window, "delete-event", G_CALLBACK (gtk_main_quit), NULL);
gtk_container_set_border_width (GTK_CONTAINER (window), 5);
vbox = gtk_vbox_new (FALSE, 5);
gtk_container_add (GTK_CONTAINER (window), vbox);
/* Option menu contents */
combo_box = gtk_combo_box_text_new ();
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo_box), NO_EXPAND);
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo_box), SINGLE_EXPAND);
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo_box), MULTI_EXPAND);
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo_box), LAST_EXPAND);
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo_box), BORDER_EXPAND);
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo_box), ALL_EXPAND);
gtk_box_pack_start (GTK_BOX (vbox), combo_box, FALSE, FALSE, 0);
/* Scrolled window and tree view */
sw = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_box_pack_start (GTK_BOX (vbox), sw, TRUE, TRUE, 0);
tree_view = gtk_tree_view_new_with_model (create_model ());
gtk_container_add (GTK_CONTAINER (sw), tree_view);
for (i = 0; i < 5; i++)
{
GtkTreeViewColumn *column;
gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (tree_view),
i, "Header",
gtk_cell_renderer_text_new (),
"text", i,
NULL);
column = gtk_tree_view_get_column (GTK_TREE_VIEW (tree_view), i);
gtk_tree_view_column_set_resizable (column, TRUE);
}
/* Toggle button for long content row */
button = gtk_toggle_button_new_with_label ("Toggle long content row");
g_signal_connect (button, "toggled",
G_CALLBACK (toggle_long_content_row), tree_view);
gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
/* Set up option menu callback and default item */
g_signal_connect (combo_box, "changed",
G_CALLBACK (combo_box_changed), tree_view);
gtk_combo_box_set_active (GTK_COMBO_BOX (combo_box), 0);
/* Done */
gtk_widget_show_all (window);
gtk_main ();
return 0;
}
/* sets up a fixture with a model with varying row heights */
static void
scroll_fixture_mixed_setup (ScrollFixture *fixture,
gconstpointer test_data)
{
scroll_fixture_setup (fixture, create_model (FALSE), test_data);
}
npc model_npc;
model_npc.normalize();
model_npc.randomize();
model_npc.set_hunger( 0 );
model_npc.thirst = 0;
model_npc.fatigue = 0;
model_npc.remove_effect( "sleep" );
// An ugly hack to prevent NPC falling asleep during testing due to massive fatigue
model_npc.set_mutation( "WEB_WEAVER" );
return model_npc;
}
TEST_CASE("on_load-sane-values")
{
npc model_npc = create_model();
SECTION("Awake for 10 minutes, gaining hunger/thirst/fatigue") {
npc test_npc = model_npc;
const int five_min_ticks = 2;
on_load_test( test_npc, 0, MINUTES(5 * five_min_ticks) );
const int margin = 1;
CHECK( test_npc.get_hunger() <= five_min_ticks + margin );
CHECK( test_npc.thirst <= five_min_ticks + margin );
CHECK( test_npc.fatigue <= five_min_ticks + margin );
CHECK( test_npc.get_hunger() >= five_min_ticks - margin );
CHECK( test_npc.thirst >= five_min_ticks - margin );
CHECK( test_npc.fatigue >= five_min_ticks - margin );
}
gint
main (gint argc, gchar **argv)
{
GtkWidget *paned, *tv;
GtkWidget *window, *icon_list, *scrolled_window;
GtkWidget *vbox, *bbox;
GtkWidget *button;
GtkWidget *prop_editor;
GtkTreeModel *model;
GtkCellRenderer *cell;
GtkTreeViewColumn *tvc;
gtk_init (&argc, &argv);
/* to test rtl layout, set RTL=1 in the environment */
if (g_getenv ("RTL"))
gtk_widget_set_default_direction (GTK_TEXT_DIR_RTL);
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_default_size (GTK_WINDOW (window), 700, 400);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_container_add (GTK_CONTAINER (window), vbox);
paned = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL);
gtk_box_pack_start (GTK_BOX (vbox), paned, TRUE, TRUE, 0);
icon_list = gtk_icon_view_new ();
gtk_icon_view_set_selection_mode (GTK_ICON_VIEW (icon_list), GTK_SELECTION_MULTIPLE);
tv = gtk_tree_view_new ();
tvc = gtk_tree_view_column_new ();
gtk_tree_view_append_column (GTK_TREE_VIEW (tv), tvc);
g_signal_connect_after (icon_list, "button_press_event",
G_CALLBACK (button_press_event_handler), NULL);
g_signal_connect (icon_list, "selection_changed",
G_CALLBACK (selection_changed), NULL);
g_signal_connect (icon_list, "popup_menu",
G_CALLBACK (popup_menu_handler), NULL);
g_signal_connect (icon_list, "item_activated",
G_CALLBACK (item_activated), NULL);
model = create_model ();
gtk_icon_view_set_model (GTK_ICON_VIEW (icon_list), model);
gtk_tree_view_set_model (GTK_TREE_VIEW (tv), model);
fill_model (model);
#if 0
gtk_icon_view_set_pixbuf_column (GTK_ICON_VIEW (icon_list), 0);
gtk_icon_view_set_text_column (GTK_ICON_VIEW (icon_list), 1);
#else
cell = gtk_cell_renderer_toggle_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (icon_list), cell, FALSE);
g_object_set (cell, "activatable", TRUE, NULL);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (icon_list),
cell, "active", 4, NULL);
g_signal_connect (cell, "toggled", G_CALLBACK (toggled), model);
cell = gtk_cell_renderer_pixbuf_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (icon_list), cell, FALSE);
g_object_set (cell,
"follow-state", TRUE,
NULL);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (icon_list),
cell, "pixbuf", 0, NULL);
cell = gtk_cell_renderer_text_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (icon_list), cell, FALSE);
g_object_set (cell,
"editable", TRUE,
"xalign", 0.5,
"wrap-mode", PANGO_WRAP_WORD_CHAR,
"wrap-width", 100,
NULL);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (icon_list),
cell, "text", 1, NULL);
g_signal_connect (cell, "edited", G_CALLBACK (edited), model);
/* now the tree view... */
cell = gtk_cell_renderer_toggle_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (tvc), cell, FALSE);
g_object_set (cell, "activatable", TRUE, NULL);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (tvc),
cell, "active", 4, NULL);
g_signal_connect (cell, "toggled", G_CALLBACK (toggled), model);
cell = gtk_cell_renderer_pixbuf_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (tvc), cell, FALSE);
g_object_set (cell,
"follow-state", TRUE,
NULL);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (tvc),
cell, "pixbuf", 0, NULL);
cell = gtk_cell_renderer_text_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (tvc), cell, FALSE);
g_object_set (cell, "editable", TRUE, NULL);
gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (tvc),
cell, "text", 1, NULL);
g_signal_connect (cell, "edited", G_CALLBACK (edited), model);
#endif
/* Allow DND between the icon view and the tree view */
gtk_icon_view_enable_model_drag_source (GTK_ICON_VIEW (icon_list),
GDK_BUTTON1_MASK,
item_targets,
G_N_ELEMENTS (item_targets),
GDK_ACTION_MOVE);
gtk_icon_view_enable_model_drag_dest (GTK_ICON_VIEW (icon_list),
item_targets,
G_N_ELEMENTS (item_targets),
GDK_ACTION_MOVE);
gtk_tree_view_enable_model_drag_source (GTK_TREE_VIEW (tv),
GDK_BUTTON1_MASK,
item_targets,
G_N_ELEMENTS (item_targets),
GDK_ACTION_MOVE);
gtk_tree_view_enable_model_drag_dest (GTK_TREE_VIEW (tv),
item_targets,
G_N_ELEMENTS (item_targets),
GDK_ACTION_MOVE);
prop_editor = create_prop_editor (G_OBJECT (icon_list), 0);
gtk_widget_show_all (prop_editor);
scrolled_window = gtk_scrolled_window_new (NULL, NULL);
gtk_container_add (GTK_CONTAINER (scrolled_window), icon_list);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_paned_add1 (GTK_PANED (paned), scrolled_window);
scrolled_window = gtk_scrolled_window_new (NULL, NULL);
gtk_container_add (GTK_CONTAINER (scrolled_window), tv);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_paned_add2 (GTK_PANED (paned), scrolled_window);
bbox = gtk_button_box_new (GTK_ORIENTATION_HORIZONTAL);
gtk_button_box_set_layout (GTK_BUTTON_BOX (bbox), GTK_BUTTONBOX_START);
gtk_box_pack_start (GTK_BOX (vbox), bbox, FALSE, FALSE, 0);
button = gtk_button_new_with_label ("Add some");
g_signal_connect (button, "clicked", G_CALLBACK (add_some), icon_list);
gtk_box_pack_start (GTK_BOX (bbox), button, TRUE, TRUE, 0);
button = gtk_button_new_with_label ("Add many");
g_signal_connect (button, "clicked", G_CALLBACK (add_many), icon_list);
gtk_box_pack_start (GTK_BOX (bbox), button, TRUE, TRUE, 0);
button = gtk_button_new_with_label ("Add large");
g_signal_connect (button, "clicked", G_CALLBACK (add_large), icon_list);
gtk_box_pack_start (GTK_BOX (bbox), button, TRUE, TRUE, 0);
button = gtk_button_new_with_label ("Remove selected");
g_signal_connect (button, "clicked", G_CALLBACK (foreach_selected_remove), icon_list);
gtk_box_pack_start (GTK_BOX (bbox), button, TRUE, TRUE, 0);
button = gtk_button_new_with_label ("Swap");
g_signal_connect (button, "clicked", G_CALLBACK (swap_rows), icon_list);
gtk_box_pack_start (GTK_BOX (bbox), button, TRUE, TRUE, 0);
bbox = gtk_button_box_new (GTK_ORIENTATION_HORIZONTAL);
gtk_button_box_set_layout (GTK_BUTTON_BOX (bbox), GTK_BUTTONBOX_START);
gtk_box_pack_start (GTK_BOX (vbox), bbox, FALSE, FALSE, 0);
button = gtk_button_new_with_label ("Select all");
g_signal_connect (button, "clicked", G_CALLBACK (select_all), icon_list);
gtk_box_pack_start (GTK_BOX (bbox), button, TRUE, TRUE, 0);
button = gtk_button_new_with_label ("Unselect all");
g_signal_connect (button, "clicked", G_CALLBACK (unselect_all), icon_list);
gtk_box_pack_start (GTK_BOX (bbox), button, TRUE, TRUE, 0);
button = gtk_button_new_with_label ("Select nonexisting");
g_signal_connect (button, "clicked", G_CALLBACK (select_nonexisting), icon_list);
gtk_box_pack_start (GTK_BOX (bbox), button, TRUE, TRUE, 0);
icon_list = gtk_icon_view_new ();
scrolled_window = gtk_scrolled_window_new (NULL, NULL);
gtk_container_add (GTK_CONTAINER (scrolled_window), icon_list);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_paned_add2 (GTK_PANED (paned), scrolled_window);
gtk_widget_show_all (window);
gtk_main ();
return 0;
}
gint
main (gint argc, gchar **argv)
{
GtkWidget *window;
GtkWidget *scrolled_window;
GtkWidget *tree_view;
GtkTreeModel *tree_model;
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
GtkCellArea *area;
gtk_init (&argc, &argv);
if (g_getenv ("RTL"))
gtk_widget_set_default_direction (GTK_TEXT_DIR_RTL);
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (window), "Vertical cells in GtkTreeViewColumn example");
g_signal_connect (window, "destroy", gtk_main_quit, NULL);
scrolled_window = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled_window), GTK_SHADOW_ETCHED_IN);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_container_add (GTK_CONTAINER (window), scrolled_window);
tree_model = create_model ();
tree_view = gtk_tree_view_new_with_model (tree_model);
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (tree_view), FALSE);
/* First column */
column = gtk_tree_view_column_new ();
renderer = gtk_cell_renderer_pixbuf_new ();
g_object_set (renderer, "stock-size", GTK_ICON_SIZE_DIALOG, NULL);
gtk_tree_view_column_pack_start (column, renderer, TRUE);
gtk_tree_view_column_set_attributes (column, renderer,
"stock-id", ICON_COLUMN, NULL);
renderer = gtk_cell_renderer_text_new ();
g_object_set (renderer, "scale", 1.2F, "weight", PANGO_WEIGHT_BOLD, NULL);
gtk_tree_view_column_pack_start (column, renderer, TRUE);
gtk_tree_view_column_set_attributes (column, renderer,
"text", INFO_COLUMN,
NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), column);
/* Second (vertical) column */
column = gtk_tree_view_column_new ();
area = gtk_cell_layout_get_area (GTK_CELL_LAYOUT (column));
gtk_orientable_set_orientation (GTK_ORIENTABLE (area), GTK_ORIENTATION_VERTICAL);
renderer = gtk_cell_renderer_text_new ();
g_object_set (renderer, "ellipsize", PANGO_ELLIPSIZE_END, "editable", TRUE, NULL);
gtk_tree_view_column_pack_start (column, renderer, TRUE);
gtk_tree_view_column_set_attributes (column, renderer,
"text", DESCRIPTION_COLUMN,
NULL);
renderer = gtk_cell_renderer_progress_new ();
gtk_tree_view_column_pack_start (column, renderer, TRUE);
gtk_tree_view_column_set_attributes (column, renderer,
"value", PROGRESS_COLUMN,
NULL);
renderer = gtk_cell_renderer_text_new ();
g_object_set (renderer, "scale", 0.6F, "ellipsize", PANGO_ELLIPSIZE_END, NULL);
gtk_tree_view_column_pack_start (column, renderer, TRUE);
gtk_tree_view_column_set_attributes (column, renderer,
"text", FINE_PRINT_COLUMN,
"foreground", FINE_PRINT_COLOR_COLUMN,
NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), column);
gtk_tree_view_expand_all (GTK_TREE_VIEW (tree_view));
gtk_container_add (GTK_CONTAINER (scrolled_window), tree_view);
gtk_window_set_default_size (GTK_WINDOW (window),
800, 400);
gtk_widget_show_all (window);
gtk_main ();
return 0;
}
static void
run_logged_in_dialogue (char **vec)
{
GtkWidget *dialog;
GtkWidget *vbox;
GtkWidget *w;
GtkWidget *sw;
GtkTreeModel *model;
GtkWidget *treeview;
GtkTreeIter iter;
GtkTreeSelection *selection;
gint response;
if (startnew == TRUE) {
/* Just return if the user doesn't want to see the dialog */
return;
}
dialog = gtk_dialog_new_with_buttons (_("Open Displays"),
NULL /* parent */,
0 /* flags */,
_("_Open New Display"),
RESPONSE_OPEN_NEW_DISPLAY,
_("Change to _Existing Display"),
RESPONSE_OPEN_EXISTING_DISPLAY,
GTK_STOCK_CANCEL,
GTK_RESPONSE_CANCEL,
NULL);
gtk_dialog_set_has_separator (GTK_DIALOG (dialog), FALSE);
vbox = GTK_DIALOG (dialog)->vbox;
w = gtk_label_new (_("There are some displays already open. You can select "
"one from the list below or open a new one."));
gtk_box_pack_start (GTK_BOX (vbox), w, FALSE, FALSE, 0);
sw = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw),
GTK_SHADOW_ETCHED_IN);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
GTK_POLICY_NEVER,
GTK_POLICY_AUTOMATIC);
gtk_box_pack_start (GTK_BOX (vbox), sw, TRUE, TRUE, 0);
/* create tree model */
model = create_model (vec);
/* create tree view */
treeview = gtk_tree_view_new_with_model (model);
gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (treeview), TRUE);
g_object_unref (model);
gtk_container_add (GTK_CONTAINER (sw), treeview);
/* add columns to the tree view */
add_columns (GTK_TREE_VIEW (treeview));
/* finish & show */
gtk_window_set_default_size (GTK_WINDOW (dialog), 280, 250);
g_signal_connect (G_OBJECT (treeview), "row_activated",
G_CALLBACK (row_activated),
dialog);
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (treeview));
g_signal_connect (selection, "changed",
G_CALLBACK (selection_changed),
dialog);
gtk_dialog_set_response_sensitive (GTK_DIALOG (dialog),
RESPONSE_OPEN_EXISTING_DISPLAY,
FALSE);
gtk_widget_show_all (dialog);
response = gtk_dialog_run (GTK_DIALOG (dialog));
run_again:
switch (response) {
case RESPONSE_OPEN_NEW_DISPLAY:
gtk_widget_destroy (dialog);
/* just continue what you are doing */
return;
case RESPONSE_OPEN_EXISTING_DISPLAY:
if (gtk_tree_selection_get_selected (selection, NULL, &iter)) {
GValue value = {0};
int vt;
gtk_tree_model_get_value (model, &iter,
COLUMN_VT,
&value);
vt = g_value_get_int (&value);
g_value_unset (&value);
/* we switched to a different screen as a result of this,
* lock the current screen */
if ( ! no_lock && vt != get_cur_vt () && vt >= 0) {
maybe_lock_screen ();
}
change_vt (vt);
/* FIXME: wait + disturb the pointer (need SUP?),
* perhaps part of the sup command to CHVT ?? */
exit (0);
} else {
/* EEK */
goto run_again;
}
break;
default:
gtk_widget_destroy (dialog);
/* cancel, or close */
exit (0);
break;
}
}
/**
* Decodes the configuration node into a compound.
*
* @param p0 the destination (internals memory) (Hand over as reference!)
* @param p1 the destination count
* @param p2 the destination size
* @param p3 the source (libxml2 xml node)
* @param p4 the source count
*/
void decode_configuration_node(void* p0, void* p1, void* p2, const void* p3, const void* p4) {
if (p3 != NULL_POINTER) {
xmlNode* s = (xmlNode*) p3;
if (p0 != NULL_POINTER) {
void** d = (void**) p0;
if (s != NULL_POINTER) {
log_message_debug("Decode configuration node.");
// Determine first child node.
xmlNode* c = s->children;
// The source name.
void* sn = NULL_POINTER;
int snc = 0;
// The source channel.
void* sc = NULL_POINTER;
int scc = 0;
// The source abstraction.
void* sa = NULL_POINTER;
int sac = 0;
// The source model.
void* sm = NULL_POINTER;
int smc = 0;
// The destination model.
void* dm = NULL_POINTER;
int* dmc = INTEGER_NULL_POINTER;
int* dms = INTEGER_NULL_POINTER;
// The comparison result.
int r = 0;
while (1) {
if (c == NULL_POINTER) {
break;
}
if (c->type == XML_ELEMENT_NODE) {
// Decode child node properties.
decode_cybol_property(
(void*) &sn, (void*) &snc, (void*) &sc, (void*) &scc,
(void*) &sa, (void*) &sac, (void*) &sm, (void*) &smc,
(void*) c);
fprintf(stderr, "sn: %s\n", (char*) sn);
fprintf(stderr, "snc: %i\n", snc);
fprintf(stderr, "sc: %s\n", (char*) sc);
fprintf(stderr, "scc: %i\n", scc);
fprintf(stderr, "sa: %s\n", (char*) sa);
fprintf(stderr, "sac: %i\n", sac);
fprintf(stderr, "sm: %s\n", (char*) sm);
fprintf(stderr, "smc: %i\n", smc);
if (r != 1) {
compare_arrays(sn, (void*) &snc, (void*) STARTUP_CHANNEL_CONFIGURATION_NAME, (void*) STARTUP_CHANNEL_CONFIGURATION_NAME_COUNT, (void*) &r, (void*) CHARACTER_ARRAY);
if (r == 1) {
log_message_debug("Found startup channel configuration name.");
// Create destination model.
create_integer((void*) &dmc);
*dmc = 0;
create_integer((void*) &dms);
*dms = 0;
create_model((void*) &dm, (void*) dmc, (void*) dms,
sm, (void*) &smc,
sa, (void*) &sac,
sc, (void*) &scc);
// Set configuration parameter in internals memory.
set_array_elements(*d, (void*) STARTUP_CHANNEL_INTERNAL, (void*) &dm, (void*) ONE_NUMBER, (void*) POINTER_ARRAY);
set_array_elements(*d, (void*) STARTUP_CHANNEL_COUNT_INTERNAL, (void*) &dmc, (void*) ONE_NUMBER, (void*) POINTER_ARRAY);
set_array_elements(*d, (void*) STARTUP_CHANNEL_SIZE_INTERNAL, (void*) &dms, (void*) ONE_NUMBER, (void*) POINTER_ARRAY);
}
}
if (r != 1) {
compare_arrays(sn, (void*) &snc, (void*) STARTUP_ABSTRACTION_CONFIGURATION_NAME, (void*) STARTUP_ABSTRACTION_CONFIGURATION_NAME_COUNT, (void*) &r, (void*) CHARACTER_ARRAY);
if (r == 1) {
log_message_debug("Found startup abstraction configuration name.");
// Create destination model.
create_integer((void*) &dmc);
*dmc = 0;
create_integer((void*) &dms);
*dms = 0;
create_model((void*) &dm, (void*) dmc, (void*) dms,
sm, (void*) &smc,
sa, (void*) &sac,
sc, (void*) &scc);
// Set configuration parameter in internals memory.
set_array_elements(*d, (void*) STARTUP_ABSTRACTION_INTERNAL, (void*) &dm, (void*) ONE_NUMBER, (void*) POINTER_ARRAY);
set_array_elements(*d, (void*) STARTUP_ABSTRACTION_COUNT_INTERNAL, (void*) &dmc, (void*) ONE_NUMBER, (void*) POINTER_ARRAY);
set_array_elements(*d, (void*) STARTUP_ABSTRACTION_SIZE_INTERNAL, (void*) &dms, (void*) ONE_NUMBER, (void*) POINTER_ARRAY);
}
}
if (r != 1) {
compare_arrays(sn, (void*) &snc, (void*) STARTUP_MODEL_CONFIGURATION_NAME, (void*) STARTUP_MODEL_CONFIGURATION_NAME_COUNT, (void*) &r, (void*) CHARACTER_ARRAY);
if (r == 1) {
log_message_debug("Found startup model configuration name.");
// Create destination model.
create_integer((void*) &dmc);
*dmc = 0;
create_integer((void*) &dms);
*dms = 0;
create_model((void*) &dm, (void*) dmc, (void*) dms,
sm, (void*) &smc,
sa, (void*) &sac,
sc, (void*) &scc);
// Set configuration parameter in internals memory.
set_array_elements(*d, (void*) STARTUP_MODEL_INTERNAL, (void*) &dm, (void*) ONE_NUMBER, (void*) POINTER_ARRAY);
set_array_elements(*d, (void*) STARTUP_MODEL_COUNT_INTERNAL, (void*) &dmc, (void*) ONE_NUMBER, (void*) POINTER_ARRAY);
set_array_elements(*d, (void*) STARTUP_MODEL_SIZE_INTERNAL, (void*) &dms, (void*) ONE_NUMBER, (void*) POINTER_ARRAY);
}
}
if (r != 1) {
compare_arrays(sn, (void*) &snc, (void*) UNIX_SERVER_SOCKET_ACTIVE_CONFIGURATION_NAME, (void*) UNIX_SERVER_SOCKET_ACTIVE_CONFIGURATION_NAME_COUNT, (void*) &r, (void*) CHARACTER_ARRAY);
if (r == 1) {
log_message_debug("Found unix server socket active configuration name.");
// Create destination model.
create_model((void*) &dm, (void*) ONE_NUMBER, (void*) ONE_NUMBER,
sm, (void*) &smc,
sa, (void*) &sac,
sc, (void*) &scc);
// Set configuration parameter in internals memory.
set_array_elements(*d, (void*) UNIX_SERVER_SOCKET_ACTIVE_INTERNAL, (void*) &dm, (void*) ONE_NUMBER, (void*) POINTER_ARRAY);
}
}
if (r != 1) {
compare_arrays(sn, (void*) &snc, (void*) UNIX_SERVER_SOCKET_FILENAME_CONFIGURATION_NAME, (void*) UNIX_SERVER_SOCKET_FILENAME_CONFIGURATION_NAME_COUNT, (void*) &r, (void*) CHARACTER_ARRAY);
if (r == 1) {
log_message_debug("Found unix server socket filename configuration name.");
// Create destination model.
create_model((void*) &dm, (void*) ONE_NUMBER, (void*) ONE_NUMBER,
sm, (void*) &smc,
sa, (void*) &sac,
sc, (void*) &scc);
// Set configuration parameter in internals memory.
set_array_elements(*d, (void*) UNIX_SERVER_SOCKET_FILENAME_INTERNAL, (void*) &dm, (void*) ONE_NUMBER, (void*) POINTER_ARRAY);
}
}
if (r != 1) {
compare_arrays(sn, (void*) &snc, (void*) TCP_SERVER_SOCKET_ACTIVE_CONFIGURATION_NAME, (void*) TCP_SERVER_SOCKET_ACTIVE_CONFIGURATION_NAME_COUNT, (void*) &r, (void*) CHARACTER_ARRAY);
if (r == 1) {
log_message_debug("Found tcp server socket active configuration name.");
// Create destination model.
create_model((void*) &dm, (void*) ONE_NUMBER, (void*) ONE_NUMBER,
sm, (void*) &smc,
sa, (void*) &sac,
sc, (void*) &scc);
// Set configuration parameter in internals memory.
set_array_elements(*d, (void*) TCP_SERVER_SOCKET_ACTIVE_INTERNAL, (void*) &dm, (void*) ONE_NUMBER, (void*) POINTER_ARRAY);
}
}
if (r != 1) {
compare_arrays(sn, (void*) &snc, (void*) TCP_SERVER_SOCKET_PORT_CONFIGURATION_NAME, (void*) TCP_SERVER_SOCKET_PORT_CONFIGURATION_NAME_COUNT, (void*) &r, (void*) CHARACTER_ARRAY);
if (r == 1) {
log_message_debug("Found tcp server socket port configuration name.");
// Create destination model.
create_model((void*) &dm, (void*) ONE_NUMBER, (void*) ONE_NUMBER,
sm, (void*) &smc,
sa, (void*) &sac,
sc, (void*) &scc);
// Set configuration parameter in internals memory.
set_array_elements(*d, (void*) TCP_SERVER_SOCKET_PORT_INTERNAL, (void*) &dm, (void*) ONE_NUMBER, (void*) POINTER_ARRAY);
}
}
if (r != 1) {
compare_arrays(sn, (void*) &snc, (void*) X_WINDOWS_SERVER_ACTIVE_CONFIGURATION_NAME, (void*) X_WINDOWS_SERVER_ACTIVE_CONFIGURATION_NAME_COUNT, (void*) &r, (void*) CHARACTER_ARRAY);
if (r == 1) {
log_message_debug("Found x windows server active configuration name.");
// Create destination model.
create_model((void*) &dm, (void*) ONE_NUMBER, (void*) ONE_NUMBER,
sm, (void*) &smc,
sa, (void*) &sac,
sc, (void*) &scc);
// Set configuration parameter in internals memory.
set_array_elements(*d, (void*) X_WINDOWS_SERVER_ACTIVE_INTERNAL, (void*) &dm, (void*) ONE_NUMBER, (void*) POINTER_ARRAY);
}
}
// Reset source name.
sn = NULL_POINTER;
snc = 0;
// Reset source channel.
sc = NULL_POINTER;
scc = 0;
// Reset source abstraction.
sa = NULL_POINTER;
sac = 0;
// Reset source model.
sm = NULL_POINTER;
smc = 0;
// Reset destination model.
dm = NULL_POINTER;
dmc = INTEGER_NULL_POINTER;
dms = INTEGER_NULL_POINTER;
// Reset comparison result.
r = 0;
}
c = c->next;
}
} else {
//?? log_message((void*) &ERROR_LOG_LEVEL, (void*) &"Could not translate xml node. The source is null.");
}
} else {
//?? log_message((void*) &ERROR_LOG_LEVEL, (void*) &"Could not translate xml node. The source is null.");
}
} else {
//?? log_message((void*) &ERROR_LOG_LEVEL, (void*) &"Could not translate xml node. The source parameter is null.");
}
}
REG * create_lr_model(){
REG * lr = create_model(lr_eval, lr_grad, lr_repo);
return lr;
}
/* sets up a fixture with a model with constant row heights */
static void
scroll_fixture_constant_setup (ScrollFixture *fixture,
gconstpointer test_data)
{
scroll_fixture_setup (fixture, create_model (TRUE), test_data);
}
/**
* grg_list_run:
*
* Creates, manages and displays a dialog with the entry list
*/
void
grg_list_run (void)
{
GtkWidget *dialog, *sw, *tbar, *hbox, *bup, *bdown;
GtkTreePath *path = gtk_tree_path_new ();
guint res;
dialog = gtk_dialog_new_with_buttons (_("Index of entries"), NULL,
GTK_DIALOG_MODAL, GTK_STOCK_OK,
GTK_RESPONSE_OK, NULL);
gtk_container_set_border_width (GTK_CONTAINER (dialog), GRG_PAD);
gtk_box_set_spacing (GTK_BOX (GTK_DIALOG (dialog)->vbox), GRG_PAD);
sw = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw),
GTK_SHADOW_ETCHED_IN);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
GTK_POLICY_NEVER,
GTK_POLICY_AUTOMATIC);
model = create_model ();
treeview = gtk_tree_view_new_with_model (model);
gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (treeview), TRUE);
gtk_tree_view_set_search_column (GTK_TREE_VIEW (treeview), COL_ID);
g_signal_connect (G_OBJECT (treeview), "button-press-event",
G_CALLBACK (double_click), (gpointer) dialog);
g_object_unref (G_OBJECT (model));
gtk_container_add (GTK_CONTAINER (sw), treeview);
add_columns (GTK_TREE_VIEW (treeview));
tbar = gtk_toolbar_new ();
gtk_toolbar_set_orientation (GTK_TOOLBAR (tbar),
GTK_ORIENTATION_VERTICAL);
#if 0
gtk_toolbar_set_icon_size (GTK_TOOLBAR (tbar),
GTK_ICON_SIZE_LARGE_TOOLBAR);
#endif
bup = grg_toolbar_insert_stock (GTK_TOOLBAR (tbar), GTK_STOCK_GO_UP,
_("Move up"),
(GtkSignalFunc) move_row,
GINT_TO_POINTER (TRUE), -1);
bdown = grg_toolbar_insert_stock (GTK_TOOLBAR (tbar),
GTK_STOCK_GO_DOWN, _("Move down"),
(GtkSignalFunc) move_row,
GINT_TO_POINTER (FALSE), -1);
hbox = gtk_hbox_new (FALSE, GRG_PAD);
gtk_box_set_homogeneous (GTK_BOX (hbox), FALSE);
gtk_box_pack_start (GTK_BOX (hbox), tbar, FALSE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (hbox), sw, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), hbox, TRUE,
TRUE, 0);
gtk_window_set_default_size (GTK_WINDOW (dialog), 180, 250);
gtk_tree_path_append_index (path, grg_entries_position ());
gtk_tree_view_set_cursor (GTK_TREE_VIEW (treeview), path, NULL,
FALSE);
gtk_tree_path_free (path);
gtk_widget_show_all (dialog);
res = gtk_dialog_run (GTK_DIALOG (dialog));
if (res == GTK_RESPONSE_OK)
grg_entries_nth (get_sel_row_num ());
else
grg_entries_nth (0);
gtk_widget_destroy (dialog);
}
GtkWidget *
do_list_store (GtkWidget *do_widget)
{
if (!window)
{
GtkWidget *vbox;
GtkWidget *label;
GtkWidget *sw;
GtkWidget *treeview;
/* create window, etc */
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_screen (GTK_WINDOW (window),
gtk_widget_get_screen (do_widget));
gtk_window_set_title (GTK_WINDOW (window), "GtkListStore demo");
g_signal_connect (window, "destroy",
G_CALLBACK (gtk_widget_destroyed), &window);
gtk_container_set_border_width (GTK_CONTAINER (window), 8);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 8);
gtk_container_add (GTK_CONTAINER (window), vbox);
label = gtk_label_new ("This is the bug list (note: not based on real data, it would be nice to have a nice ODBC interface to bugzilla or so, though).");
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
sw = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw),
GTK_SHADOW_ETCHED_IN);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
GTK_POLICY_NEVER,
GTK_POLICY_AUTOMATIC);
gtk_box_pack_start (GTK_BOX (vbox), sw, TRUE, TRUE, 0);
/* create tree model */
model = create_model ();
/* create tree view */
treeview = gtk_tree_view_new_with_model (model);
gtk_tree_view_set_search_column (GTK_TREE_VIEW (treeview),
COLUMN_DESCRIPTION);
g_object_unref (model);
gtk_container_add (GTK_CONTAINER (sw), treeview);
/* add columns to the tree view */
add_columns (GTK_TREE_VIEW (treeview));
/* finish & show */
gtk_window_set_default_size (GTK_WINDOW (window), 280, 250);
g_signal_connect (window, "delete-event",
G_CALLBACK (window_closed), NULL);
}
if (!gtk_widget_get_visible (window))
{
gtk_widget_show_all (window);
if (timeout == 0) {
/* FIXME this should use the animation-duration instead */
timeout = g_timeout_add (80, spinner_timeout, NULL);
}
}
else
{
gtk_widget_destroy (window);
window = NULL;
if (timeout != 0)
{
g_source_remove (timeout);
timeout = 0;
}
}
return window;
}
gpointer do_tree_store()
{
GtkWidget *window = __g_priv.window;
if (!window) {
GtkWidget *vbox, *tool_hbox, *grep_hbox;
GtkWidget *scan_button;
GtkWidget *grep_button;
GtkWidget *grep_entry;
GtkWidget *sw;
GtkWidget *treeview;
GtkTreeModel *model;
GtkTreeModel *filter;
/* create window, etc */
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_screen(GTK_WINDOW(window), gtk_widget_get_screen(NULL));
gtk_window_set_title(GTK_WINDOW(window), "list");
g_signal_connect(window, "destroy", G_CALLBACK(gtk_widget_destroyed), &window);
vbox = gtk_vbox_new(FALSE, 1);
gtk_container_set_border_width(GTK_CONTAINER(vbox), 1);
gtk_container_add(GTK_CONTAINER(window), vbox);
tool_hbox = gtk_hbox_new(FALSE, 1);
gtk_container_set_border_width(GTK_CONTAINER(tool_hbox), 1);
gtk_box_pack_start(GTK_BOX(vbox), tool_hbox, FALSE, FALSE, 0);
scan_button = gtk_toggle_button_new_with_mnemonic("_Rescan");
gtk_box_pack_start(GTK_BOX(tool_hbox), scan_button, FALSE, FALSE, 0);
grep_button = gtk_toggle_button_new_with_mnemonic("_Search");
gtk_box_pack_end(GTK_BOX(tool_hbox), grep_button, FALSE, FALSE, 0);
grep_hbox = gtk_hbox_new(FALSE, 1);
gtk_container_set_border_width(GTK_CONTAINER(grep_hbox), 1);
gtk_box_pack_start(GTK_BOX(vbox), grep_hbox, FALSE, FALSE, 0);
grep_entry = gtk_entry_new();
gtk_box_pack_start(GTK_BOX(grep_hbox), grep_entry, TRUE, TRUE, 0);
g_signal_connect(G_OBJECT(grep_button), "toggled", G_CALLBACK(cb_search_toggled), GTK_ENTRY(grep_entry));
sw = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(sw), GTK_SHADOW_ETCHED_IN);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_box_pack_start(GTK_BOX(vbox), sw, TRUE, TRUE, 0);
/* create model */
model = create_model();
gtk_tree_view_set_model(GTK_TREE_VIEW(treeview), GTK_TREE_MODEL(model));
/* Create filter and set visible function */
filter = gtk_tree_model_filter_new(model, NULL);
gtk_tree_model_filter_set_visible_func(GTK_TREE_MODEL_FILTER(filter), (GtkTreeModelFilterVisibleFunc)
filter_func, grep_entry, NULL);
/* Create treeview with model */
treeview = gtk_tree_view_new_with_model(filter);
fill_data(treeview, GTK_TREE_STORE(model));
g_signal_connect(G_OBJECT(grep_entry), "changed", G_CALLBACK(cb_entry_changed), GTK_TREE_VIEW(treeview));
g_object_unref(model);
gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(treeview), TRUE);
gtk_tree_view_set_show_expanders(GTK_TREE_VIEW(treeview), TRUE);
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(treeview), FALSE);
gtk_tree_selection_set_mode(gtk_tree_view_get_selection(GTK_TREE_VIEW(treeview)), GTK_SELECTION_SINGLE);
add_columns(GTK_TREE_VIEW(treeview));
gtk_container_add(GTK_CONTAINER(sw), treeview);
/* expand all rows after the treeview widget has been realized */
g_signal_connect(treeview, "realize", G_CALLBACK(gtk_tree_view_expand_all), NULL);
gtk_window_set_default_size(GTK_WINDOW(window), 650, 400);
/* set priv */
__g_priv.window = window;
__g_priv.treeview = treeview;
__g_priv.model = model;
__g_priv.filter = filter;
__g_priv.scan_button = scan_button;
__g_priv.grep_button = grep_button;
__g_priv.grep_entry = grep_entry;
}
if (!GTK_WIDGET_VISIBLE(window))
gtk_widget_show_all(window);
else {
gtk_widget_destroy(window);
window = NULL;
}
return (gpointer) & __g_priv;
}
gint
main (gint argc, gchar **argv)
{
GtkWidget *window;
GtkWidget *scrolled_window;
GtkWidget *tree_view;
GtkWidget *vbox, *hbox, *cntl_vbox;
GtkTreeModel *tree_model;
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
GtkCellArea *area;
CallbackData callback[4];
gtk_init (&argc, &argv);
if (g_getenv ("RTL"))
gtk_widget_set_default_direction (GTK_TEXT_DIR_RTL);
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (window), "GtkTreeView editing sample");
g_signal_connect (window, "destroy", gtk_main_quit, NULL);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
gtk_widget_show (vbox);
gtk_container_add (GTK_CONTAINER (window), vbox);
scrolled_window = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled_window), GTK_SHADOW_ETCHED_IN);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_box_pack_start (GTK_BOX (vbox), scrolled_window, TRUE, TRUE, 0);
tree_model = create_model ();
tree_view = gtk_tree_view_new_with_model (tree_model);
g_signal_connect (tree_view, "button_press_event", G_CALLBACK (button_press_event), NULL);
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (tree_view), TRUE);
column = gtk_tree_view_column_new ();
gtk_tree_view_column_set_title (column, "String");
area = gtk_cell_layout_get_area (GTK_CELL_LAYOUT (column));
renderer = gtk_cell_renderer_pixbuf_new ();
gtk_tree_view_column_pack_start (column, renderer, FALSE);
gtk_tree_view_column_set_attributes (column, renderer,
"icon-name", ICON_NAME_COLUMN,
"sensitive", IS_SENSITIVE_COLUMN,
NULL);
callback[0].area = area;
callback[0].renderer = renderer;
renderer = gtk_cell_renderer_text_new ();
gtk_tree_view_column_pack_start (column, renderer, FALSE);
gtk_tree_view_column_set_attributes (column, renderer,
"text", STRING_COLUMN,
"editable", IS_EDITABLE_COLUMN,
"sensitive", IS_SENSITIVE_COLUMN,
NULL);
callback[1].area = area;
callback[1].renderer = renderer;
g_signal_connect (renderer, "edited",
G_CALLBACK (edited), tree_model);
g_object_set (renderer,
"placeholder-text", "Type here",
NULL);
renderer = gtk_cell_renderer_text_new ();
gtk_tree_view_column_pack_start (column, renderer, FALSE);
gtk_tree_view_column_set_attributes (column, renderer,
"text", STRING_COLUMN,
"editable", IS_EDITABLE_COLUMN,
"sensitive", IS_SENSITIVE_COLUMN,
NULL);
callback[2].area = area;
callback[2].renderer = renderer;
g_signal_connect (renderer, "edited",
G_CALLBACK (edited), tree_model);
g_object_set (renderer,
"placeholder-text", "Type here too",
NULL);
renderer = gtk_cell_renderer_pixbuf_new ();
g_object_set (renderer,
"xalign", 0.0,
NULL);
gtk_tree_view_column_pack_start (column, renderer, FALSE);
gtk_tree_view_column_set_attributes (column, renderer,
"icon-name", LAST_ICON_NAME_COLUMN,
"sensitive", IS_SENSITIVE_COLUMN,
NULL);
callback[3].area = area;
callback[3].renderer = renderer;
gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), column);
renderer = gtk_cell_renderer_toggle_new ();
g_signal_connect (renderer, "toggled",
G_CALLBACK (editable_toggled), tree_model);
g_object_set (renderer,
"xalign", 0.0,
NULL);
gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (tree_view),
-1, "Editable",
renderer,
"active", IS_EDITABLE_COLUMN,
NULL);
renderer = gtk_cell_renderer_toggle_new ();
g_signal_connect (renderer, "toggled",
G_CALLBACK (sensitive_toggled), tree_model);
g_object_set (renderer,
"xalign", 0.0,
NULL);
gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (tree_view),
-1, "Sensitive",
renderer,
"active", IS_SENSITIVE_COLUMN,
NULL);
renderer = gtk_cell_renderer_progress_new ();
gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (tree_view),
-1, "Progress",
renderer,
"value", PROGRESS_COLUMN,
NULL);
gtk_container_add (GTK_CONTAINER (scrolled_window), tree_view);
gtk_window_set_default_size (GTK_WINDOW (window),
800, 250);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
gtk_widget_show (hbox);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
/* Alignment controls */
cntl_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2);
gtk_widget_show (cntl_vbox);
gtk_box_pack_start (GTK_BOX (hbox), cntl_vbox, FALSE, FALSE, 0);
create_control (cntl_vbox, 1, CNTL_ALIGN, &callback[0]);
create_control (cntl_vbox, 2, CNTL_ALIGN, &callback[1]);
create_control (cntl_vbox, 3, CNTL_ALIGN, &callback[2]);
create_control (cntl_vbox, 4, CNTL_ALIGN, &callback[3]);
/* Expand controls */
cntl_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2);
gtk_widget_show (cntl_vbox);
gtk_box_pack_start (GTK_BOX (hbox), cntl_vbox, FALSE, FALSE, 0);
create_control (cntl_vbox, 1, CNTL_EXPAND, &callback[0]);
create_control (cntl_vbox, 2, CNTL_EXPAND, &callback[1]);
create_control (cntl_vbox, 3, CNTL_EXPAND, &callback[2]);
create_control (cntl_vbox, 4, CNTL_EXPAND, &callback[3]);
/* Fixed controls */
cntl_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2);
gtk_widget_show (cntl_vbox);
gtk_box_pack_start (GTK_BOX (hbox), cntl_vbox, FALSE, FALSE, 0);
create_control (cntl_vbox, 1, CNTL_FIXED, &callback[0]);
create_control (cntl_vbox, 2, CNTL_FIXED, &callback[1]);
create_control (cntl_vbox, 3, CNTL_FIXED, &callback[2]);
create_control (cntl_vbox, 4, CNTL_FIXED, &callback[3]);
gtk_widget_show_all (window);
gtk_main ();
return 0;
}
int main (int argc, char *argv[])
{
GtkWidget *window1;
GdkPixbuf *window1_icon_pixbuf;
GtkWidget *vbox1;
GtkWidget *menubar1;
GtkWidget *menuitem1;
GtkWidget *menuitem1_menu;
GtkWidget *Save_s_1;
GtkWidget *Quit_q_1;
GtkWidget *menuitem2;
GtkWidget *menuitem2_menu;
GtkWidget *Add_a_1;
GtkWidget *Edit_e_1;
GtkWidget *Delete_d_1;
GtkWidget *menuitem3;
GtkWidget *menuitem3_menu;
GtkWidget *Find_f_1;
GtkWidget *toolbar1;
GtkIconSize tmp_toolbar_icon_size;
GtkWidget *toolbutton1;
GtkWidget *toolbutton2;
GtkWidget *toolbutton3;
GtkWidget *toolbutton4;
GtkWidget *toolbutton5;
GtkWidget *hbox1;
GtkWidget *scrolledwindow1;
GtkWidget *treeview;
GtkWidget *scrolledwindow2;
GtkWidget *textview1;
GtkAccelGroup *accel_group;
GtkTooltips *tooltips;
GtkTreeSelection *selection;
//初始化GTK+
gtk_init (&argc, &argv);
tooltips = gtk_tooltips_new ();
accel_group = gtk_accel_group_new ();
window1 = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_widget_set_size_request (window1, 450, 600);
gtk_window_set_title (GTK_WINDOW (window1), "Echo Addressbook");
gtk_window_set_icon_from_file(GTK_WINDOW (window1), "./pixmaps/logo.png", NULL);
vbox1 = gtk_vbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER (window1), vbox1);
//菜单
menubar1 = gtk_menu_bar_new ();
gtk_box_pack_start (GTK_BOX (vbox1), menubar1, FALSE, FALSE, 0);
menuitem1 = gtk_menu_item_new_with_mnemonic ("_File");
gtk_container_add (GTK_CONTAINER (menubar1), menuitem1);
menuitem1_menu = gtk_menu_new ();
gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem1), menuitem1_menu);
Save_s_1 = gtk_image_menu_item_new_from_stock ("gtk-save", accel_group);
gtk_container_add (GTK_CONTAINER (menuitem1_menu), Save_s_1);
Quit_q_1 = gtk_image_menu_item_new_from_stock ("gtk-quit", accel_group);
gtk_container_add (GTK_CONTAINER (menuitem1_menu), Quit_q_1);
menuitem2 = gtk_menu_item_new_with_mnemonic ("_Edit");
gtk_container_add (GTK_CONTAINER (menubar1), menuitem2);
menuitem2_menu = gtk_menu_new ();
gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem2), menuitem2_menu);
Add_a_1 = gtk_image_menu_item_new_from_stock ("gtk-add", accel_group);
gtk_container_add (GTK_CONTAINER (menuitem2_menu), Add_a_1);
gtk_widget_add_accelerator (Add_a_1, "activate", accel_group, GDK_a, (GdkModifierType) GDK_CONTROL_MASK,GTK_ACCEL_VISIBLE);
Edit_e_1 = gtk_image_menu_item_new_from_stock ("gtk-edit", accel_group);
gtk_container_add (GTK_CONTAINER (menuitem2_menu), Edit_e_1);
gtk_widget_add_accelerator (Edit_e_1, "activate", accel_group, GDK_e, (GdkModifierType) GDK_CONTROL_MASK,GTK_ACCEL_VISIBLE);
Delete_d_1 = gtk_image_menu_item_new_from_stock ("gtk-delete", accel_group);
gtk_container_add (GTK_CONTAINER (menuitem2_menu), Delete_d_1);
gtk_widget_add_accelerator (Delete_d_1, "activate", accel_group, GDK_d, (GdkModifierType) GDK_CONTROL_MASK,GTK_ACCEL_VISIBLE);
menuitem3 = gtk_menu_item_new_with_mnemonic ("_Search");
gtk_container_add (GTK_CONTAINER (menubar1), menuitem3);
menuitem3_menu = gtk_menu_new ();
gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem3), menuitem3_menu);
Find_f_1 = gtk_image_menu_item_new_from_stock ("gtk-find", accel_group);
gtk_container_add (GTK_CONTAINER (menuitem3_menu), Find_f_1);
//菜单
//工具条
toolbar1 = gtk_toolbar_new ();
gtk_box_pack_start (GTK_BOX (vbox1), toolbar1, FALSE, FALSE, 0);
gtk_toolbar_set_style (GTK_TOOLBAR (toolbar1), GTK_TOOLBAR_ICONS);
tmp_toolbar_icon_size = gtk_toolbar_get_icon_size (GTK_TOOLBAR (toolbar1));
toolbutton1 = (GtkWidget *) gtk_tool_button_new_from_stock ("gtk-add");
gtk_container_add (GTK_CONTAINER (toolbar1), toolbutton1);
gtk_tool_item_set_tooltip (GTK_TOOL_ITEM (toolbutton1), tooltips, "Add", NULL);
toolbutton2 = (GtkWidget *) gtk_tool_button_new_from_stock ("gtk-find");
gtk_container_add (GTK_CONTAINER (toolbar1), toolbutton2);
gtk_tool_item_set_tooltip (GTK_TOOL_ITEM (toolbutton2), tooltips, "Search", NULL);
toolbutton3 = (GtkWidget *) gtk_tool_button_new_from_stock ("gtk-edit");
gtk_container_add (GTK_CONTAINER (toolbar1), toolbutton3);
gtk_tool_item_set_tooltip (GTK_TOOL_ITEM (toolbutton3), tooltips, "Edit", NULL);
toolbutton4 = (GtkWidget *) gtk_tool_button_new_from_stock ("gtk-save");
gtk_container_add (GTK_CONTAINER (toolbar1), toolbutton4);
gtk_tool_item_set_tooltip (GTK_TOOL_ITEM (toolbutton4), tooltips, "Save", NULL);
toolbutton5 = (GtkWidget *) gtk_tool_button_new_from_stock ("gtk-delete");
gtk_container_add (GTK_CONTAINER (toolbar1), toolbutton5);
gtk_tool_item_set_tooltip (GTK_TOOL_ITEM (toolbutton5), tooltips, "Delete", NULL);
//工具条
/* hbox start*/
hbox1 = gtk_hbox_new (FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox1), hbox1, TRUE, TRUE, 0);
statusbar = gtk_statusbar_new ();
//Treeview
//创建treeview
model = create_model ();
treeview = gtk_tree_view_new_with_model (model);
//创建栏目
creat_columns (GTK_TREE_VIEW (treeview));
//加载数据
LoadFile();
BuildTreeView(GTK_TREE_VIEW (treeview));
gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (treeview), TRUE);
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (treeview));
//滚动条1---treeview
scrolledwindow1 = gtk_scrolled_window_new (NULL, NULL);
gtk_box_pack_start (GTK_BOX (hbox1), scrolledwindow1, FALSE, TRUE, 0);
gtk_widget_set_size_request (scrolledwindow1, 160, -1);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow1), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolledwindow1), GTK_SHADOW_IN);
gtk_container_add (GTK_CONTAINER (scrolledwindow1), treeview);
//
//GTK textview
textview1 = gtk_text_view_new ();
gtk_text_view_set_editable (GTK_TEXT_VIEW (textview1), FALSE);
gtk_text_view_set_cursor_visible (GTK_TEXT_VIEW (textview1), FALSE);
gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (textview1), GTK_WRAP_CHAR);
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (textview1));
gtk_text_buffer_create_tag (buffer, "x-large","scale", PANGO_SCALE_X_LARGE, NULL);
//滚动条2---textview
scrolledwindow2 = gtk_scrolled_window_new (NULL, NULL);
gtk_box_pack_start (GTK_BOX (hbox1), scrolledwindow2, TRUE, TRUE, 0);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow2), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolledwindow2), GTK_SHADOW_IN);
gtk_container_add (GTK_CONTAINER (scrolledwindow2), textview1);
/* hbox end */
//状态栏
gtk_box_pack_start (GTK_BOX (vbox1), statusbar, FALSE, FALSE, 0);
//设置回调函数
g_signal_connect (window1, "destroy", G_CALLBACK (gtk_main_quit),NULL);
g_signal_connect (selection, "changed", G_CALLBACK (GetSelect), treeview);
g_signal_connect (toolbutton1, "clicked", G_CALLBACK (add_people), treeview);
g_signal_connect (toolbutton2, "clicked", G_CALLBACK (search_people), treeview);
g_signal_connect (toolbutton3, "clicked", G_CALLBACK (edit_people), treeview);
g_signal_connect (toolbutton4, "clicked", G_CALLBACK (SaveFile), NULL);
g_signal_connect (toolbutton5, "clicked",G_CALLBACK (remove_item),treeview);
g_signal_connect (Add_a_1, "activate", G_CALLBACK (add_people), treeview);
g_signal_connect (Edit_e_1, "activate", G_CALLBACK (edit_people),treeview);
g_signal_connect (Find_f_1, "activate", G_CALLBACK (search_people),treeview);
g_signal_connect (Delete_d_1, "activate", G_CALLBACK (remove_item),treeview);
g_signal_connect (Quit_q_1, "activate", G_CALLBACK (gtk_main_quit),treeview);
//快捷键组
gtk_window_add_accel_group (GTK_WINDOW (window1), accel_group);
gtk_widget_show_all (window1);
//GTK_main
gtk_main ();
return 0;
}
void Config_macros(GtkAction *action, gpointer data)
{
GtkWidget *vbox, *hbox;
GtkWidget *sw;
GtkTreeModel *model;
GtkWidget *treeview;
GtkWidget *button;
GtkWidget *separator;
/* create window, etc */
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (window), _("Configure Macros"));
g_signal_connect (window, "destroy",
G_CALLBACK (gtk_widget_destroyed), &window);
gtk_container_set_border_width (GTK_CONTAINER (window), 8);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 8);
gtk_container_add (GTK_CONTAINER (window), vbox);
sw = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw),
GTK_SHADOW_ETCHED_IN);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
GTK_POLICY_NEVER,
GTK_POLICY_AUTOMATIC);
gtk_box_pack_start (GTK_BOX (vbox), sw, TRUE, TRUE, 0);
/* create tree model */
model = create_model ();
/* create tree view */
treeview = gtk_tree_view_new_with_model (model);
gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (treeview), TRUE);
gtk_tree_view_set_search_column (GTK_TREE_VIEW (treeview),
COLUMN_SHORTCUT);
g_object_unref (model);
gtk_container_add (GTK_CONTAINER (sw), treeview);
/* add columns to the tree view */
add_columns (GTK_TREE_VIEW (treeview));
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 4);
gtk_box_set_homogeneous (GTK_BOX (hbox), TRUE);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
button = gtk_button_new_with_mnemonic (_("_Add"));
g_signal_connect(button, "clicked", G_CALLBACK(Add_shortcut), (gpointer)model);
gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
button = gtk_button_new_with_mnemonic (_("_Delete"));
g_signal_connect(button, "clicked", G_CALLBACK(Delete_shortcut), (gpointer)treeview);
gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
button = gtk_button_new_with_mnemonic (_("_Capture Shortcut"));
g_signal_connect(button, "clicked", G_CALLBACK(Capture_shortcut), (gpointer)treeview);
gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
separator = gtk_separator_new(GTK_ORIENTATION_HORIZONTAL);
gtk_box_pack_start (GTK_BOX (vbox), separator, FALSE, TRUE, 0);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 4);
gtk_box_set_homogeneous (GTK_BOX (hbox), TRUE);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
button = gtk_button_new_from_stock (GTK_STOCK_HELP);
g_signal_connect(button, "clicked", G_CALLBACK(Help_screen), (gpointer)window);
gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
button = gtk_button_new_from_stock (GTK_STOCK_OK);
g_signal_connect(button, "clicked", G_CALLBACK(Save_shortcuts), (gpointer)treeview);
g_signal_connect_swapped(button, "clicked", G_CALLBACK(gtk_widget_destroy), (gpointer)window);
gtk_box_pack_end (GTK_BOX (hbox), button, TRUE, TRUE, 0);
button = gtk_button_new_from_stock (GTK_STOCK_CANCEL);
g_signal_connect_swapped(button, "clicked", G_CALLBACK(gtk_widget_destroy), (gpointer)window);
gtk_box_pack_end (GTK_BOX (hbox), button, TRUE, TRUE, 0);
gtk_window_set_default_size (GTK_WINDOW(window), 300, 400);
gtk_widget_show_all(window);
}
GtkWidget *
create_directory_treeview (void)
{
GtkCellRenderer *cell;
GtkTreeViewColumn *col;
GtkWidget *scrolled;
GtkWidget *tvw = GTK_WIDGET (gtk_builder_get_object (baobab.main_ui, "treeview1"));
g_signal_connect (tvw, "row-expanded",
G_CALLBACK (on_tv_row_expanded), NULL);
g_signal_connect (tvw, "cursor-changed",
G_CALLBACK (on_tv_cur_changed), NULL);
g_signal_connect (tvw, "button-press-event",
G_CALLBACK (on_tv_button_press), NULL);
/* dir name column */
g_signal_connect (gtk_tree_view_get_selection (GTK_TREE_VIEW (tvw)), "changed",
G_CALLBACK (on_tv_selection_changed), NULL);
cell = gtk_cell_renderer_text_new ();
col = gtk_tree_view_column_new_with_attributes (NULL, cell, "markup",
COL_DIR_NAME, "text",
COL_DIR_NAME, NULL);
gtk_tree_view_column_set_sort_column_id (col, COL_DIR_NAME);
gtk_tree_view_column_set_reorderable (col, TRUE);
gtk_tree_view_column_set_title (col, _("Folder"));
gtk_tree_view_column_set_sizing (col, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
gtk_tree_view_column_set_resizable (col, TRUE);
gtk_tree_view_append_column (GTK_TREE_VIEW (tvw), col);
/* percentage bar & text column */
col = gtk_tree_view_column_new ();
cell = baobab_cell_renderer_progress_new ();
gtk_tree_view_column_pack_start (col, cell, FALSE);
gtk_tree_view_column_set_attributes (col, cell, "perc",
COL_H_PERC, NULL);
cell = gtk_cell_renderer_text_new ();
gtk_tree_view_column_pack_start (col, cell, TRUE);
gtk_tree_view_column_set_cell_data_func (col, cell,
perc_cell_data_func,
NULL, NULL);
g_object_set (G_OBJECT (cell), "xalign", (gfloat) 1.0, NULL);
gtk_tree_view_column_set_sort_column_id (col, COL_H_PERC);
gtk_tree_view_column_set_reorderable (col, TRUE);
gtk_tree_view_column_set_title (col, _("Usage"));
gtk_tree_view_column_set_sizing (col, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
gtk_tree_view_column_set_resizable (col, FALSE);
gtk_tree_view_append_column (GTK_TREE_VIEW (tvw), col);
/* directory size column */
cell = gtk_cell_renderer_text_new ();
col = gtk_tree_view_column_new_with_attributes (NULL, cell, "markup",
COL_DIR_SIZE, "text",
COL_DIR_SIZE, NULL);
g_object_set (G_OBJECT (cell), "xalign", (gfloat) 1.0, NULL);
gtk_tree_view_column_set_sort_column_id (col,
baobab.show_allocated ? COL_H_ALLOCSIZE : COL_H_SIZE);
gtk_tree_view_column_set_reorderable (col, TRUE);
gtk_tree_view_column_set_title (col, _("Size"));
gtk_tree_view_column_set_sizing (col, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
gtk_tree_view_column_set_resizable (col, TRUE);
gtk_tree_view_append_column (GTK_TREE_VIEW (tvw), col);
/* store this column, we need it when toggling 'allocated' */
g_object_set_data (G_OBJECT (tvw), "baobab_size_col", col);
/* objects column */
cell = gtk_cell_renderer_text_new ();
col = gtk_tree_view_column_new_with_attributes (NULL, cell, "markup",
COL_ELEMENTS, "text",
COL_ELEMENTS, NULL);
g_object_set (G_OBJECT (cell), "xalign", (gfloat) 1.0, NULL);
gtk_tree_view_column_set_sort_column_id (col, COL_H_ELEMENTS);
gtk_tree_view_column_set_reorderable (col, TRUE);
gtk_tree_view_column_set_title (col, _("Contents"));
gtk_tree_view_column_set_sizing (col, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
gtk_tree_view_column_set_resizable (col, TRUE);
gtk_tree_view_append_column (GTK_TREE_VIEW (tvw), col);
/* hardlink column */
cell = gtk_cell_renderer_text_new ();
col = gtk_tree_view_column_new_with_attributes (NULL, cell, "markup",
COL_HARDLINK, "text",
COL_HARDLINK, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (tvw), col);
gtk_tree_view_collapse_all (GTK_TREE_VIEW (tvw));
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (tvw), FALSE);
scrolled = GTK_WIDGET (gtk_builder_get_object (baobab.main_ui, "scrolledwindow1"));
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_tree_view_set_search_equal_func (GTK_TREE_VIEW (tvw),
baobab_treeview_equal_func,
NULL, NULL);
baobab.model = create_model ();
/* By default, sort by size */
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (baobab.model),
baobab.show_allocated ? COL_H_ALLOCSIZE : COL_H_SIZE,
GTK_SORT_DESCENDING);
gtk_tree_view_set_model (GTK_TREE_VIEW (tvw),
GTK_TREE_MODEL (baobab.model));
g_object_unref (baobab.model);
return tvw;
}
