void ttext_::set_cursor(const size_t offset, const bool select) { if(select) { if(selection_start_ == offset) { selection_length_ = 0; } else { selection_length_ = - static_cast<int>(selection_start_ - offset); } #ifdef __unix__ // selecting copies on UNIX systems. copy_selection(true); #endif update_canvas(); set_dirty(true); } else { assert(offset <= text_.get_length()); selection_start_ = offset; selection_length_ = 0; update_canvas(); set_dirty(true); } }
void TE_View::copy() { Session* session = Session::instance(); Display* display = session->default_display(); SelectionManager* s = display->clipboard_selection(); // copy selection into selection buffer copy_selection(s); // mark selection as owned own_selection(s); }
read_request * copy_read_request (const read_request * r) { read_request * newreq; newreq = (read_request *) malloc (sizeof (read_request)); assert (newreq); newreq->sel = copy_selection (r->sel); newreq->varid = r->varid; newreq->from_steps = r->from_steps; newreq->nsteps = r->nsteps; newreq->data = r->data; newreq->datasize = r->datasize; newreq->priv = r->priv; newreq->next = 0; return newreq; }
static ADIOS_VARCHUNK * extract_chunk_from_finished_read_reqgroup(adios_transform_read_request *reqgroup) { assert(reqgroup); assert(reqgroup->completed); ADIOS_VARCHUNK *chunk = malloc(sizeof(ADIOS_VARCHUNK)); chunk->varid = reqgroup->raw_varinfo->varid; chunk->type = reqgroup->transinfo->orig_type; chunk->from_steps = reqgroup->from_steps; chunk->nsteps = reqgroup->nsteps; // Transfer ownership of orig_data chunk->data = reqgroup->orig_data; reqgroup->orig_data = NULL; // Transfer ownership of orig_sel chunk->sel = copy_selection(reqgroup->orig_sel); reqgroup->orig_sel = NULL; return chunk; }
void TE_View::release(const Event& e) { if (active_) { current_window_ = e.window(); SelectionManager* s = e.display()->primary_selection(); switch(drag_mode_) { case DragSelect: // copy and own current selection copy_selection(s); own_selection(s); break; case DragMenu: // unselect menu and unmap window menu_->release(e); menu_->unselect(); menu_window_->unmap(); menu_window_->unbind(); // required ?? break; default: break; } } }
void pvs_construct_hint(int selection, int forward, Char *hint) { PVSProof *p; FILE *f; Char *hintstr; ProofStep **cstep; KeywordItem *kwi; p = pvs_temporary_file(lasthintfile,&f); copy_selection(&p->selection, get_selection(selection)); { char lemmabuf[500]; sprintf(lemmabuf, "%s%i", UstrtoLocale(pvs_lemma_name), lastlemmanr); lastlemmanr++; p->lemma = strdup(lemmabuf); fprintf(f,"%s: THEOREM\n\t\t", lemmabuf); } cstep = &p->step; /* add an empty proof step to store the starting expression */ *cstep = malloc(sizeof(ProofStep)); (*cstep)->next=0; (*cstep)->keyword=0; (*cstep)->pvsinput=0; (*cstep)->comment=translate("starting formula"); (*cstep)->result=0; (*cstep)->failed=0; (*cstep)->steptype=SkipStep; (*cstep)->use_result=0; cstep = &((*cstep)->next); /* add the initial proof step to start the hints */ *cstep = malloc(sizeof(ProofStep)); (*cstep)->next=0; (*cstep)->keyword=get_pvskeyword(translate("INITSTEP")); (*cstep)->pvsinput=0; (*cstep)->comment=translate("initialisation steps"); (*cstep)->result=0; (*cstep)->failed=0; (*cstep)->use_result=0; (*cstep)->steptype=InitStep; cstep = &((*cstep)->next); kwi = get_pvskeyword(hint); if (kwi) { if (kwi->induct) { void *node; char *str=0; char *h; void *upsel; upsel=0; copy_selection(&upsel, p->selection); up_selection(upsel); tex_set_string(&str); tex_placeholders(0); latex_all_parens(MP_True); tex_mode(ASCII); node = first_node(upsel); latex_node(node); out_latex_char('='); node = last_node(upsel); latex_node(node); tex_unset(); latex_all_parens(MP_False); destruct_selection(upsel); /* ** Filter out '+(1)' and '+1'. ** This should be adjusted for allow induction on other types */ h=str; while (h && ((h=strstr(h,"+(1)")))) { int i; for (i=0; i<4;i++) h[i]=' '; h=h+4; } h=str; while (h && ((h=strstr(h,"+1")))) { int i; for (i=0; i<2;i++) h[i]=' '; h=h+2; } fprintf(f, "(%s) IMPLIES\n",str); free(str); } *cstep = malloc(sizeof(ProofStep)); (*cstep)->next=0; (*cstep)->keyword=kwi; (*cstep)->pvsinput=0; (*cstep)->comment=0; (*cstep)->result=0; (*cstep)->failed=0; (*cstep)->steptype=KeywordStep; (*cstep)->use_result=0; cstep = &((*cstep)->next); } { char *str=0; tex_set_string(&str); tex_placeholders(0); latex_all_parens(MP_True); tex_mode(ASCII); latex_selection(selection); tex_unset(); latex_all_parens(MP_False); if (using_booleans) { fprintf(f,"%s\n\n", str); } else { fprintf(f, "(%s) = Tresult\n\n", str); } } *cstep = malloc(sizeof(ProofStep)); (*cstep)->next=0; (*cstep)->keyword=get_pvskeyword(translate("RESULTSTEP")); (*cstep)->pvsinput=0; (*cstep)->comment=0; (*cstep)->result=0; (*cstep)->failed=0; (*cstep)->steptype=FinishStep; (*cstep)->use_result=(forward? 2:1); cstep = &((*cstep)->next); fprintf(f, "\nEND %s\n", p->theory); fclose(f); lasthintfile++; pvs_start_proof(p); }
void pvs_check_hint(int selection) { int nr,vnr; unsigned long uvnr=0; Char *hintstr; PVSProof *pvsproof; ProofStep **cstep; char *head; int assumptions=0; int np=0; int curlinenr=0; FILE *f; char buffer[1024]; /* check if hint is selected */ nr = selected_notation(selection, &vnr); if (nr>=0) uvnr = which_notation(nnr_vnr2innr(nr,0))->vers[vnr].vnr; if (nr<0 || uvnr<firsthintnr || uvnr> lasthintnr) { message(MP_ERROR, translate("No valid hint selected")); return; } pvsproof=pvs_temporary_file(lasthintfile, &f); { int pos[2]; copy_selection(&pvsproof->selection, get_selection(selection)); pos[0]=1;pos[1]=0; change_selection(pvsproof->selection, pos,2); } { char lemmabuf[500]; sprintf(lemmabuf, "%s%i", UstrtoLocale(pvs_lemma_name), lastlemmanr); lastlemmanr++; pvsproof->lemma = strdup(lemmabuf); fprintf(f,"%s: THEOREM\n\t\t", lemmabuf); curlinenr++; } assumptions=0; cstep = &pvsproof->step; /* add an empty proof step to store the starting expression */ *cstep = malloc(sizeof(ProofStep)); (*cstep)->next=0; (*cstep)->keyword=0; (*cstep)->pvsinput=0; (*cstep)->comment=translate("starting formula"); (*cstep)->result=0; (*cstep)->failed=0; (*cstep)->steptype=SkipStep; (*cstep)->use_result=0; cstep = &((*cstep)->next); /* add the initial proof step to start the hints */ *cstep = malloc(sizeof(ProofStep)); (*cstep)->next=0; (*cstep)->keyword=get_pvskeyword(translate("INITSTEP")); (*cstep)->pvsinput=0; (*cstep)->comment=translate("initialisation steps"); (*cstep)->result=0; (*cstep)->failed=0; (*cstep)->use_result=0; (*cstep)->steptype=InitStep; cstep = &((*cstep)->next); /* parse text in hint: ** - expression -> add to assumptions ** - "induction" -> add 'Ef = El' to assumptions ** (Ef: first expr., El: last expr, =: weakest operator) ** add (inst?)(ground)(try-triv-step (replace*)) to proof ** - "name" -> add (modulo-assoc (bidi-rewrite "name")) to proof ** - "definition" -> add (expand-simp* "def1" ... "defn") to proof ** (def1 ... defn extracted from expressions) ** - hidden PVS -> add content to proof */ { int pos[2]; pos[0]=1; pos[1]=0; hintstr = get_subnode_string(selection, pos,2); } if (!hintstr || !hintstr[0]) { /* empty hints usually indicate trivial steps */ hintstr = translate("trivial"); } while (*hintstr) { if (IsPh(hintstr[0])) { /* An expression, identifier, operator of text */ void *node; int pos[3]; char *str=0; pos[0]=1; pos[1]=0; pos[2]=np++; node = get_subnode(selection, pos, 3); nr = node_notation(node, &vnr); if (nr!= -1) uvnr = which_notation(nnr_vnr2innr(nr,0))->vers[0].vnr; tex_set_string(&str); tex_placeholders(0); latex_all_parens(MP_True); tex_mode(ASCII); latex_node(node); tex_unset(); latex_all_parens(MP_False); if (str && str[0]) { /* the expression produces output */ if (uvnr==pvshiddenstep) { /* a special PVS related template to add steps to the proof list */ *cstep = malloc(sizeof(ProofStep)); (*cstep)->next=0; (*cstep)->keyword=0; (*cstep)->pvsinput=str; (*cstep)->comment=translate("hidden proof steps"); (*cstep)->result=0; (*cstep)->failed=0; (*cstep)->use_result=0; (*cstep)->steptype=HiddenStep; cstep = &((*cstep)->next); } else { /* A normal expression. For now, an assumption, but it could be ** an identifier (as in "definition of $fold$") or ** a single operator (as in "$\times$ distributes over $\plus$") */ if (!assumptions) { fprintf(f,"(\t"); } else { fprintf(f,"\t\t AND "); } fprintf(f, "%s\n",str); curlinenr++; { char *h; for (h=str; *h; h++) { if (*h=='\n') curlinenr++; } } free(str); assumptions++; *cstep = malloc(sizeof(ProofStep)); (*cstep)->next=0; (*cstep)->keyword=get_pvskeyword(translate("EXPRESSIONSTEP")); (*cstep)->pvsinput=0; (*cstep)->comment=translate("assumption step"); (*cstep)->result=0; (*cstep)->failed=0; (*cstep)->use_result=0; (*cstep)->steptype=ExpressionStep; cstep = &((*cstep)->next); } } hintstr++; } else { KeywordItem *kwi= kwlist; kwi = get_pvskeyword(hintstr); if (kwi) { if (kwi->induct) { void *node; char *str=0; char *h; tex_set_string(&str); tex_placeholders(0); latex_all_parens(MP_True); tex_mode(ASCII); node = first_node(get_selection(selection)); latex_node(node); out_latex_char('='); node = last_node(get_selection(selection)); latex_node(node); tex_unset(); latex_all_parens(MP_False); /* ** Filter out '+(1)' and '+1'. ** This should be adjusted for allow induction on other types */ h=str; while (h && ((h=strstr(h,"+(1)")))) { int i; for (i=0; i<4;i++) h[i]=' '; h=h+4; } h=str; while (h && ((h=strstr(h,"+1")))) { int i; for (i=0; i<2;i++) h[i]=' '; h=h+2; } if (!assumptions) { fprintf(f,"(\t"); } else { fprintf(f,"\t\t AND "); } fprintf(f, "%s\n",str); curlinenr++; { char *nlc; for (nlc=str; *nlc; nlc++) { if (*nlc=='\n') curlinenr++; } } free(str); assumptions++; } if (kwi->step && kwi->step[0]) { *cstep = malloc(sizeof(ProofStep)); (*cstep)->next=0; (*cstep)->keyword=kwi; (*cstep)->pvsinput=0; (*cstep)->comment=0; (*cstep)->result=0; (*cstep)->failed=0; (*cstep)->use_result=0; (*cstep)->steptype=KeywordStep; cstep = &((*cstep)->next); } hintstr=hintstr+kwi->len; } /* might want to skip to the next place holder/word boundary */ hintstr++; } } if (assumptions) { fprintf(f,"\t\t) IMPLIES\n\t\t\t"); curlinenr++; } /* generate lemma */ { char *str=0; tex_set_string(&str); tex_placeholders(0); latex_all_parens(MP_True); tex_mode(ASCII); latex_selection(selection); tex_unset(); latex_all_parens(MP_False); { char *nlc; for (nlc=str; *nlc; nlc++) if (*nlc=='\n') curlinenr++; } fprintf(f, "%s\n\n", str); curlinenr += 2; } *cstep = malloc(sizeof(ProofStep)); (*cstep)->next=0; (*cstep)->keyword=get_pvskeyword(translate("FINISHSTEP")); (*cstep)->pvsinput=0; (*cstep)->comment=0; (*cstep)->result=0; (*cstep)->failed=0; (*cstep)->use_result=0; (*cstep)->steptype=FinishStep; cstep = &((*cstep)->next); fprintf(f, "\nEND %s\n", pvsproof->theory); fclose(f); lasthintfile++; /* start PVS proof of temporary lemma */ pvs_start_proof(pvsproof); /* pvs_start_proof starts the proof of the selected hint(s) ** and checks if each step is correct, by sending the step, ** parse the output, check for errors, send next step, etc. ** At the end, Q.E.D. should appear and the ** delivery. */ if (pvsproof) { ProofStep *ps; for (ps=pvsproof->step; ps; ps=ps->next) { if (ps->pvsinput) { string_to_window(translate("PVS Generated Proof"), LocaletoUstr((unsigned char*)ps->pvsinput)); } else if (ps->keyword && ps->keyword->step) { string_to_window(translate("PVS Generated Proof"), LocaletoUstr((unsigned char*)ps->keyword->step)); } } } /* set PVS parse function correct */ }
void ttext_::signal_handler_sdl_key_down(const event::tevent event , bool& handled , const SDLKey key , SDLMod modifier , const Uint16 unicode) { DBG_GUI_E << LOG_HEADER << ' ' << event << ".\n"; // For copy/paste we use a different key on the MAC. Other ctrl modifiers won't // be modifed seems not to be required when I read the comment in // widgets/textbox.cpp:516. Would be nice if somebody on a MAC would test it. #ifdef __APPLE__ const unsigned copypaste_modifier = KMOD_LMETA | KMOD_RMETA; #else const unsigned copypaste_modifier = KMOD_CTRL; #endif switch(key) { case SDLK_LEFT : handle_key_left_arrow(modifier, handled); break; case SDLK_RIGHT : handle_key_right_arrow(modifier, handled); break; case SDLK_UP : handle_key_up_arrow(modifier, handled); break; case SDLK_DOWN : handle_key_down_arrow(modifier, handled); break; case SDLK_PAGEUP : handle_key_page_up(modifier, handled); break; case SDLK_PAGEDOWN : handle_key_page_down(modifier, handled); break; case SDLK_a : if(!(modifier & KMOD_CTRL)) { handle_key_default(handled, key, modifier, unicode); break; } // If ctrl-a is used for home drop the control modifier modifier = static_cast<SDLMod>(modifier &~ KMOD_CTRL); /* FALL DOWN */ case SDLK_HOME : handle_key_home(modifier, handled); break; case SDLK_e : if(!(modifier & KMOD_CTRL)) { handle_key_default(handled, key, modifier, unicode); break; } // If ctrl-e is used for end drop the control modifier modifier = static_cast<SDLMod>(modifier &~ KMOD_CTRL); /* FALL DOWN */ case SDLK_END : handle_key_end(modifier, handled); break; case SDLK_BACKSPACE : handle_key_backspace(modifier, handled); break; case SDLK_u : if(modifier & KMOD_CTRL) { handle_key_clear_line(modifier, handled); } else { handle_key_default(handled, key, modifier, unicode); } break; case SDLK_DELETE : handle_key_delete(modifier, handled); break; case SDLK_c : if(!(modifier & copypaste_modifier)) { handle_key_default(handled, key, modifier, unicode); break; } // atm we don't care whether there is something to copy or paste // if nothing is there we still don't want to be chained. copy_selection(false); handled = true; break; case SDLK_x : if(!(modifier & copypaste_modifier)) { handle_key_default(handled, key, modifier, unicode); break; } copy_selection(false); delete_selection(); handled = true; break; case SDLK_v : if(!(modifier & copypaste_modifier)) { handle_key_default(handled, key, modifier, unicode); break; } paste_selection(false); handled = true; break; default : handle_key_default(handled, key, modifier, unicode); } if(text_changed_callback_) { text_changed_callback_(this, this->text()); } }
/** * Edit a stream * @param console_in stream to read console from * @param console_out stream to write console to * @param stream stream to read/write file to */ void muon_edit(handle_t console_in, handle_t console_out, const char *title, handle_t stream) { int rc; int i; editor_t *ed = (editor_t *) neutron_malloc(sizeof(editor_t)); memset(ed, 0, sizeof(editor_t)); ed->console_in = console_in; ed->console_out = console_out; ed->title = title; ed->anchor = -1; rc = load_file(ed, stream); get_console_size(ed); bool done = false; int key; ed->refresh = 1; while (!done) { if (ed->refresh) { draw_screen(ed); draw_full_statusline(ed); ed->refresh = 0; ed->lineupdate = 0; } else if (ed->lineupdate) { update_line(ed); ed->lineupdate = 0; draw_statusline(ed); } else { draw_statusline(ed); } position_cursor(ed); key = getkey(ed); if (key >= ' ' && key <= 0x7F) { insert_char(ed, (char) key); } else { switch (key) { case KEY_F1: help(ed); break; case KEY_F5: redraw_screen(ed); break; case KEY_UP: up(ed, 0); break; case KEY_DOWN: down(ed, 0); break; case KEY_LEFT: left(ed, 0); break; case KEY_RIGHT: right(ed, 0); break; case KEY_HOME: home(ed, 0); break; case KEY_END: end(ed, 0); break; case KEY_PGUP: pageup(ed, 0); break; case KEY_PGDN: pagedown(ed, 0); break; case KEY_CTRL_RIGHT: wordright(ed, 0); break; case KEY_CTRL_LEFT: wordleft(ed, 0); break; case KEY_CTRL_HOME: top(ed, 0); break; case KEY_CTRL_END: bottom(ed, 0); break; case KEY_SHIFT_UP: up(ed, 1); break; case KEY_SHIFT_DOWN: down(ed, 1); break; case KEY_SHIFT_LEFT: left(ed, 1); break; case KEY_SHIFT_RIGHT: right(ed, 1); break; case KEY_SHIFT_PGUP: pageup(ed, 1); break; case KEY_SHIFT_PGDN: pagedown(ed, 1); break; case KEY_SHIFT_HOME: home(ed, 1); break; case KEY_SHIFT_END: end(ed, 1); break; case KEY_SHIFT_CTRL_RIGHT: wordright(ed, 1); break; case KEY_SHIFT_CTRL_LEFT: wordleft(ed, 1); break; case KEY_SHIFT_CTRL_HOME: top(ed, 1); break; case KEY_SHIFT_CTRL_END: bottom(ed, 1); break; case ctrl('a'): select_all(ed); break; case ctrl('c'): copy_selection(ed); break; case ctrl('f'): find_text(ed, 0); break; case ctrl('l'): goto_line(ed); break; case ctrl('g'): find_text(ed, 1); break; case KEY_TAB: indent(ed, INDENT); break; case KEY_SHIFT_TAB: unindent(ed, INDENT); break; case KEY_ENTER: newline(ed); break; case KEY_BACKSPACE: backspace(ed); break; case KEY_DEL: del(ed); break; case ctrl('x'): cut_selection(ed); break; case ctrl('z'): undo(ed); break; case ctrl('r'): redo(ed); break; case ctrl('v'): paste_selection(ed); break; case ctrl('s'): save_editor(ed); break; case ctrl('q'): done = close_editor(ed); break; } } } gotoxy(ed, 0, ed->lines + 1); outstr(ed, RESET_COLOR CLREOL); if (ed->clipboard) neutron_free(ed->clipboard); if (ed->search) neutron_free(ed->search); if (ed->linebuf) neutron_free(ed->linebuf); clear_undo(ed); neutron_free(ed); }
void cut_selection(editor_t *ed) { copy_selection(ed); erase_selection(ed); }
int adios_read_flexpath_schedule_read_byid(const ADIOS_FILE *adiosfile, const ADIOS_SELECTION *sel, int varid, int from_steps, int nsteps, void *data) { fp_log("FUNC", "entering schedule_read_byid\n"); flexpath_reader_file * fp = (flexpath_reader_file*)adiosfile->fh; flexpath_var * var = fp->var_list; while(var){ if(var->id == varid) break; else var=var->next; } if(!var){ adios_error(err_invalid_varid, "Invalid variable id: %d\n", varid); return err_invalid_varid; } //store the user allocated buffer. flexpath_var_chunk *chunk = &var->chunks[0]; chunk->user_buf = data; var->start_position = 0; if(nsteps != 1){ adios_error (err_invalid_timestep, "Only one step can be read from a stream at a time. " "You requested % steps in adios_schedule_read()\n", nsteps); return err_invalid_timestep; } // this is done so that the user can do multiple schedule_read/perform_reads // within before doing release/advance step. Might need a better way to // manage the ADIOS selections. if(var->sel){ free_selection(var->sel); } var->sel = copy_selection(sel); switch(var->sel->type) { case ADIOS_SELECTION_WRITEBLOCK: { int writer_index = var->sel->u.block.index; if(writer_index > fp->num_bridges){ adios_error(err_out_of_bound, "No process exists on the writer side matching the index.\n"); return err_out_of_bound; } send_var_message(fp, writer_index, var->varname); break; } case ADIOS_SELECTION_BOUNDINGBOX: { free_displacements(var->displ, var->num_displ); var->displ = NULL; int j=0; int need_count = 0; array_displacements * all_disp = NULL; uint64_t pos = 0; double sched_start = MPI_Wtime(); for(j=0; j<fp->num_bridges; j++) { int destination=0; if(need_writer(fp, j, var->sel, fp->gp, var->varname)==1){ uint64_t _pos = 0; need_count++; destination = j; global_var *gvar = find_gbl_var(fp->gp->vars, var->varname, fp->gp->num_vars); // TODO: memory leak here. have to free these at some point. array_displacements *displ = get_writer_displacements(j, var->sel, gvar, &_pos); displ->pos = pos; _pos *= (uint64_t)var->type_size; pos += _pos; all_disp = realloc(all_disp, sizeof(array_displacements)*need_count); all_disp[need_count-1] = *displ; send_var_message(fp, j, var->varname); } } double sched_end = MPI_Wtime(); var->displ = all_disp; var->num_displ = need_count; break; } case ADIOS_SELECTION_AUTO: { adios_error(err_operation_not_supported, "ADIOS_SELECTION_AUTO not yet supported by flexpath."); break; } case ADIOS_SELECTION_POINTS: { adios_error(err_operation_not_supported, "ADIOS_SELECTION_POINTS not yet supported by flexpath."); break; } } fp_log("FUNC", "entering schedule_read_byid\n"); return 0; }
void TE_View::keystroke(const Event& e) { if (active_) { current_window_ = e.window(); // check if known key symbol unsigned long keysym = e.keysym(); for (TE_ViewKeySymInfo* k = &default_key_sym_map[0]; k->keysym != 0; k++) { if (keysym == k->keysym) { TE_ViewKeyFunc f = k->func; (this->*f)(); return; } } // map event to key signed char c; if (e.mapkey((char *)&c, 1) == 0) return; // check if known key map #ifndef __sgi /* avoid SGI gcc warning */ if (c >= 0) { // fix alt-V on linux/pc #else if (1) { #endif TE_ViewKeyFunc f = key_[c]; if (f != nil) { (this->*f)(); return; } } #ifndef __sgi /* avoid SGI gcc warning */ if (c >= 0 && (isspace(c) || !iscntrl(c))) #else if (isspace(c) || !iscntrl(c)) #endif insert_char(c); else printf("Unknown character - ignored!\n"); } } void TE_View::double_click(const Event& e) { if (active_) { boolean tripple_click = false; int dot, mark; unsigned long t = e.time(); if (t - click_time_ < threshold_) { tripple_click = true; } click_time_ = t; int index = event_to_index(e); text_editor_->Select(index); // select work or line if (tripple_click) { // line text_editor_->BeginningOfLine(); dot = text_editor_->Dot(); text_editor_->EndOfLine(); mark = text_editor_->Dot(); } else { // word text_editor_->BeginningOfWord(); dot = text_editor_->Dot(); text_editor_->EndOfWord(); mark = text_editor_->Dot(); } text_editor_->Select(dot, mark); // copy and own current selection SelectionManager* s = e.display()->primary_selection(); copy_selection(s); own_selection(s); } } void TE_View::popup_menu(const Event&e) { // display popup-menu const Window& rel = *e.window(); Coord x = rel.left() + e.pointer_x(); Coord y = rel.bottom() + e.pointer_y() - menu_window_->height() + 6; menu_window_->place(x, y); menu_window_->map(); } void TE_View::line_update() { // update line information lines_ = displayed_lines(); end_row_ = start_row_ + lines_ - 1; notify(); // notify adjustable }