bool
edit_interface_rep::set_hybrid_footer (tree st) {
// WARNING: update edit_dynamic_rep::activate_hybrid when updating this
if (is_atomic (st))
if (is_func (subtree (et, path_up (tp, 2)), HYBRID, 1)) {
string msg;
// macro argument
string name= st->label;
path mp= search_upwards (MACRO);
if (!is_nil (mp)) {
tree mt= subtree (et, mp);
int i, n= N(mt)-1;
for (i=0; i<n; i++)
if (mt[i] == name) {
set_message (concat (kbd ("return"), ": insert argument ", name),
"hybrid command");
return true;
}
}
// macro application
tree f= get_env_value (name);
if (drd->contains (name) && (f == UNINIT))
set_message (concat (kbd ("return"), ": insert primitive ", name),
"hybrid command");
else if (is_func (f, MACRO) || is_func (f, XMACRO))
set_message (concat (kbd ("return"), ": insert macro ", name),
"hybrid command");
else if (f != UNINIT)
set_message (concat (kbd ("return"), ": insert value ", name),
"hybrid command");
else return false;
return true;
}
return false;
}
path
edit_select_rep::selection_get_subtable (
int& row1, int& col1, int& row2, int& col2)
{
if (selection_active_table ()) {
path fp= ::table_search_format (et, common (start_p, end_p));
if (is_nil (fp)) return fp;
tree st= subtree (et, fp);
table_search_coordinates (st, tail (start_p, N(fp)), row1, col1);
table_search_coordinates (st, tail (end_p, N(fp)), row2, col2);
if (row1>row2) { int tmp= row1; row1= row2; row2= tmp; }
if (col1>col2) { int tmp= col1; col1= col2; col2= tmp; }
table_bound (fp, row1, col1, row2, col2);
return fp;
}
else if (selection_active_table (false)) {
path fp= ::table_search_format (et, common (start_p, end_p) * 0);
if (is_nil (fp)) return fp;
path p= fp;
tree st;
while (true) {
st= subtree (et, p);
if (is_func (st, TABLE) && N(st) > 0 && is_func (st[0], ROW)) break;
if (!is_func (st, TFORMAT)) return path ();
p= p * (N(st) - 1);
}
row1= 0; col1= 0;
row2= N(st)-1; col2= N(st[0])-1;
return fp;
}
else return path ();
}
path
edit_cursor_rep::make_cursor_accessible (path p, bool forwards) {
//time_t t1= texmacs_time ();
path start_p= p;
bool inverse= false;
int old_mode= get_access_mode ();
if (get_init_string (MODE) == "src")
set_access_mode (DRD_ACCESS_SOURCE);
while (!is_accessible_cursor (et, p) && !in_source ()) {
path pp;
ASSERT (rp <= p, "path outside document");
p= rp * closest_inside (subtree (et, rp), p / rp);
if (forwards ^ inverse)
pp= rp * next_valid (subtree (et, rp), p / rp);
else
pp= rp * previous_valid (subtree (et, rp), p / rp);
if (pp == p) {
if (inverse) break;
else { p= start_p; inverse= true; }
}
else p= pp;
}
set_access_mode (old_mode);
//time_t t2= texmacs_time ();
//if (t2-t1 >= 1) cout << "made_cursor_accessible took " << t2-t1 << "ms\n";
return p;
}
path
find_subtable_selection (tree et, path p1, path p2,
int& row1, int& col1, int& row2, int& col2) {
if (is_table_selection (et, p1, p2, true)) {
path fp= table_search_format (et, common (p1, p2));
if (is_nil (fp)) return fp;
tree st= subtree (et, fp);
table_search_coordinates (st, tail (p1, N(fp)), row1, col1);
table_search_coordinates (st, tail (p2, N(fp)), row2, col2);
if (row1>row2) { int tmp= row1; row1= row2; row2= tmp; }
if (col1>col2) { int tmp= col1; col1= col2; col2= tmp; }
// table_bound (fp, row1, col1, row2, col2);
// FIXME: table editing routines should be moved to src/Data/Tree
return fp;
}
else if (is_table_selection (et, p1, p2, false)) {
path fp= table_search_format (et, common (p1, p2) * 0);
if (is_nil (fp)) return fp;
path p= fp;
tree st;
while (true) {
st= subtree (et, p);
if (is_func (st, TABLE) && N(st) > 0 && is_func (st[0], ROW)) break;
if (!is_func (st, TFORMAT)) return path ();
p= p * (N(st) - 1);
}
row1= 0; col1= 0;
row2= N(st)-1; col2= N(st[0])-1;
return fp;
}
else return path ();
}
static path
table_search_format (tree t, path p) {
tree st= subtree (t, p);
if (is_func (st, TFORMAT) && is_func (st[N(st)-1], TABLE)) return p;
while ((!is_nil (p)) && (!is_func (subtree (t, p), TABLE))) p= path_up (p);
if ((!is_nil (p)) && (is_func (subtree (t, path_up (p)), TFORMAT)))
p= path_up (p);
return p;
}
int subtree(tree *t1,tree *t2)
{
if(t1==NULL)
return 0;
if(t1->element==t2->element)
if(match_tree(t1,t2))
return 1;
return subtree(t1->left,t2)||subtree(t1->right,t2);
}
// check if node2 tree is subtree of node1 tree
bool subtree(treeNode *node1, treeNode *node2){
if(node1 == NULL){
return false; // tree1 is empty
}
else if(node1->data == node2->data){
return matchTree(node1, node2);
}
else{
return subtree(node1->left, node2) || subtree(node1->right, node2);
}
}
edit_main_rep::edit_main_rep (server_rep* sv, tm_buffer buf):
editor_rep (sv, buf), props (UNKNOWN), ed_obs (edit_observer (this))
{
#ifdef EXPERIMENTAL
cct= copy (subtree (et, rp));
copy_ip (subtree (et, rp), cct);
#endif
attach_observer (subtree (et, rp), ed_obs);
notify_change (THE_TREE);
tp= correct_cursor (et, rp * 0);
}
bool
admissible_selection (gr_selection sel) {
if (sel->type != "box" || N(sel->cp) != 1) return true;
if (last_item (sel->cp[0]) < 0 || N(sel->cp[0]) <= 2) return true;
path p= path_up (sel->cp[0]);
if (!has_subtree (the_et, p)) return true;
tree st= subtree (the_et, p);
if (is_compound (st, "anim-edit")) return false;
tree pt= subtree (the_et, path_up (p));
if (is_func (st, WITH) && is_compound (pt, "anim-edit")) return false;
return true;
}
void
edit_select_rep::cut (path p1, path p2) {
path p = common (p1, p2);
tree st= subtree (et, p);
raw_cut (p1, p2);
if (!is_func (st, TFORMAT) &&
!is_func (st, TABLE) &&
!is_func (st, ROW) &&
!is_document (subtree (et, p)) &&
is_concat (subtree (et, path_up (p))))
correct_concat (path_up (p));
}
bool subtree(Node<T> *a, Node<T> *b)
{
if (!a)
return false;
if (a->data == b->data)
{
if (matchTree(a, b))
return true;
}
return subtree(a->left, b) || subtree(a->right, b);
}
AlnusPhyolgeticBranch*
AlnusNewickParser::descendants()
{
AlnusPhyolgeticBranch *branch = new AlnusPhyolgeticBranch;
AlnusPhyolgeticBranch *childBranch = subtree();
branch->addChild(childBranch);
while (mOperator == Operator::COMMA) {
next();
childBranch = subtree();
branch->addChild(childBranch);
}
return branch;
}
void subtree(int *n, int *merge, int *node, int *pknode, int *pktree)
{
int i,j,k,temp,length,temp1,temp2, nn;
int *letree, *ritree;
int *lenode, *rinode;
temp=*node;
length=*n;
letree=(int *)malloc((length+1)*sizeof(int));
ritree=(int *)malloc((length+1)*sizeof(int));
lenode=(int *)malloc(length*sizeof(int));
rinode=(int *)malloc(length*sizeof(int));
nn=length+1;
i=temp-1;
temp1=*(merge+i);
j=length+i;
temp2=*(merge+j);
for(i=0;i<nn;i++)
{
letree[i]=0;
ritree[i]=0;
}
for(j=0;j<length;j++)
{
lenode[j]=0;
rinode[j]=0;
}
if(temp1<0)
pktree[-temp1-1]=1;
else
{
subtree(n, merge, &temp1, lenode, letree);
OrVector(n,lenode, pknode);
OrVector(&nn, letree, pktree);
}
if(temp2<0)
pktree[-temp2-1]=1;
else
{
subtree(n, merge, &temp2, rinode, ritree);
OrVector(n,rinode, pknode);
OrVector(&nn, ritree, pktree);
}
*(pknode+temp-1)=1;
}
bool
edit_interface_rep::set_latex_footer (tree st) {
if (is_atomic (st))
if (is_func (subtree (et, path_up (tp, 2)), LATEX, 1) ||
is_func (subtree (et, path_up (tp, 2)), HYBRID, 1)) {
string s= st->label;
string help;
command cmd;
if (sv->kbd_get_command (s, help, cmd)) {
set_left_footer (concat (kbd ("return"), ": " * help));
set_right_footer ("latex command");
return true;
}
}
return false;
}
void Path::moveLeft(unsigned Level) {
assert(Level != 0 && "Cannot move the root node");
// Go up the tree until we can go left.
unsigned l = 0;
if (valid()) {
l = Level - 1;
while (path[l].offset == 0) {
assert(l != 0 && "Cannot move beyond begin()");
--l;
}
} else if (height() < Level)
// end() may have created a height=0 path.
path.resize(Level + 1, Entry(nullptr, 0, 0));
// NR is the subtree containing our left sibling.
--path[l].offset;
NodeRef NR = subtree(l);
// Get the rightmost node in the subtree.
for (++l; l != Level; ++l) {
path[l] = Entry(NR, NR.size() - 1);
NR = NR.subtree(NR.size() - 1);
}
path[l] = Entry(NR, NR.size() - 1);
}
bool
edit_interface_rep::complete_try () {
tree st= subtree (et, path_up (tp));
if (is_compound (st)) return false;
string s= st->label, ss;
int end= last_item (tp);
array<string> a;
if (inside (LABEL) || inside (REFERENCE) || inside (PAGEREF)) {
if (end != N(s)) return false;
ss= copy (s);
tree t= get_labels ();
int i, n= N(t);
for (i=0; i<n; i++)
if (is_atomic (t[i]) && starts (t[i]->label, s))
a << string (t[i]->label (N(s), N(t[i]->label)));
}
else {
if ((end==0) || (!is_iso_alpha (s[end-1])) ||
((end!=N(s)) && is_iso_alpha (s[end]))) return false;
int start= end-1;
while ((start>0) && is_iso_alpha (s[start-1])) start--;
ss= s (start, end);
a= find_completions (drd, et, ss);
}
if (N(a) == 0) return false;
complete_start (ss, a);
return true;
}
void
edit_process_rep::generate_aux (string which) {
// path saved_path= tp;
generate_aux_recursively (which, subtree (et, rp), rp);
// if (which == "") go_to (saved_path);
// ... may be problematic if cursor was inside regenerated content
}
void
edit_interface_rep::complete_start (string prefix, array<string> compls) {
// check consistency
tree st= subtree (et, path_up (tp));
if (is_compound (st)) return;
string s= st->label;
int end= last_item (tp);
if ((end<N(prefix)) || (s (end-N(prefix), end) != prefix)) return;
// perform first completion and switch to completion mode if necessary
if (N (compls) == 1) {
string s= compls[0];
if (ends (s, "()")) // temporary fix for Pari
insert_tree (s, path (N(s)-1));
else insert_tree (s);
completions= array<string> ();
}
else {
completion_prefix= prefix;
completions = close_completions (compls);
completion_pos = 0;
insert_tree (completions[0]);
complete_message ();
beep ();
set_input_mode (INPUT_COMPLETE);
}
}
void
edit_select_rep::select (path p1, path p2) {
//cout << "Select " << p1 << " -- " << p2 << "\n";
if (start_p == p1 && end_p == p2) return;
if (!(rp <= p1 && rp <= p2)) return;
if (start_p == end_p && p1 == p2) {
start_p= copy (p1);
end_p = copy (p2);
return;
}
if (p1 != p2) {
path cp= common (p1, p2);
tree st= subtree (et, cp);
if (!is_func (st, TABLE) && !is_func (st, ROW))
(void) semantic_select (cp, p1, p2, 0);
}
if (path_less (p1, p2)) {
start_p= copy (p1);
end_p = copy (p2);
}
else {
start_p= copy (p2);
end_p = copy (p1);
}
notify_change (THE_SELECTION);
}
void
edit_typeset_rep::typeset_invalidate_all () {
//cout << "Invalidate all\n";
notify_change (THE_ENVIRONMENT);
typeset_preamble ();
::notify_assign (ttt, path(), subtree (et, rp));
}
bool isSubtree(Tree<T> &a, Tree<T> &b)
{
if (!b.root)
return true;
return subtree(a.root, b.root);
}
bool
join (modification& m1, modification m2, tree t) {
if (m1->k == MOD_INSERT &&
m2->k == MOD_INSERT &&
is_atomic (m1->t) &&
root (m1) == root (m2) &&
(index (m2) == index (m1) ||
index (m2) == index (m1) + N (m1->t->label)))
{
string s= m1->t->label * m2->t->label;
if (index (m2) == index (m1))
s= m2->t->label * m1->t->label;
m1= mod_insert (root (m1), index (m1), tree (s));
return true;
}
if (m1->k == MOD_REMOVE &&
m2->k == MOD_REMOVE &&
is_atomic (subtree (t, root (m1))) &&
root (m1) == root (m2) &&
(index (m1) == index (m2) ||
index (m1) == index (m2) + argument (m2)))
{
m1= mod_remove (root (m2), index (m2),
argument (m1) + argument (m2));
return true;
}
return false;
}
void
edit_select_rep::selection_get (selection& sel) {
if (selection_active_table ()) {
int row1, col1, row2, col2;
path fp= selection_get_subtable (row1, col1, row2, col2);
tree st= subtree (et, fp);
int i, j;
rectangle r (0, 0, 0, 0);
for (i=row1; i<=row2; i++)
for (j=col1; j<=col2; j++) {
path cp= fp * ::table_search_cell (st, i, j);
sel= eb->find_check_selection (cp * 0, cp * 1);
if (sel->valid) {
rectangles rs= sel->rs;
if (r != rectangle (0, 0, 0, 0)) rs= rectangles (r, rs);
r= least_upper_bound (rs);
}
}
sel= selection (rectangles (r), fp * 0, fp * 1);
}
else {
path p_start, p_end;
//cout << "Find " << start_p << " -- " << end_p << "\n";
selection_correct (start_p, end_p, p_start, p_end);
//cout << "Find " << p_start << " -- " << p_end << "\n";
sel= eb->find_check_selection (p_start, p_end);
//cout << "sel= " << sel << "\n";
}
}
void
edit_typeset_rep::typeset_sub (SI& x1, SI& y1, SI& x2, SI& y2) {
//time_t t1= texmacs_time ();
typeset_prepare ();
eb= empty_box (reverse (rp));
// saves memory, also necessary for change_log update
bench_start ("typeset");
#ifdef USE_EXCEPTIONS
try {
#endif
eb= ::typeset (ttt, x1, y1, x2, y2);
#ifdef USE_EXCEPTIONS
}
catch (string msg) {
the_exception= msg;
std_error << "Typesetting failure, resetting to empty document\n";
assign (rp, tree (DOCUMENT, ""));
::notify_assign (ttt, path(), subtree (et, rp));
eb= ::typeset (ttt, x1, y1, x2, y2);
}
handle_exceptions ();
#endif
bench_end ("typeset");
//time_t t2= texmacs_time ();
//if (t2 - t1 >= 10) cout << "typeset took " << t2-t1 << "ms\n";
picture_cache_clean ();
}
bool
edit_interface_rep::complete_keypress (string key) {
set_message ("", "");
if (key == "space") key= " ";
if ((key != "tab") && (key != "S-tab")) {
set_input_normal (); return false; }
tree st= subtree (et, path_up (tp));
if (is_compound (st)) {
set_input_normal (); return false; }
string s= st->label;
int end= last_item (tp);
string old_s= completions [completion_pos];
string test= completion_prefix * old_s;
if ((end<N(test)) || (s (end-N(test), end) != test)) {
set_input_normal (); return false; }
if (key == "tab") completion_pos++;
else completion_pos--;
if (completion_pos < 0) completion_pos= N(completions)-1;
if (completion_pos >= N(completions)) completion_pos= 0;
string new_s= completions [completion_pos];
remove (path_up (tp) * (end-N(old_s)), N(old_s));
insert (path_up (tp) * (end-N(old_s)), new_s);
complete_message ();
return true;
}
AlnusPhyolgeticTree* AlnusNewickParser::parse()
{
AlnusPhyolgeticTree *t = tree();
AlnusPhyolgeticBranch *root = subtree();
t->setRoot(root);
return t;
}
void
notify_remove_node (typesetter ttt, path p) {
// cout << "Remove node " << p << "\n";
tree t= subtree (ttt->br->st, p);
if (is_nil (path_up (p))) ttt->br= make_bridge (ttt, t, ttt->br->ip);
else ttt->br->notify_assign (path_up (p), t);
}
bool
has_player (path ip) {
path p= reverse (ip);
if (!has_subtree (the_et, p)) return false;
tree t= subtree (the_et, p);
blackbox bb;
return t->obs->get_contents (ADDENDUM_PLAYER, bb);
}
void
edit_graphics_rep::back_in_text_at (tree t, path p, bool forward) {
(void) forward;
int i= last_item (p);
if ((i == 0) && is_empty (t[0])) {
p= path_up (p);
if (is_func (subtree (et, path_up (p)), WITH)) p= path_up (p);
tree st= subtree (et, path_up (p));
if (is_func (st, GRAPHICS)) {
if (N(st) == 1) assign (p, "");
else {
remove (p, 1);
go_to_border (path_up (p) * 0, true);
}
}
}
}
bool containsTree(treeNode *node1, treeNode *node2){
if(node2 == NULL){
return true;
}
else{
return subtree(node1, node2);
}
}
