static int check_buf(char *buf, t_win *win, int position, t_ios *term)
{
int select;
select = 0;
if (buf[0] == 32)
selection(win->arg, position, &select);
else if (buf[0] == 4)
{
if (tcsetattr(0, TCSADRAIN, term) == -1)
leave_term();
}
else if (buf[0] == 10)
print_selected(win->arg);
else if (buf[0] == 114)
select_reverse(win->arg);
else if (buf[0] == 97)
select_all(win->arg);
else if ((buf[0] == 126 || buf[0] == 127))
{
clr_screen();
win->arg = delete_link(win, position);
}
return (select);
}
bool Connection::table_exists( const string &table_name ) {
AttributeList parameters;
parameters.push_back( table_name );
RowSet rows = select_all( "SELECT name FROM sqlite_master WHERE type='table' AND name = ?;",
parameters );
return ( rows.size() ? true : false );
}
static void special_keys(unsigned int key, t_entlist *l)
{
if (key == K_SPACE)
{
l->list->hl = l->list->hl == 0 ? 1 : 0;
go_down(l);
}
else if (key == K_A)
{
l->sel_v = l->sel_v == 0 ? 1 : 0;
select_all(l, l->sel_v);
}
else if (key == K_R)
{
l->sel_v = l->sel_v == 0 ? 1 : 0;
select_specific(l, R, l->sel_v);
}
else if (key == K_D)
{
l->sel_v = l->sel_v == 0 ? 1 : 0;
select_specific(l, D, l->sel_v);
}
else if (key == K_X)
{
l->sel_v = l->sel_v == 0 ? 1 : 0;
select_specific(l, X, l->sel_v);
}
}
bool
BasicGrid::handle_event_impl(
UI::Event const& event
) noexcept {
switch (event.type) {
case UI::EventType::key_input:
if (!has_input_control() && event.key_input.mod == KeyMod::none) {
bool handled = true;
switch (event.key_input.code) {
case KeyCode::up : row_step(-1); break;
case KeyCode::down : row_step(+1); break;
case KeyCode::left : col_step(-1); break;
case KeyCode::right: col_step(+1); break;
case KeyCode::home: row_abs(0); break;
case KeyCode::end : row_abs(max_ce(0, row_count() - 1)); break;
case KeyCode::pgup:
row_step(min_ce(0, -view().fit_count - 1)); break;
case KeyCode::pgdn:
row_step(max_ce(0, +view().fit_count - 1)); break;
default:
switch (event.key_input.cp) {
case 'k': row_step(-1); break;
case 'j': row_step(+1); break;
case 'h': col_step(-1); break;
case 'l': col_step(+1); break;
case 'a': select_all(); break;
case 'A': select_none(); break;
case 's': select_toggle(m_cursor.row, 1); break;
default:
handled = false;
break;
}
}
return handled;
}
break;
case UI::EventType::focus_changed:
queue_cell_render(
m_cursor.row, m_cursor.row + 1,
m_cursor.col, m_cursor.col + 1
);
if (is_focused()) {
App::instance.m_ui.csline->set_location(
std::to_string(m_cursor.row) + ", " +
std::to_string(m_cursor.col)
);
} else {
App::instance.m_ui.csline->clear_location();
}
return false;
default:
break;
}
return false;
}
void
ttext_box::signal_handler_left_button_double_click(const event::tevent event,
bool& handled)
{
DBG_GUI_E << LOG_HEADER << ' ' << event << ".\n";
select_all();
handled = true;
}
/* Called for "None" button. */
static int none_cb()
{
/* unselect all grids */
select_all( DB, ALL_BITS, 0 );
LUI_ListSetStatusAll( gridlister, 0 );
LUI_ListSetStatusAll( varlister, 0 );
LUI_ListSetStatusAll( timelister, 0 );
LUI_ListSetStatusAll( projlister, 0 );
LUI_ListSetStatusAll( vcslister, 0 );
estimate_file_size();
return 0;
}
static gboolean keypress_cb (GtkWidget * widget, GdkEventKey * event)
{
if (event->keyval == GDK_A && (event->state && GDK_CONTROL_MASK))
select_all (NULL, TRUE);
else if (event->keyval == GDK_Delete)
remove_selected ();
else if (event->keyval == GDK_Escape)
gtk_widget_destroy (qm_win);
else
return FALSE;
return TRUE;
}
layer_manager::layer_manager(QWidget* parent) :
QWidget(parent),
layout_(new FlowLayout)
{
QSizePolicy policy(QSizePolicy::MinimumExpanding, QSizePolicy::MinimumExpanding);
policy.setHeightForWidth(true);
setSizePolicy(policy);
setLayout(layout_);
setFocusPolicy(Qt::StrongFocus);
auto shortcut = new QShortcut(QKeySequence(tr("Ctrl+A")), this);
connect(shortcut, SIGNAL(activated()), this, SLOT(select_all()));
}
void View_list::key_down(Core *c, Event *e, uint8_t key_name){
if (key_name == 'a'){
select_all();
return;
}
if (key_name == 'A'){
deselect_all();
return;
}
int32_t amount = 64;
if (key_name == 'N'){
scroll_all(c, e, amount, 0, 0);
return;
}
if (key_name == 'H'){
scroll_all(c, e, -amount, 0, 0);
return;
}
if (key_name == 'C'){
scroll_all(c, e, 0, amount, 0);
return;
}
if (key_name == 'T'){
scroll_all(c, e, 0, -amount, 0);
return;
}
if (key_name == 'l'){
layouter = new Virtical_layouter_v1;
return;
}
if (key_name == 's'){
layouter = new Horizontial_layouter_v1;
return;
}
if (key_name == '/'){
layouter = new Matrix_layouter;
return;
}
View* v = view_at(e->cursor());
if (not v) return;
if (key_name == 'x'){
v->reset_visible();
return;
}
v->key_down(c, e, key_name);
}
BOOL CListCtrlEx::PreTranslateMessage(MSG* pMsg)
{
if (pMsg->message == WM_KEYDOWN)
{
if (GetKeyState(VK_CONTROL) < 0)
{
switch (pMsg->wParam)
{
case 'A':
if (GetStyle() & LVS_SINGLESEL)
break;
select_all();
return true;
case VK_ADD:
auto_size();
return true;
}
}
}
return CListCtrl::PreTranslateMessage(pMsg);
}
void LineEdit::menu_option(int p_option) {
switch(p_option) {
case MENU_CUT: {
if (editable) {
cut_text();
}
}
break;
case MENU_COPY: {
copy_text();
}
break;
case MENU_PASTE: {
if (editable) {
paste_text();
}
}
break;
case MENU_CLEAR: {
if (editable) {
clear();
}
}
break;
case MENU_SELECT_ALL: {
select_all();
}
break;
case MENU_UNDO: {
undo();
}
break;
}
}
int main(int argc, char **argv)
{
int i, become_daemon = 1;
for(i=1; i<argc; i++) {
if(argv[i][0] == '-' && argv[i][2] == 0) {
switch(argv[i][1]) {
case 'd':
become_daemon = !become_daemon;
break;
case 'v':
verbose = 1;
break;
case 'h':
printf("usage: %s [options]\n", argv[0]);
printf("options:\n");
printf(" -d\tdo not daemonize\n");
printf(" -v\tverbose output\n");
printf(" -h\tprint this usage information\n");
return 0;
default:
fprintf(stderr, "unrecognized argument: %s\n", argv[i]);
return 1;
}
} else {
fprintf(stderr, "unexpected argument: %s\n", argv[i]);
return 1;
}
}
if(become_daemon) {
daemonize();
}
write_pid_file();
read_cfg("/etc/spnavrc", &cfg);
if(!(client_list = malloc(sizeof *client_list))) {
perror("failed to allocate client list");
return 1;
}
client_list->next = 0;
signal(SIGINT, sig_handler);
signal(SIGTERM, sig_handler);
signal(SIGSEGV, sig_handler);
signal(SIGHUP, sig_handler);
signal(SIGUSR1, sig_handler);
signal(SIGUSR2, sig_handler);
init_dev();
init_unix();
#ifdef USE_X11
init_x11();
#endif
/* event handling loop */
while(1) {
fd_set rd_set;
if(dev_fd == -1) {
if(init_dev() == -1) {
sleep(30);
continue;
}
}
if(select_all(&rd_set) >= 0) {
handle_events(&rd_set);
}
}
/* just for the sense of symmetry, execution can't reach this :) */
#ifdef USE_X11
close_x11();
#endif
close_dev();
return 0;
}
bool TextWidget::on_key_event(const KeyEvent *event) {
if (!_text_interaction_on)
return false;
if (_on_key_event(this, event)) {
// user ate this event
return true;
}
if (event->action == KeyActionUp)
return false;
int start, end;
get_cursor_slice(start, end);
switch (event->virt_key) {
case VirtKeyLeft:
if (key_mod_ctrl(event->modifiers) && key_mod_shift(event->modifiers)) {
int new_end = backward_word();
set_selection(_cursor_start, new_end);
} else if (key_mod_ctrl(event->modifiers)) {
int new_start = backward_word();
set_selection(new_start, new_start);
} else if (key_mod_shift(event->modifiers)) {
set_selection(_cursor_start, _cursor_end - 1);
} else {
if (start == end) {
set_selection(start - 1, start - 1);
} else {
set_selection(start, start);
}
}
return true;
case VirtKeyRight:
if (key_mod_ctrl(event->modifiers) && key_mod_shift(event->modifiers)) {
int new_end = forward_word();
set_selection(_cursor_start, new_end);
} else if (key_mod_ctrl(event->modifiers)) {
int new_start = forward_word();
set_selection(new_start, new_start);
} else if (key_mod_shift(event->modifiers)) {
set_selection(_cursor_start, _cursor_end + 1);
} else {
if (start == end) {
set_selection(start + 1, end + 1);
} else {
set_selection(end, end);
}
}
return true;
case VirtKeyBackspace:
if (start == end) {
if (key_mod_ctrl(event->modifiers)) {
int new_start = backward_word();
replace_text(new_start, start, "", 0);
} else {
replace_text(start - 1, end, "", 0);
}
} else {
replace_text(start, end, "", 0);
}
return true;
case VirtKeyDelete:
if (start == end) {
if (key_mod_ctrl(event->modifiers)) {
int new_start = forward_word();
replace_text(start, new_start, "", 0);
} else {
replace_text(start, end + 1, "", 0);
}
} else {
replace_text(start, end, "", 0);
}
return true;
case VirtKeyHome:
if (key_mod_shift(event->modifiers)) {
set_selection(_cursor_start, 0);
} else {
set_selection(0, 0);
}
return true;
case VirtKeyEnd:
if (key_mod_shift(event->modifiers)) {
set_selection(_cursor_start, _label.text().length());
} else {
set_selection(_label.text().length(), _label.text().length());
}
return true;
case VirtKeyA:
if (key_mod_only_ctrl(event->modifiers)) {
select_all();
return true;
}
case VirtKeyX:
if (key_mod_only_ctrl(event->modifiers)) {
cut();
return true;
}
case VirtKeyC:
if (key_mod_only_ctrl(event->modifiers)) {
copy();
return true;
}
case VirtKeyV:
if (key_mod_only_ctrl(event->modifiers)) {
paste();
return true;
}
default:
// do nothing
return true;
}
}
void disable(void) { select_all(); Set_Display_On_Off(0); select(0); }
void enable(void) { select_all(); Set_Display_On_Off(1); select(0); }
//void print_digit(u8 digit, u8 start_page, u8 start_col);
void set_brightness(u8 brightness) { select_all(); Set_Contrast_Control(brightness); select(0); }
void UnitTestBulkData::testChangeParts_loop( ParallelMachine pm )
{
enum { nPerProc = 10 };
const unsigned p_rank = parallel_machine_rank( pm );
const unsigned p_size = parallel_machine_size( pm );
const unsigned nLocalNode = nPerProc + ( 1 < p_size ? 1 : 0 );
const unsigned nLocalEdge = nPerProc ;
UnitTestRingMeshFixture ring_mesh( pm , nPerProc , true /* generate parts */ );
ring_mesh.m_meta_data.commit();
ring_mesh.generate_mesh( false /* no aura */ );
Part & part_owns = ring_mesh.m_meta_data.locally_owned_part();
Part & part_univ = ring_mesh.m_meta_data.universal_part();
Selector select_owned( ring_mesh.m_meta_data.locally_owned_part() );
Selector select_used = select_owned | ring_mesh.m_meta_data.globally_shared_part();
Selector select_all( ring_mesh.m_meta_data.universal_part() );
std::vector<unsigned> local_count ;
for ( unsigned i = 0 ; i < nLocalEdge ; ++i ) {
const unsigned n = i + nPerProc * p_rank ;
Entity * const edge = ring_mesh.m_bulk_data.get_entity( 1 , ring_mesh.m_edge_ids[n] );
STKUNIT_ASSERT( edge != NULL );
STKUNIT_ASSERT( edge->bucket().member( part_univ ) );
STKUNIT_ASSERT( edge->bucket().member( part_owns ) );
STKUNIT_ASSERT( edge->bucket().member( * ring_mesh.m_edge_parts[ n % ring_mesh.m_edge_parts.size() ] ) );
}
for ( unsigned i = 0 ; i < nLocalNode ; ++i ) {
const unsigned n = ( i + nPerProc * p_rank ) % ring_mesh.m_node_ids.size();
const unsigned e0 = n ;
const unsigned e1 = ( n + ring_mesh.m_edge_ids.size() - 1 ) % ring_mesh.m_edge_ids.size();
const unsigned ns = ring_mesh.m_edge_parts.size();
const unsigned n0 = e0 % ns ;
const unsigned n1 = e1 % ns ;
Part * const epart_0 = ring_mesh.m_edge_parts[ n0 < n1 ? n0 : n1 ];
Part * const epart_1 = ring_mesh.m_edge_parts[ n0 < n1 ? n1 : n0 ];
Entity * const node = ring_mesh.m_bulk_data.get_entity( 0 , ring_mesh.m_node_ids[n] );
STKUNIT_ASSERT( node != NULL );
if ( node->owner_rank() == p_rank ) {
STKUNIT_ASSERT( node->bucket().member( part_univ ) );
STKUNIT_ASSERT( node->bucket().member( part_owns ) );
STKUNIT_ASSERT( node->bucket().member( *epart_0 ) );
STKUNIT_ASSERT( node->bucket().member( *epart_1 ) );
}
else {
STKUNIT_ASSERT( node->bucket().member( part_univ ) );
STKUNIT_ASSERT( ! node->bucket().member( part_owns ) );
STKUNIT_ASSERT( node->bucket().member( * epart_0 ) );
STKUNIT_ASSERT( node->bucket().member( * epart_1 ) );
}
}
ring_mesh.m_bulk_data.modification_begin();
if ( 0 == p_rank ) {
for ( unsigned i = 0 ; i < nLocalEdge ; ++i ) {
const unsigned n = i + nPerProc * p_rank ;
PartVector add(1); add[0] = & ring_mesh.m_edge_part_extra ;
PartVector rem(1); rem[0] = ring_mesh.m_edge_parts[ n % ring_mesh.m_edge_parts.size() ];
Entity * const edge = ring_mesh.m_bulk_data.get_entity( 1 , ring_mesh.m_edge_ids[n] );
ring_mesh.m_bulk_data.change_entity_parts( *edge , add , rem );
STKUNIT_ASSERT( edge->bucket().member( part_univ ) );
STKUNIT_ASSERT( edge->bucket().member( part_owns ) );
STKUNIT_ASSERT( edge->bucket().member(ring_mesh.m_edge_part_extra ) );
}
}
ring_mesh.m_bulk_data.modification_end();
for ( unsigned i = 0 ; i < nLocalNode ; ++i ) {
const unsigned n = ( i + nPerProc * p_rank ) % ring_mesh.m_node_ids.size();
const unsigned e0 = n ;
const unsigned e1 = ( n + ring_mesh.m_edge_ids.size() - 1 ) % ring_mesh.m_edge_ids.size();
const unsigned ns = ring_mesh.m_edge_parts.size();
const unsigned n0 = e0 % ns ;
const unsigned n1 = e1 % ns ;
Part * ep_0 = e0 < nLocalEdge ? & ring_mesh.m_edge_part_extra : ring_mesh.m_edge_parts[n0] ;
Part * ep_1 = e1 < nLocalEdge ? & ring_mesh.m_edge_part_extra : ring_mesh.m_edge_parts[n1] ;
Part * epart_0 = ep_0->mesh_meta_data_ordinal() < ep_1->mesh_meta_data_ordinal() ? ep_0 : ep_1 ;
Part * epart_1 = ep_0->mesh_meta_data_ordinal() < ep_1->mesh_meta_data_ordinal() ? ep_1 : ep_0 ;
Entity * const node = ring_mesh.m_bulk_data.get_entity( 0 , ring_mesh.m_node_ids[n] );
STKUNIT_ASSERT( node != NULL );
if ( node->owner_rank() == p_rank ) {
STKUNIT_ASSERT( node->bucket().member( part_owns ) );
}
else {
STKUNIT_ASSERT( ! node->bucket().member( part_owns ) );
}
STKUNIT_ASSERT( node->bucket().member( part_univ ) );
STKUNIT_ASSERT( node->bucket().member( *epart_0 ) );
STKUNIT_ASSERT( node->bucket().member( *epart_1 ) );
}
}
void
get_commands()
{
int ch;
for(;;) {
can_resize = TRUE; /* it's safe to resize now */
if(!opt_get_bool(BOOL_SHOW_CURSOR))
hide_cursor();
if(should_resize)
refresh_screen();
ch = getch();
if(!opt_get_bool(BOOL_SHOW_CURSOR))
show_cursor();
can_resize = FALSE; /* it's not safe to resize anymore */
switch(ch) {
case 'q':
return;
case 'Q':
quit_abook(QUIT_DONTSAVE);
break;
case 'P':
print_stderr(selected_items() ?
-1 : list_get_curitem());
return;
case '?':
display_help(HELP_MAIN);
refresh_screen();
break;
case 'a':
add_item();
break;
case '\r':
edit_item(-1);
break;
case KEY_DC:
case 'd':
case 'r':
ui_remove_items();
break;
case 'D':
duplicate_item();
break;
case 12:
refresh_screen();
break;
case 'k':
case KEY_UP:
scroll_up();
break;
case 'j':
case KEY_DOWN:
scroll_down();
break;
case 'K':
case KEY_PPAGE:
page_up();
break;
case 'J':
case KEY_NPAGE:
page_down();
break;
case 'g':
case KEY_HOME:
goto_home();
break;
case 'G':
case KEY_END:
goto_end();
break;
case 'w':
save_database();
break;
case 'l':
ui_read_database();
break;
case 'i':
import_database();
break;
case 'e':
export_database();
break;
case 'C':
ui_clear_database();
break;
case 'o':
ui_open_datafile();
break;
case 's':
sort_by_field("name");
break;
case 'S':
sort_surname();
break;
case 'F':
sort_by_field(NULL);
break;
case '/':
ui_find(0);
break;
case '\\':
ui_find(1);
break;
case ' ':
if(list_get_curitem() >= 0) {
list_invert_curitem_selection();
ui_print_number_of_items();
refresh_list();
}
break;
case '+':
select_all();
refresh_list();
break;
case '-':
select_none();
refresh_list();
break;
case '*':
invert_selection();
refresh_list();
break;
case 'A':
move_curitem(MOVE_ITEM_UP);
break;
case 'Z':
move_curitem(MOVE_ITEM_DOWN);
break;
case 'm':
launch_mutt(selected_items() ?
-1 : list_get_curitem());
refresh_screen();
break;
case 'p':
ui_print_database();
break;
case 'v':
launch_wwwbrowser(list_get_curitem());
refresh_screen();
break;
case 'H':
launch_callpgm(list_get_curitem(), 'H');
refresh_screen();
break;
case 'W':
launch_callpgm(list_get_curitem(), 'W');
refresh_screen();
break;
case 'M':
launch_callpgm(list_get_curitem(), 'M');
refresh_screen();
break;
}
}
}
//select
void mSelectAllSlot(GtkWidget * widget, gpointer user_data)
{
select_all(view->g[view->activeGraph]);
}
LRESULT CALLBACK App::subclass_wndproc_new(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam){
//odnalezienie kontrolki
Control* kontrolka = NULL;
for(unsigned int i=0; i<Controls::geti()->controls.size(); i++){
if(Controls::geti()->controls.at(i)->handle == hwnd){
kontrolka = Controls::geti()->controls.at(i);
break;
}
}
if(kontrolka==NULL){
IO::geti()->error("Subclassing: Nie znaleziono kontrolki o podanym uchwycie");
return 0;
}
string nazwa = kontrolka->name;
//globalne skróty klawiszowe
if(message == WM_KEYDOWN){
if(wParam==VK_F1||wParam==VK_F2||wParam==VK_F3||wParam==VK_F5||wParam==VK_F6||wParam==VK_F7||wParam==VK_F8||wParam==VK_F9||wParam==VK_F10||wParam==VK_F11){
CallWindowProc(windowProc, hwnd, message, wParam, lParam); //przekazanie wy¿ej do mainwindow
return 0; //przechwycenie
}
//wyjœcie z fullscreena
if(wParam==VK_ESCAPE && Config::geti()->fullscreen_on){
CallWindowProc(windowProc, hwnd, message, wParam, lParam); //przekazanie wy¿ej do mainwindow
return 0; //przechwycenie
}
//ctrl
if(is_control_pressed()){
if(wParam=='S'||wParam=='F'||wParam=='N'||wParam=='B'||wParam==VK_ADD||wParam==VK_SUBTRACT||wParam==VK_LEFT||wParam==VK_RIGHT||wParam=='0'||wParam==VK_NUMPAD0||wParam==VK_OEM_3){
CallWindowProc(windowProc, hwnd, message, wParam, lParam); //przekazanie wy¿ej do mainwindow
return 0; //przechwycenie
}
}
}
if(message == WM_SYSKEYDOWN){
if(wParam==VK_F10){
//zamiana WM_SYSKEYDOWN na WM_KEYDOWN
subclass_wndproc_new(hwnd, WM_KEYDOWN, wParam, lParam);
return 0;
}
}
//globalne przechwycenie wygaszacza
if(message == WM_SYSCOMMAND){
if(wParam == SC_SCREENSAVE){
CallWindowProc(windowProc, hwnd, message, wParam, lParam); //przekazanie wy¿ej do mainwindow
return 0; //przechwycenie
}
}
//nowe procedury kontrolek
if(nazwa=="filename_edit"){
switch(message){
case WM_CHAR:{
if(wParam==VK_ESCAPE){
Controls::geti()->set_focus("editor");
return 0;
}else if(wParam==VK_RETURN){
if(!Config::geti()->cmd_show){
cmd_switch(1);
}
Controls::geti()->set_focus("cmd");
Controls::geti()->select_all("cmd");
return 0;
}
}break;
}
}
if(nazwa=="cmd"){
switch(message){
case WM_CHAR:{
if(wParam==VK_ESCAPE){
Controls::geti()->set_focus("editor");
return 0;
}else if(wParam==VK_RETURN){
exec_cmd();
return 0; //przechwycenie
}
}break;
case WM_KEYDOWN:{
if(wParam==VK_UP){
Controls::geti()->set_text("cmd", last_cmd);
SendMessage(Controls::geti()->find("cmd"), EM_SETSEL, last_cmd.length(), last_cmd.length());
return 0;
}
if(wParam==VK_DOWN){
Controls::geti()->set_text("cmd", "");
return 0;
}
}break;
}
}
if(nazwa=="editor"){ //edytor
switch(message){
case WM_SYSKEYDOWN:{
if(wParam>='1' && wParam<='9'){
//zamiana WM_SYSKEYDOWN na WM_KEYDOWN
subclass_wndproc_new(hwnd, WM_KEYDOWN, wParam, lParam);
return 0;
}
}break;
case WM_KEYDOWN:{
if(is_control_pressed()){ //ctrl
if(wParam=='C'){
copy_text();
return 0;
}else if(wParam=='A'){
select_all();
return 0;
}else if(wParam=='Z'){
undo->revert();
return 0;
}else if(wParam=='R'){
refresh_text();
return 0;
}else if(wParam=='T'){
quick_replace();
return 0;
}else if(wParam=='Q'){
usun_akordy();
return 0;
}else if(wParam=='W'){
save_pattern();
return 0;
}else if(wParam=='E'){
insert_pattern();
return 0;
}else if(wParam=='D'){
dodaj_nawias();
return 0;
}else if(wParam>='1' && wParam<='9'){
zapisz_tekst(wParam-'1'+1);
return 0;
}
}else if(is_alt_pressed()){ //alt
if(wParam>='1' && wParam<='9'){
wstaw_tekst(wParam-'1'+1);
return 0;
}
}
}break;
case WM_CHAR:{
//dla ka¿dego znaku (bez controla)
if(!is_control_pressed()){
undo->save();
}
//undo->save();
if(wParam == ']'){
string add_text = "]";
SendMessage(Controls::geti()->find("editor"), EM_REPLACESEL, 0, (LPARAM)add_text.c_str()); //wstawienie znaku
refresh_text(); //odœwie¿enie tekstu
//zmiana koloru po nawiasie na kolor tekstu
CHARFORMAT cf_text;
cf_text.cbSize = sizeof(cf_text);
SendMessage(Controls::geti()->find("editor"), EM_GETCHARFORMAT, SCF_DEFAULT, (LPARAM)&cf_text);
//kolor tekstu + brak pogrubienia
cf_text.dwMask = CFM_COLOR | CFM_BOLD;
cf_text.crTextColor = RGB(Config::i()->color_text[0], Config::i()->color_text[1], Config::i()->color_text[2]);
cf_text.dwEffects = 0;
SendMessage(Controls::geti()->find("editor"), EM_SETCHARFORMAT, SCF_SELECTION, (LPARAM)&cf_text);
return 0;
}
}break;
case WM_MOUSEWHEEL:{
int zdelta = GET_WHEEL_DELTA_WPARAM(wParam);
if(LOWORD(wParam)==MK_CONTROL){ //z controlem
//zmiana czcionki
if(zdelta>=0){
change_font_size(+1);
}else{
change_font_size(-1);
}
return 0;
}else{
//scrollowanie edytora
int scroll_step = Config::geti()->editor_fontsize + 2;
if(zdelta>=0){
change_scroll(-scroll_step);
}else{
change_scroll(+scroll_step);
}
return 0;
}
}break;
}
}
if(nazwa=="find_edit"){ //szukany ci¹g znaków
switch(message){
case WM_SETFOCUS:{
if(Controls::i()->get_text("find_edit")==Config::i()->find_edit_placeholder){
Controls::i()->set_text("find_edit", "");
}
IO::geti()->echo("(Wpisz szukany ci¹g znaków, Enter - szukaj)");
}break;
case WM_KILLFOCUS:{
if(Controls::i()->get_text("find_edit").length()==0){
Controls::i()->set_text("find_edit", Config::i()->find_edit_placeholder);
}
}break;
case WM_CHAR:{
if(wParam==VK_RETURN){
znajdz();
return 0;
}
if(wParam==VK_TAB){
Controls::geti()->set_focus("replace_edit");
return 0;
}
}break;
}
}
if(nazwa=="replace_edit"){ //tekst do zamiany
switch(message){
case WM_SETFOCUS:{
if(Controls::i()->get_text("replace_edit")==Config::i()->replace_edit_placeholder){
Controls::i()->set_text("replace_edit", "");
}
IO::geti()->echo("(Wpisz tekst do zamiany, Enter - zamieñ w zaznaczeniu lub ca³ym pliku)");
}break;
case WM_KILLFOCUS:{
if(Controls::i()->get_text("replace_edit").length()==0){
Controls::i()->set_text("replace_edit", Config::i()->replace_edit_placeholder);
}
}break;
case WM_CHAR:{
if(wParam==VK_RETURN){
zamien();
return 0;
}
if(wParam==VK_TAB){
Controls::geti()->set_focus("find_edit");
return 0;
}
}break;
}
}
if(nazwa=="autoscroll_interval"){ //autoscroll_interval
switch(message){
case WM_SETFOCUS:{
IO::geti()->echo("(Czas miêdzy kolejnymi przebiegami autoscrolla - wyra¿ony w milisekundach)");
}break;
case WM_CHAR:{
if(wParam==VK_RETURN){
autoscroll_nowait(0);
return 0;
}
}break;
}
}
if(nazwa=="autoscroll_wait"){ //autoscroll_wait
switch(message){
case WM_SETFOCUS:{
IO::geti()->echo("(Czas opóŸnienia przed autoscrollem - wyra¿ony w sekundach)");
}break;
case WM_CHAR:{
if(wParam==VK_RETURN){
autoscroll_on();
return 0;
}
}break;
}
}
return CallWindowProc(kontrolka->wndproc_old, hwnd, message, wParam, lParam);
}
/**
* 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 symboltable::check_types() const
{
s_ptr<typecontext> global(new typecontext());
ltypecontext c(global);
substitution s;
std::map<sid, s_ptr<const sl_polytype_exists>> init_types;
for(size_t i = 0; i < index.size(); i++)
if(index[i].t == symbolref::t_var || index[i].t == symbolref::t_fun)
{
const s_ptr<const sl_polytype_exists> t(new sl_polytype_exists());
init_types[i] = t;
c.register_type(i, std::static_pointer_cast<const sl_polytype>(t));
}
for(const sid i : select_all(symbolref::symbolreftype::t_construct))
s = conss[index[i].i]->declare_type(c).composite(s);
ltypecontext corig = c;
for(const sid i : select_all(symbolref::symbolreftype::t_var))
{
ltypecontext ctmp = corig;
s = vars[index[i].i]->declare_type(ctmp).composite(s);
c.register_type(i, ctmp[i]); //Copy result from ctmp to c;
}
for(const sid i : select_all(symbolref::symbolreftype::t_fun))
{
ltypecontext ctmp = corig;
s = funs[index[i].i]->declare_type(ctmp).composite(s);
c.register_type(i, ctmp[i]); //Copy result from ctmp to c;
}
std::vector<sid> prop_index;
for(const std::pair<sid, s_ptr<const sl_polytype_exists>> p : init_types)
prop_index.push_back(p.first);
while(!prop_index.empty())
{
bool changed = false;
for(size_t i = 0; i < prop_index.size(); i++)
{
const s_ptr<const sl_polytype_exists> t = init_types[prop_index[i]];
std::vector<s_ptr<const sl_type_unbound>> blacklist;
for(size_t j = 0; j < prop_index.size(); j++)
if(i != j)
for(const auto tmp : init_types[prop_index[j]]->fetch_bindings())
add_to<s_ptr<const sl_type_unbound>>(tmp->apply(s)->tv(), blacklist);
if(any_is_in_ptr<const sl_type_unbound>(std::dynamic_pointer_cast<const sl_polytype_forall>(c[prop_index[i]])->unbind_maintain()->apply(s)->tv(), blacklist))
continue;
s = t->propagate_findings(c, c[prop_index[i]]->apply(c, s), s);
prop_index.erase(prop_index.begin()+i);
i--;
changed = true;
break;
}
if(!prop_index.empty() && !changed)
{
for(size_t i = 0; i < prop_index.size(); i++)
{
print_name(prop_index[i], std::cout << std::endl);
for(const auto t : std::dynamic_pointer_cast<const sl_polytype_forall>(c[prop_index[i]])->unbind_maintain()->apply(s)->tv())
t->print(std::cout << ' ');
}
throw std::runtime_error("Cyclic dependency in definitions, cannot infer type");
}
}
for(const sid i : select_all(symbolref::symbolreftype::t_type))
c.register_type(i, sl_polytype::not_qualify(c.create_fresh(sloc())));
typecontext gtmp = global->apply_maintain(s);
substitution stmp;
for(const sid i : select_all(symbolref::symbolreftype::t_var))
{
gtmp = gtmp.apply(stmp);
stmp = vars[index[i].i]->fetch_assigned_type(gtmp)->unify(gtmp[i]->unbind(gtmp)).composite(stmp);
}
for(const sid i : select_all(symbolref::symbolreftype::t_fun))
{
gtmp = gtmp.apply(stmp);
stmp = funs[index[i].i]->fetch_assigned_type(gtmp)->unify(gtmp[i]->unbind(gtmp)).composite(stmp);
}
for(const sid i : select_all(symbolref::symbolreftype::t_arg))
{
gtmp = gtmp.apply(stmp);
stmp = args[index[i].i]->fetch_assigned_type(gtmp)->unify(gtmp[i]->unbind(gtmp)).composite(stmp);
}
for(const sid i : select_all(symbolref::symbolreftype::t_local_var))
{
gtmp = gtmp.apply(stmp);
stmp = local_vars[index[i].i]->fetch_assigned_type(gtmp)->unify(gtmp[i]->unbind(gtmp)).composite(stmp);
}
print(global->apply_maintain(stmp.composite(s)), std::cout << "Typecontext final: " << std::endl);
}
