/**
* ticalcs_dirlist_display:
* @tree: the tree to display.
*
* Display to stdout the tree content formatted in a tab.
*
* Return value: none.
**/
TIEXPORT3 void TICALL ticalcs_dirlist_display(GNode* tree)
{
GNode *vars = tree;
TreeInfo *info;
int i;
if (tree == NULL)
{
ticalcs_critical("ticalcs_dirlist_display(NULL)");
return;
}
info = (TreeInfo *)(tree->data);
if (info == NULL)
{
return;
}
printf( "+------------------+----------+----+----+----------+----------+\n");
printf(_("| B. name | T. name |Attr|Type| Size | Folder |\n"));
printf( "+------------------+----------+----+----+----------+----------+\n");
i = (int)g_node_n_children(vars);
//ticalcs_info("Root has %d children", i);
display_tree(info, vars);
if (!i)
{
if (!strcmp(info->type, VAR_NODE_NAME))
{
printf(_("| No variables |\n"));
}
else if (!strcmp(info->type, APP_NODE_NAME))
{
printf(_("| No applications |\n"));
}
}
printf(_("+------------------+----------+----+----+----------+----------+"));
printf("\n");
}
static void display_tree(TreeInfo * info, GNode * vars)
{
int i;
//ticalcs_info("vars has %d children", (int)g_node_n_children(vars));
for (i = 0; i < (int)g_node_n_children(vars); i++) // parse children
{
GNode *parent = g_node_nth_child(vars, i);
VarEntry *fe = (VarEntry *) (parent->data);
int j;
if (fe != NULL)
{
display_node(info, fe, -1);
}
//ticalcs_info("parent has %d children", (int)g_node_n_children(parent));
if (info->model != CALC_NSPIRE)
{
for (j = 0; j < (int)g_node_n_children(parent); j++)
{
GNode *child = g_node_nth_child(parent, j);
VarEntry *ve = (VarEntry *) (child->data);
display_node(info, ve, ve->type);
}
}
else
{
// Recurse into sub-folder if necessary.
if (fe != NULL && fe->type == NSP_DIR)
{
//ticalcs_info("Recurse");
display_tree(info, parent);
}
}
//ticalcs_info("finished enumerating %d children of parent", (int)g_node_n_children(parent));
}
//ticalcs_info("finished enumerating %d children of vars", (int)g_node_n_children(vars));
}
void display_ast_iter(size_t indent, struct ast_t *a, const char *type_strings[]) {
size_t i;
for (i = 1; i < indent; i++) {
printf(" ");
}
switch (a->type) {
case AST_CHAR:
{
display_c(indent, a);
break;
}
case AST_TREE:
{
display_tree(indent, a, type_strings);
break;
}
default:
break;
}
}
void start_split(Widget w, XtPointer client_data,
XmSelectionBoxCallbackStruct *call_data)
{
short i,j,condition;
char *cond;
/* Get threshold value from user's selection */
XmStringGetLtoR(call_data->value, XmSTRING_DEFAULT_CHARSET, &cond);
condition = atoi(cond);
if (!(condition>=0 && condition<=20512) ) {
XBell(XtDisplay(w),100);
return;
}
/* Fill in the image with background color */
for(i=0; i<IMAGE_WIDTH; i++)
for(j=0; j<IMAGE_HEIGHT; j++)
XPutPixel(theXImage_2,i,j,bg);
/* Clear the drawing window so the image is displayed again */
XClearArea(XtDisplay(draw_1),XtWindow(draw_2),0,0,0,0,True);
/* Associate the watch cursor with the main window */
XDefineCursor(XtDisplay(draw_1), XtWindow(main_window), theCursor);
/* Flush the request buffer and wait for all events */
/* and errors to be processed by the server. */
XSync(XtDisplay(draw_1), False);
/* Free the memory used for giving room to the structure */
/* that represents the merged regions if any */
if (merged_region_list!=NULL) free_merge(&merged_region_list);
/* Free the memory used for giving room to the tree structure if any */
if (root!=NULL) free_tree(root); root=NULL;
num_reg=0;
num_split=0;
/* Generate the quadtree structure */
root = split(condition,0,0,0);
/* Show usefull information on the screen */
fprintf (stderr,"\n\n\n************************ SPLIT ***********************\n");
fprintf (stderr," Standard deviation: %i\n", condition);
fprintf (stderr," Number of split operations: %i\n", num_split);
fprintf (stderr," Number of regions after split: %i\n", num_reg);
display_tree(root);
/* Clear the drawing window so the image is displayed again */
XClearArea(XtDisplay(draw_1),XtWindow(draw_1),0,0,0,0,True);
/* Disassociate the watch cursor from the main window */
XUndefineCursor(XtDisplay(draw_1), XtWindow(main_window));
/* Copy image into pixmap */
XPutImage(XtDisplay(draw_2), thePixmap_2, image_gc_2, theXImage_2,
0, 0, 0, 0, theXImage_2->width, theXImage_2->height);
/* Clear the drawing window so the image is displayed again */
XClearArea(XtDisplay(draw_1),XtWindow(draw_2),0,0,0,0,True);
}
int main(int ac, char *av[])
{
const char *name;
char *env;
gchar *glade_file;
#ifndef LKC_DIRECT_LINK
kconfig_load();
#endif
bindtextdomain(PACKAGE, LOCALEDIR);
bind_textdomain_codeset(PACKAGE, "UTF-8");
textdomain(PACKAGE);
/* GTK stuffs */
gtk_set_locale();
gtk_init(&ac, &av);
glade_init();
//add_pixmap_directory (PACKAGE_DATA_DIR "/" PACKAGE "/pixmaps");
//add_pixmap_directory (PACKAGE_SOURCE_DIR "/pixmaps");
/* Determine GUI path */
env = getenv(SRCTREE);
if (env)
glade_file = g_strconcat(env, "/scripts/kconfig/gconf.glade", NULL);
else if (av[0][0] == '/')
glade_file = g_strconcat(av[0], ".glade", NULL);
else
glade_file = g_strconcat(g_get_current_dir(), "/", av[0], ".glade", NULL);
/* Load the interface and connect signals */
init_main_window(glade_file);
init_tree_model();
init_left_tree();
init_right_tree();
/* Conf stuffs */
if (ac > 1 && av[1][0] == '-') {
switch (av[1][1]) {
case 'a':
//showAll = 1;
break;
case 'h':
case '?':
printf("%s <config>\n", av[0]);
exit(0);
}
name = av[2];
} else
name = av[1];
conf_parse(name);
fixup_rootmenu(&rootmenu);
conf_read(NULL);
switch (view_mode) {
case SINGLE_VIEW:
display_tree_part();
break;
case SPLIT_VIEW:
display_list();
break;
case FULL_VIEW:
display_tree(&rootmenu);
break;
}
gtk_main();
return 0;
}
/* Display the whole tree (single/split/full view) */
static void display_tree(struct menu *menu)
{
struct symbol *sym;
struct property *prop;
struct menu *child;
enum prop_type ptype;
if (menu == &rootmenu) {
indent = 1;
current = &rootmenu;
}
for (child = menu->list; child; child = child->next) {
prop = child->prompt;
sym = child->sym;
ptype = prop ? prop->type : P_UNKNOWN;
if (sym)
sym->flags &= ~SYMBOL_CHANGED;
if ((view_mode == SPLIT_VIEW)
&& !(child->flags & MENU_ROOT) && (tree == tree1))
continue;
if ((view_mode == SPLIT_VIEW) && (child->flags & MENU_ROOT)
&& (tree == tree2))
continue;
if ((opt_mode == OPT_NORMAL && menu_is_visible(child)) ||
(opt_mode == OPT_PROMPT && menu_has_prompt(child)) ||
(opt_mode == OPT_ALL && menu_get_prompt(child)))
place_node(child, fill_row(child));
#ifdef DEBUG
printf("%*c%s: ", indent, ' ', menu_get_prompt(child));
printf("%s", child->flags & MENU_ROOT ? "rootmenu | " : "");
printf("%s", prop_get_type_name(ptype));
printf(" | ");
if (sym) {
printf("%s", sym_type_name(sym->type));
printf(" | ");
printf("%s", dbg_sym_flags(sym->flags));
printf("\n");
} else
printf("\n");
#endif
if ((view_mode != FULL_VIEW) && (ptype == P_MENU)
&& (tree == tree2))
continue;
/*
if (((menu != &rootmenu) && !(menu->flags & MENU_ROOT))
|| (view_mode == FULL_VIEW)
|| (view_mode == SPLIT_VIEW))*/
if (((view_mode == SINGLE_VIEW) && (menu->flags & MENU_ROOT))
|| (view_mode == FULL_VIEW)
|| (view_mode == SPLIT_VIEW)) {
indent++;
display_tree(child);
indent--;
}
}
}
int main(int argc, char *argv[])
{
struct rooted_tree *tree;
struct parameters params;
int align_leaves;
int with_scale_bar;
enum display_status status;
void (*node_destroyer)(struct rnode *) = NULL;
params = get_params(argc, argv);
if (params.svg) {
set_svg_parameters(params);
if(! svg_init()) {
fprintf (stderr, "%s\n", get_last_error_message());
exit(EXIT_FAILURE);
}
node_destroyer = destroy_svg_node_data;
}
while (NULL != (tree = parse_tree())) {
align_leaves = is_cladogram(tree);
/* show scale bar IFF tree is NOT a cladogram. Since
* is_cladogram() takes some time to run, we just look
* up 'align_leaves' which has the same value. */
with_scale_bar = !align_leaves;
/* User can also suppress scale bar */
if (params.no_scale_bar) with_scale_bar = FALSE;
if (params.svg) {
svg_header(leaf_count(tree), with_scale_bar);
svg_run_params_comment(argc, argv);
status = display_svg_tree(tree,
align_leaves, with_scale_bar,
params.branch_length_unit);
switch(status) {
case DISPLAY_OK:
break;
assert(0);
case DISPLAY_MEM_ERROR:
perror(NULL);
exit(EXIT_FAILURE);
/* The following two should never happen */
case DISPLAY_UNKNOWN_STYLE:
default:
assert(0);
}
svg_footer();
} else {
prettify_labels(tree);
status = display_tree(tree, params.width,
align_leaves,
params.inner_label_pos,
with_scale_bar,
params.branch_length_unit,
params.scale_zero_at_root);
switch(status) {
case DISPLAY_OK:
break;
assert(0);
case DISPLAY_MEM_ERROR:
perror(NULL);
exit(EXIT_FAILURE);
/* The following two should never happen */
case DISPLAY_UNKNOWN_STYLE:
default:
assert(0);
}
}
destroy_tree_cb(tree, node_destroyer);
}
return 0;
}
void mexFunction( int nlhs, mxArray **plhs, int nrhs, const mxArray **prhs){
Tree *tree;
double *reference, *model;
int *index, i;
unsigned int N, D, M;
double *closest_pts, *distances, *pointer_to_tree;
int SkipQueries=0;
if (nrhs <2 ){
mexErrMsgTxt("Must have at least two input arrays.");
}
#ifdef DEBUG
mexPrintf("Mex function called with %d inputs and %d explicit outputs\n",nrhs,nlhs);
#endif
reference = mxGetPr(prhs[0]);
N = mxGetM(prhs[0]);
D = mxGetN(prhs[0]);
if ((!N || !D ) && ( nrhs < 3) )
mexErrMsgTxt("You have to supply some reference points to build a k-D tree.");
#ifdef TIME
gettimeofday(&tv1,&tz);
#endif
//
//
// If the tree is not passed in as a third input, we must build it
//
//
if (nrhs < 3 ){
#ifdef DEBUG
mexPrintf("----------------------\n");
mexPrintf("Building k-D Tree ...\n");
#endif
index = (int*) malloc( sizeof(int) * N);
for (i=0; i < N; i++) index[i]=i;
if ( (tree = build_kdtree(reference,N,D,index,N,0))==NULL ){
free(index);
mexErrMsgTxt("Not enough free memory to build k-D tree\n");
} else {
tree->dims = D;
free(index);
}
#ifdef DEBUG
mexPrintf("Done Building k-D Tree\n");
mexPrintf("----------------------\n");
#endif
} else {
//
// The tree was built previously, and is now being passed in to the function.
//
//
// The tree was built previously, and is now being passed in to the function.
//
if ( (pointer_to_tree = mxGetPr(prhs[2])) == NULL )
mexErrMsgTxt("Third argument is not a valid pointer to a k-D tree\n");
if ( (tree = (Tree *) ((long) pointer_to_tree[0]))== NULL )
mexErrMsgTxt("Third argument is not a valid pointer to a k-D tree\n");
}
#ifdef TIME
gettimeofday(&tv2,&tz);
if (tv2.tv_usec - tv1.tv_usec < 0) {
tv2.tv_sec--;
tv2.tv_usec += 1000000;
}
mexPrintf("Time to Build Tree : %f\n", tv2.tv_sec -tv1.tv_sec+(tv2.tv_usec-tv1.tv_usec)/1000000.0);
#endif
#ifdef DISPLAY_TREE
mexPrintf("\nDepth first traversal of the k-D tree\n");
mexPrintf("-------------------------------------\n");
display_tree(tree->rootptr,D);
mexPrintf("-------------------------------------\n");
#endif
//
// Query section
//
//
model = mxGetPr(prhs[1]);
M = mxGetM(prhs[1]);
if (!model && !M) {
// There are no points to query
SkipQueries=1;
} else {
// Check that the model points are of the same dimension as the
// reference points in the k-d tree.
if (mxGetN(prhs[1]) != tree->dims)
mexErrMsgTxt("Reference and Model Vectors must be of the same dimension");
}
if (nlhs >=0){
plhs[0] = mxCreateDoubleMatrix(M, tree->dims,mxREAL);
closest_pts = mxGetPr(plhs[0]);
}
else{
closest_pts = (double *) malloc (sizeof(double) *M* (tree->dims));
}
if (nlhs >=2) {
plhs[1] = mxCreateDoubleMatrix(M,1,mxREAL);
distances = mxGetPr(plhs[1]);
}
else {
distances = (double *) malloc (sizeof(double)*M);
}
if (nlhs >=3) {
plhs[2] = mxCreateDoubleMatrix(1,1,mxREAL);
pointer_to_tree = mxGetPr(plhs[2]);
pointer_to_tree[0] = (long) tree;
}
if (!SkipQueries) {
#ifdef TIME
gettimeofday(&tv1,&tz);
#endif
#ifdef DEBUG
mexPrintf("--------------------\n");
mexPrintf("Running Queries...\n");
#endif
run_queries(tree->rootptr, model, M, tree->dims, closest_pts,
distances, RETURN_POINTS);
#ifdef DEBUG
mexPrintf("Done Running Queries\n");
mexPrintf("--------------------\n");
#endif
#ifdef TIME
gettimeofday(&tv2,&tz);
if (tv2.tv_usec - tv1.tv_usec < 0) {
tv2.tv_sec--;
tv2.tv_usec += 1000000;
}
mexPrintf("Time per Search : %f\n",
(tv2.tv_sec - tv1.tv_sec +
(tv2.tv_usec-tv1.tv_usec) /1000000.0 )/(double)M);
#endif
}
if (nlhs<3) {
#ifdef DEBUG
mexPrintf("-------------------------------------\n");
mexPrintf("Removing k-D Tree from system memory.\n");
#endif
free_tree(tree->rootptr);
free(tree);
#ifdef DEBUG
mexPrintf("Done.\n");
mexPrintf("-------------------------------------\n");
#endif
if (nlhs < 2){
free(distances);
}
} else{
#ifdef DEBUG
mexPrintf("--------------------------------\n");
mexPrintf("k-D Tree saved in system memory.\n");
mexPrintf("Don't forget to remove it later.\n");
mexPrintf("--------------------------------\n");
#endif
}
#ifdef DEBUG
mexPrintf("Mex function has exited normally.\n");
#endif
}
