fiddlerwoaroof/crawl - Change IIN7AVA6JYRBXH6ZYRR7BY7TV6PW7ANAQ2A3PD55FKBKKQFEEF2AC

Experimental mouse support for ncurses (enable with mouse_input=yes in

.crawlrc).

git-svn-id: https://crawl-ref.svn.sourceforge.net/svnroot/crawl-ref/trunk@1610 c06c8d41-db1a-0410-9941-cceddc491573

Created by dshaligram on June 20, 2007

IIN7AVA6JYRBXH6ZYRR7BY7TV6PW7ANAQ2A3PD55FKBKKQFEEF2AC

Dependencies

In channels

main

Change contents

Insertion in crawl-ref/source/view.cc at line 40 [11.16817]
[9.1471]
[10.5]
```
#include "cio.h"
```
Replacement in crawl-ref/source/view.cc at line 2522 [11.16817]
B:BD[12.955] → [12.955:975]
```
    char getty = 0;
```
[12.955]
[11.74806]
```
    int getty = 0;
```
Insertion in crawl-ref/source/view.cc at line 2609 [11.16817]
[12.3743]
[13.6281]
```
        c_input_reset(true);
```
Insertion in crawl-ref/source/view.cc at line 2612 [11.16817]
[13.6410]
[12.4173]
```
        c_input_reset(false);
```
Replacement in crawl-ref/source/view.cc at line 2647 [11.16817]
B:BD[7.801] → [7.801:810]
```
        
```
[7.801]
[12.4647]

Insertion in crawl-ref/source/view.cc at line 2811 [11.16817]

[14.25509]

[12.8565]


        case CK_MOUSE_MOVE:
            move_x = move_y = 0;
            break;
        
        case CK_MOUSE_CLICK:
        {
            const c_mouse_event cme = get_mouse_event();
            const coord_def curp(start_x + curs_x - 1, start_y + curs_y - 1);
            const coord_def grdp =
                cme.pos + coord_def(start_x - 1, start_y - top);
            
            if (cme.left_clicked() && in_bounds(grdp))
            {
                spec_place[0] = grdp.x;
                spec_place[1] = grdp.y;
                map_alive     = false;
            }
            else if (cme.scroll_up())
            {
                move_y = -block_step * ((curs_y - top + 1) / block_step + 1);
                move_x = 0;
            }
            else if (cme.scroll_down())
            {
                move_y =
                    block_step *
                    ((get_number_of_lines() - curs_y + top - 1) / block_step
                     + 1);
                move_x = 0;
            }
            else if (cme.right_clicked())
            {
                const coord_def delta = grdp - curp;
                move_y = delta.y;
                move_x = delta.x;
            }
            break;
        }

Replacement in crawl-ref/source/tutorial.cc at line 9 [16.5936]
B:BD[15.1358] → [15.1358:1359]
[15.1339]
[15.1359]
```
#include "cio.h"
```
Insertion in crawl-ref/source/travel.cc at line 17 [14.39949]
[17.151]
[14.40219]
```
#include "cio.h"
```

Insertion in crawl-ref/source/travel.cc at line 2556 [14.39949]

[14.109101]

[2.220]

    if (Options.tut_explored)
        Options.tut_explored = 0;
        
    if (you.level_type == LEVEL_LABYRINTH || you.level_type == LEVEL_ABYSS)
    {
        mpr("It would help if you knew where you were, first.");
        return;
    }

Insertion in crawl-ref/source/stash.cc at line 11 [14.147324]
[14.147482]
[14.147482]
```
#include "cio.h"
```

Replacement in crawl-ref/source/spl-book.h at line 51 [11.395672]

B:BD[11.397570] → [14.188910:189037]

unsigned char spellbook_contents( item_def &book, int action,
                                  formatted_string *fs = NULL );

[11.397570]

[14.189037]

int spellbook_contents( item_def &book, int action,
                        formatted_string *fs = NULL );

Replacement in crawl-ref/source/spl-book.cc at line 28 [11.397614]
B:BD[11.398234] → [11.398234:398235]
[11.398234]
[11.398235]
```
#include "cio.h"
```

Replacement in crawl-ref/source/spl-book.cc at line 688 [11.397614]

B:BD[14.189190] → [14.189190:189309]

unsigned char spellbook_contents( item_def &book, int action,
                                  formatted_string *fs )

[14.189190]

[11.414979]

int spellbook_contents( item_def &book, int action,
                        formatted_string *fs )

Replacement in crawl-ref/source/spl-book.cc at line 830 [11.397614]
B:BD[14.190262] → [14.190262:190290]
```
    unsigned char keyn = 0;
```
[14.190262]
[14.190290]
```
    int keyn = 0;
```

Replacement in crawl-ref/source/spl-book.cc at line 838 [11.397614]

B:BD[11.418561] → [14.190481:190549]

        keyn = getch();
        if (keyn == 0)
            getch();

[11.418561]

[14.190621]

        keyn = c_getch();

Replacement in crawl-ref/source/skills2.cc at line 1821 [11.647133]
B:BD[11.728466] → [18.178:197]
```
void show_skills()
```
[11.728466]
[11.728489]
```
static void display_skill_table(bool show_aptitudes)
```
Replacement in crawl-ref/source/skills2.cc at line 1823 [11.647133]
B:BD[11.728491] → [11.728491:728513]
B:BD[11.728513] → [9.162576:162600]
B:BD[9.162600] → [19.39:72]
∅:D[19.72] → [11.728530:728531]
∅:D[9.162600] → [11.728530:728531]
B:BD[11.728530] → [11.728530:728531]
```
    int i;
    int x;
    menu_letter lcount;
    bool show_aptitudes = false;
```
[11.728491]
[11.728531]
```
    menu_letter lcount = 'a';
```
Deletion in crawl-ref/source/skills2.cc at line 1825 [11.647133]
B:BD[11.728689] → [11.728689:728704]
```
    clrscr();
```
Deletion in crawl-ref/source/skills2.cc at line 1826 [11.647133]
B:BD[11.728705] → [11.728705:728741]
```
  reprint_stuff:
    lcount = 'a';
```
Replacement in crawl-ref/source/skills2.cc at line 1842 [11.647133]
∅:D[18.342] → [11.729133:729134]
B:BD[11.729133] → [11.729133:729134]
[18.342]
[11.729134]
```
    int x;
```
Replacement in crawl-ref/source/skills2.cc at line 1846 [11.647133]
B:BD[11.729263] → [9.162601:162645]
```
    for (i = 0; i < ndisplayed_skills; ++i)
```
[11.729263]
[11.729300]
```
    for (int i = 0; i < ndisplayed_skills; ++i)
```

Replacement in crawl-ref/source/skills2.cc at line 1933 [11.647133]

B:BD[6.3043] → [6.3043:3690]

      textcolor(MAGENTA);
      gotoxy(1, bottom_line-5);
      formatted_string::parse_block(
        "This screen shows the skill set of your character. You can pick up new" EOL
        "skills by performing the corresponding actions. The number next to the" EOL
        "skill is your current level, the higher the better. The blue percent  " EOL
        "value shows your progress towards the next skill level. You can toggle" EOL
        "which skills to train by pressing their slot letters. A <darkgrey>greyish<magenta> skill " EOL
        "will increase at a decidedly slower rate and ease training of others. ",
        false).display();

[6.3043]

[6.3690]

        textcolor(MAGENTA);
        gotoxy(1, bottom_line-5);
        formatted_string::parse_block(
            "This screen shows the skill set of your character. You can pick up new" EOL
            "skills by performing the corresponding actions. The number next to the" EOL
            "skill is your current level, the higher the better. The blue percent  " EOL
            "value shows your progress towards the next skill level. You can toggle" EOL
            "which skills to train by pressing their slot letters. A <darkgrey>greyish<magenta> skill " EOL
            "will increase at a decidedly slower rate and ease training of others. ",
            false).display();

Replacement in crawl-ref/source/skills2.cc at line 1946 [11.647133]

B:BD[19.565] → [6.3706:3997]

∅:D[6.3997] → [19.565:597]

B:BD[19.565] → [19.565:597]

B:BD[19.597] → [18.418:680]

B:BD[18.680] → [6.3998:4006]

      // if any more skills added, must adapt letters to go into caps
      gotoxy(1, bottom_line-1);
      textcolor(LIGHTGREY);
      cprintf("Press the letter of a skill to choose whether you want to practise it.");
      if (!player_genus(GENPC_DRACONIAN) || you.max_level >= 7)
      {
        gotoxy(1, bottom_line);
        formatted_string::parse_string("Press '!' to toggle between "
                                       "<blue>progress</blue> and "
                                       "<red>aptitude</red> "
                                       "display.").display();
      }

[19.565]

[19.676]

        // if any more skills added, must adapt letters to go into caps
        gotoxy(1, bottom_line-1);
        textcolor(LIGHTGREY);
        cprintf("Press the letter of a skill to choose "
                "whether you want to practise it.");
        if (!player_genus(GENPC_DRACONIAN) || you.max_level >= 7)
        {
            gotoxy(1, bottom_line);
            formatted_string::parse_string("Press '!' to toggle between "
                                           "<blue>progress</blue> and "
                                           "<red>aptitude</red> "
                                           "display.").display();
        }

Insertion in crawl-ref/source/skills2.cc at line 1960 [11.647133]
[19.682]
[11.731708]
```
}
```

Replacement in crawl-ref/source/skills2.cc at line 1962 [11.647133]

B:BD[11.731709] → [18.681:710]

    int get_thing = getch();

[11.731709]

[11.731729]

void show_skills()
{
    bool show_aptitudes = false;
    clrscr();
    while (true)
    {
        display_skill_table(show_aptitudes);

Replacement in crawl-ref/source/skills2.cc at line 1970 [11.647133]
B:BD[11.731756] → [11.731756:731812]
```
    if (get_thing == 0)
        getch();
    else
    {
```
[11.731730]
[19.683]
```
        const int get_thing = getch();
```

Replacement in crawl-ref/source/skills2.cc at line 1972 [11.647133]

B:BD[19.750] → [19.750:805]

                                  you.max_level >= 7))

[19.750]

[19.805]

                                 you.max_level >= 7))

Replacement in crawl-ref/source/skills2.cc at line 1975 [11.647133]
B:BD[19.861] → [19.861:893]
```
            goto reprint_stuff;
```
[19.861]
[19.893]
```
            continue;
```
Insertion in crawl-ref/source/skills2.cc at line 1977 [11.647133]
[19.903]
[11.731812]
```
        
```

Replacement in crawl-ref/source/skills2.cc at line 1981 [11.647133]

B:BD[11.731928] → [11.731928:731985]

            lcount = 'a';       // toggle skill practise

[11.731928]

[11.731985]

            menu_letter lcount = 'a';       // toggle skill practise

Replacement in crawl-ref/source/skills2.cc at line 1983 [11.647133]

B:BD[11.731986] → [9.163631:163683]

            for (i = 0; i < ndisplayed_skills; i++)

[11.731986]

[11.732023]

            int x;
            for (int i = 0; i < ndisplayed_skills; i++)

Replacement in crawl-ref/source/skills2.cc at line 1989 [11.647133]
B:BD[9.163822] → [9.163822:163823]
[9.163822]
[9.163823]
```
                
```
Replacement in crawl-ref/source/skills2.cc at line 1992 [11.647133]
B:BD[11.732107] → [11.732107:732108]
[11.732107]
[11.732108]
```
            
```
Replacement in crawl-ref/source/skills2.cc at line 1998 [11.647133]
B:BD[11.732289] → [11.732289:732290]
[11.732289]
[9.163933]
```
                
```
Replacement in crawl-ref/source/skills2.cc at line 2001 [11.647133]
B:BD[11.732424] → [11.732424:732457]
```
            goto reprint_stuff;
```
[11.732424]
[11.732457]
```
            continue;
```
Insertion in crawl-ref/source/skills2.cc at line 2003 [11.647133]
[11.732467]
[11.732467]
```
        break;
```
Deletion in crawl-ref/source/skills2.cc at line 2005 [11.647133]
B:BD[11.732473] → [11.732473:732474]
B:BD[11.732532] → [11.732532:732544]
```
    return;
```
Deletion in crawl-ref/source/skills2.cc at line 2007 [11.647133]
B:BD[11.732547] → [11.732547:732548]
Replacement in crawl-ref/source/shopping.cc at line 28 [11.759950]
B:BD[11.760475] → [11.760475:760476]
[11.760475]
[11.760476]
```
#include "cio.h"
```
Deletion in crawl-ref/source/player.cc at line 2933 [11.962854]
B:BD[11.1029814] → [11.1029814:1029840]
```
    unsigned char keyin;
```
Replacement in crawl-ref/source/player.cc at line 2941 [11.962854]
B:BD[11.1030048] → [11.1030048:1030100]
```
  get_key:
    keyin = getch();
    if (keyin == 0)
```
[11.1030048]
[11.1030100]
```
    while (true)
```
Replacement in crawl-ref/source/player.cc at line 2943 [11.962854]
B:BD[11.1030106] → [11.1030106:1030151]
```
        getch();
        goto get_key;
    }
```
[11.1030106]
[11.1030151]
```
        const int keyin = getch();
```

Replacement in crawl-ref/source/player.cc at line 2945 [11.962854]

B:BD[11.1030152] → [11.1030152:1030267]

    switch (keyin)
    {
    case 's':
    case 'S':
        modify_stat(STAT_STRENGTH, 1, false);
        return;

[11.1030152]

[11.1030267]

        switch (keyin)
        {
        case 's':
        case 'S':
            modify_stat(STAT_STRENGTH, 1, false);
            return;

Replacement in crawl-ref/source/player.cc at line 2952 [11.962854]

B:BD[11.1030268] → [11.1030268:1030362]

    case 'i':
    case 'I':
        modify_stat(STAT_INTELLIGENCE, 1, false);
        return;

[11.1030268]

[11.1030362]

        case 'i':
        case 'I':
            modify_stat(STAT_INTELLIGENCE, 1, false);
            return;

Replacement in crawl-ref/source/player.cc at line 2957 [11.962854]

B:BD[11.1030363] → [11.1030363:1030454]

    case 'd':
    case 'D':
        modify_stat(STAT_DEXTERITY, 1, false);
        return;

[11.1030363]

[11.1030454]

        case 'd':
        case 'D':
            modify_stat(STAT_DEXTERITY, 1, false);
            return;
        }

Deletion in crawl-ref/source/player.cc at line 2963 [11.962854]

B:BD[11.1030460] → [11.1030460:1030600]


    goto get_key;
/* this is an infinite loop because it is reasonable to assume that you're not going to want to leave it prematurely. */

Insertion in crawl-ref/source/notes.cc at line 13 [9.370339]
[20.3142]
[9.370462]
```
#include "cio.h"
```
Insertion in crawl-ref/source/newgame.cc at line 74 [11.1132300]
[20.3254]
[21.63]
```
#include "cio.h"
```
Replacement in crawl-ref/source/message.cc at line 27 [11.1993826]
B:BD[11.1994364] → [11.1994364:1994365]
[11.1994364]
[14.253924]
```
#include "cio.h"
```
Insertion in crawl-ref/source/menu.cc at line 10 [14.261322]
[9.564794]
[14.261341]
```
#include "cio.h"
```
Insertion in crawl-ref/source/makefile.obj at line 10 [22.79]
[22.145]
[22.145]
```
cio.o \
```
Insertion in crawl-ref/source/macro.cc at line 47 [11.2457534]
[11.2458839]
[11.2458839]
```
#include "cio.h"
```
Replacement in crawl-ref/source/macro.cc at line 581 [11.2457534]
B:BD[14.281929] → [14.281929:281953]
```
        rgetch = getch;
```
[14.281929]
[14.281953]
```
        rgetch = m_getch;
```
Replacement in crawl-ref/source/macro.cc at line 659 [11.2457534]
B:BD[11.2467788] → [11.2467788:2467813]
```
    unsigned char input;
```
[11.2467788]
[11.2467813]
```
    int input;
```

Replacement in crawl-ref/source/macro.cc at line 664 [11.2457534]

B:BD[14.282294] → [9.616450:616547]

∅:D[14.282409] → [11.2467897:2467964]

∅:D[9.616547] → [11.2467897:2467964]

B:BD[11.2467897] → [11.2467897:2467964]

    mpr( "(m)acro, keymap [(k) default, (x) level-map or (t)argeting], (s)ave?", MSGCH_PROMPT );
    input = getch();
    if (input == 0)
        input = getch();

[14.282294]

[11.2467964]

    mpr("(m)acro, keymap [(k) default, (x) level-map or (t)argeting], (s)ave?",
        MSGCH_PROMPT);
    input = m_getch();

Replacement in crawl-ref/source/macro.cc at line 716 [11.2457534]

B:BD[11.2468759] → [11.2468759:2468837]

        input = getch();
        if (input == 0)
            input = getch();

[11.2468759]

[11.2468837]

        input = m_getch();

Replacement in crawl-ref/source/libw32c.h at line 31 [11.2475780]

B:BD[11.2476383] → [11.2476383:2476492]

void setStringInput(bool value);
bool setBuffering(bool value);
int getConsoleString(char *buf, int maxlen);

[11.2476383]

[11.2476492]

void set_string_input(bool value);
bool set_buffering(bool value);
int get_console_string(char *buf, int maxlen);

Insertion in crawl-ref/source/libw32c.h at line 52 [11.2475780]
[23.187]
[11.2476814]
```
void set_mouse_enabled(bool enabled);
```

Insertion in crawl-ref/source/libw32c.cc at line 224 [11.2476860]

[11.2483793]

void set_mouse_enabled(bool enabled)
{
    DWORD inmode;
    if (::GetConsoleMode(inbuf, &inmode))
    {
        if (enabled)
            inmode |= ENABLE_MOUSE_INPUT;
        else
            inmode &= ~ENABLE_MOUSE_INPUT;
        
        ::SetConsoleMode(inbuf, inmode);
    }
}

Replacement in crawl-ref/source/libw32c.cc at line 238 [11.2476860]
B:BD[11.2483794] → [11.2483794:2483826]
```
void setStringInput(bool value)
```
[11.2483794]
[11.2483826]
```
void set_string_input(bool value)
```
Replacement in crawl-ref/source/libw32c.cc at line 368 [11.2476860]
B:BD[8.4179] → [8.4179:4208]
```
    setStringInput( false );
```
[8.4179]
[11.2485376]
```
    set_string_input( false );
```
Replacement in crawl-ref/source/libw32c.cc at line 380 [11.2476860]
B:BD[8.4440] → [8.4440:4464]
```
    setBuffering(true);
```
[8.4440]
[11.2485576]
```
    set_buffering(true);
```
Replacement in crawl-ref/source/libw32c.cc at line 415 [11.2476860]
B:BD[8.5632] → [8.5632:5658]
```
    setStringInput(true);
```
[8.5632]
[11.2485837]
```
    set_string_input(true);
```
Replacement in crawl-ref/source/libw32c.cc at line 629 [11.2476860]
B:BD[8.8311] → [8.8311:8335]
```
    setBuffering(true);
```
[8.8311]
[11.2488080]
```
    set_buffering(true);
```
Replacement in crawl-ref/source/libw32c.cc at line 639 [11.2476860]
B:BD[8.8463] → [8.8463:8491]
```
    setBuffering(oldValue);
```
[8.8463]
[11.2488314]
```
    set_buffering(oldValue);
```
Insertion in crawl-ref/source/libw32c.cc at line 789 [11.2476860]
[11.2490671]
[14.319495]
```
int m_getch()
{
    return getch();
}
```
Replacement in crawl-ref/source/libw32c.cc at line 866 [11.2476860]
B:BD[8.12158] → [8.12158:12183]
```
    setBuffering(false);
```
[8.12158]
[11.2492075]
```
    set_buffering(false);
```
Replacement in crawl-ref/source/libw32c.cc at line 874 [11.2476860]
B:BD[8.12278] → [8.12278:12306]
```
    setBuffering(oldValue);
```
[8.12278]
[11.2492192]
```
    set_buffering(oldValue);
```
Replacement in crawl-ref/source/libw32c.cc at line 910 [11.2476860]
B:BD[11.2492414] → [11.2492414:2492458]
```
int getConsoleString(char *buf, int maxlen)
```
[11.2492414]
[11.2492458]
```
int get_console_string(char *buf, int maxlen)
```
Replacement in crawl-ref/source/libw32c.cc at line 914 [11.2476860]
B:BD[8.12438] → [8.12438:12466]
```
    setStringInput( true );
```
[8.12438]
[11.2492540]
```
    set_string_input( true );
```
Replacement in crawl-ref/source/libw32c.cc at line 941 [11.2476860]
B:BD[8.13227] → [8.13227:13256]
```
    setStringInput( false );
```
[8.13227]
[11.2493283]
```
    set_string_input( false );
```
Replacement in crawl-ref/source/libw32c.cc at line 956 [11.2476860]
∅:D[13.13625] → [11.2493402:2493434]
B:BD[11.2493402] → [11.2493402:2493434]
```
bool setBuffering( bool value )
```
[13.13625]
[11.2493434]
```
bool set_buffering( bool value )
```
Replacement in crawl-ref/source/libutil.h at line 3 [11.2493627]
B:BD[11.2493657] → [11.2493657:2493703]
```
 *  Summary:    System indepentant functions 
```
[11.2493657]
[9.619231]
```
 *  Summary:    System independent functions 
```

Deletion in crawl-ref/source/libutil.h at line 21 [11.2493627]

B:BD[14.320122] → [24.290:320]

∅:D[24.320] → [9.619312:619313]

B:BD[14.320122] → [9.619312:619313]

B:BD[9.619313] → [25.469:677]

B:BD[25.677] → [4.263:394]


void cursorxy(int x, int y);
// Converts a key to a direction key, converting keypad and other sequences
// to vi key sequences (shifted/control key directions are also handled). Non
// direction keys (hopefully) pass through unmangled.
int unmangle_direction_keys(int keyin, int keymap = 0,
                            bool fake_ctrl = true, bool fake_shift = true);

Deletion in crawl-ref/source/libutil.h at line 49 [11.2493627]
B:BD[11.2493843] → [14.320123:320209]
```
// getch() that returns a consistent set of values for all platforms.
int c_getch();
```

Deletion in crawl-ref/source/libutil.h at line 55 [11.2493627]

B:BD[14.320447] → [14.320447:320448]

∅:D[14.320448] → [11.2493843:2493894]

B:BD[11.2493843] → [11.2493843:2493894]

B:BD[11.2493894] → [14.320449:320470]

B:BD[14.320470] → [9.619605:619711]

∅:D[9.619711] → [14.320470:320471]

B:BD[14.320470] → [14.320470:320471]

B:BD[14.320471] → [9.619712:620259]


void get_input_line( char *const buff, int len );
class input_history;
// In view.cc, declared here for default argument to cancelable_get_line()
int get_number_of_cols(void);
// Returns zero if user entered text and pressed Enter, otherwise returns the 
// key pressed that caused the exit, usually Escape.
//
// If keyproc is provided, it must return 1 for normal processing, 0 to exit
// normally (pretend the user pressed Enter), or -1 to exit as if the user
// pressed Escape
int cancelable_get_line( char *buf, 
                         int len, 
                         int wrapcol = get_number_of_cols(),
                         input_history *mh = NULL,
                         int (*keyproc)(int &c) = NULL );

Deletion in crawl-ref/source/libutil.h at line 107 [11.2493627]

B:BD[11.2494049] → [11.2494049:2494050]

B:BD[11.2494050] → [14.320775:320894]

B:BD[14.320894] → [9.620415:620439]

∅:D[9.620439] → [14.320918:321546]

B:BD[14.320918] → [14.320918:321546]


// Keys that getch() must return for keys Crawl is interested in.
enum KEYS
{
    CK_ENTER  = '\r',
    CK_BKSP   = 8,
    CK_ESCAPE = ESCAPE,
    // 128 is off-limits because it's the code that's used when running
    CK_DELETE = 129,
    // This sequence of enums should not be rearranged.
    CK_UP,
    CK_DOWN,
    CK_LEFT,
    CK_RIGHT,
    CK_INSERT,
    CK_HOME,
    CK_END,
    CK_CLEAR,
    CK_PGUP,
    CK_PGDN,
    CK_SHIFT_UP,
    CK_SHIFT_DOWN,
    CK_SHIFT_LEFT,
    CK_SHIFT_RIGHT,
    CK_SHIFT_INSERT,
    CK_SHIFT_HOME,
    CK_SHIFT_END,
    CK_SHIFT_CLEAR,
    CK_SHIFT_PGUP,
    CK_SHIFT_PGDN,
    CK_CTRL_UP,
    CK_CTRL_DOWN,
    CK_CTRL_LEFT,
    CK_CTRL_RIGHT,
    CK_CTRL_INSERT,
    CK_CTRL_HOME,
    CK_CTRL_END,
    CK_CTRL_CLEAR,

Deletion in crawl-ref/source/libutil.h at line 108 [11.2493627]
B:BD[14.321547] → [14.321547:321565]
B:BD[14.321565] → [26.929:946]
∅:D[26.946] → [14.321583:321587]
B:BD[14.321583] → [14.321583:321587]
```
    CK_CTRL_PGUP,
    CK_CTRL_PGDN
};
```
Deletion in crawl-ref/source/libutil.h at line 123 [11.2493627]
B:BD[27.791] → [27.791:795]
∅:D[27.795] → [9.620440:620471]
B:BD[14.321587] → [9.620440:620471]
B:BD[9.620471] → [28.637:756]
∅:D[28.756] → [23.966:1008]
B:BD[23.966] → [23.966:1008]
B:BD[23.1008] → [28.757:801]
∅:D[28.801] → [9.620570:620600]
B:BD[9.620570] → [9.620570:620600]
B:BD[9.620600] → [28.802:838]
∅:D[28.838] → [23.1009:1051]
B:BD[9.620659] → [23.1009:1051]
∅:D[23.1051] → [9.620659:620691]
B:BD[9.620659] → [9.620659:620691]
B:BD[9.620691] → [23.1052:1074]
```
};
class cursor_control
{
public:
    cursor_control(bool cursor_enabled) 
        : cstate(is_cursor_enabled()), smartcstate(is_smart_cursor_enabled())
    {
        enable_smart_cursor(false);
        set_cursor_enabled(cursor_enabled);
    }
    ~cursor_control() {
        set_cursor_enabled(cstate);
        enable_smart_cursor(smartcstate);
    }
private:
    bool cstate;
    bool smartcstate;
```

Deletion in crawl-ref/source/libutil.h at line 125 [11.2493627]

B:BD[9.620695] → [9.620695:621561]

// Reads lines of text; used internally by cancelable_get_line.
class line_reader
{
public:
    line_reader(char *buffer, size_t bufsz, 
                int wrap_col = get_number_of_cols());
    typedef int (*keyproc)(int &key);
    int read_line(bool clear_previous = true);
    std::string get_text() const;
    void set_input_history(input_history *ih);
    void set_keyproc(keyproc fn);
protected:
    void cursorto(int newcpos);
    int process_key(int ch);
    void backspace();
    void killword();
    bool is_wordchar(int c);
private:
    char            *buffer;
    size_t          bufsz;
    input_history   *history;
    int             start_x, start_y;
    keyproc         keyfn;
    int             wrapcol;
    // These are subject to change during editing.
    char            *cur;
    int             length;
    int             pos;
};

Deletion in crawl-ref/source/libutil.cc at line 47 [11.2494093]

B:BD[14.324702] → [25.756:982]

∅:D[25.982] → [14.324702:324709]

B:BD[14.324702] → [14.324702:324709]

B:BD[14.324709] → [25.983:984]

B:BD[25.984] → [4.396:476]

∅:D[4.476] → [25.1031:1390]

B:BD[25.1031] → [25.1031:1390]

∅:D[25.1390] → [14.324709:324710]

B:BD[14.324709] → [14.324709:324710]

B:BD[14.324710] → [25.1391:1428]

B:BD[25.1428] → [4.477:512]

∅:D[4.512] → [25.1450:1576]

B:BD[25.1450] → [25.1450:1576]

B:BD[25.1576] → [4.513:554]

∅:D[4.554] → [25.1603:1931]

B:BD[25.1603] → [25.1603:1931]

B:BD[25.1931] → [16.79321:79371]

∅:D[16.79371] → [25.1973:2071]

B:BD[25.1973] → [25.1973:2071]

B:BD[25.2071] → [16.79372:79472]

∅:D[16.79472] → [25.2151:2228]

B:BD[25.2151] → [25.2151:2228]

B:BD[25.2228] → [16.79473:79533]

∅:D[16.79533] → [25.2276:2387]

B:BD[25.2276] → [25.2276:2387]

B:BD[25.2387] → [3.120:636]

#endif
#ifdef UNIX
static keycode_type numpad2vi(keycode_type key)
{
    if (key >= '1' && key <= '9')
    {
        const char *vikeys = "bjnh.lyku";
        return keycode_type(vikeys[key - '1']);
    }
    return (key);
}
#endif
int unmangle_direction_keys(int keyin, int km, bool fake_ctrl, bool fake_shift)
{
    const KeymapContext keymap = static_cast<KeymapContext>(km);
#ifdef UNIX
    // Kludging running and opening as two character sequences
    // for Unix systems.  This is an easy way out... all the
    // player has to do is find a termcap and numlock setting
    // that will get curses the numbers from the keypad.  This
    // will hopefully be easy.
    /* can we say yuck? -- haranp */
    if (fake_ctrl && keyin == '*')
    {
        keyin = getchm(keymap);
        // return control-key
        keyin = CONTROL(toupper(numpad2vi(keyin)));
    }
    else if (fake_shift && keyin == '/')
    {
        keyin = getchm(keymap);
        // return shift-key
        keyin = toupper(numpad2vi(keyin));
    }
#else
    // Old DOS keypad support
    if (keyin == 0)
    {
        /* FIXME haranp - hackiness */
        const char DOSidiocy[10]     = { "OPQKSMGHI" };
        const char DOSunidiocy[10]   = { "bjnh.lyku" };
        const int DOScontrolidiocy[9] =
        {
            117, 145, 118, 115, 76, 116, 119, 141, 132
        };
        keyin = getchm(keymap);
        for (int j = 0; j < 9; ++j )
        {
            if (keyin == DOSidiocy[j])
            {
                keyin = DOSunidiocy[j];
                break;
            }
            if (keyin == DOScontrolidiocy[j])
            {
                keyin = CONTROL(toupper(DOSunidiocy[j]));
                break;
            }
        }
    }
#endif
    // [dshaligram] More lovely keypad mangling.
    switch (keyin)
    {
#ifdef UNIX
    case '1': return 'b';
    case '2': return 'j';
    case '3': return 'n';
    case '4': return 'h';
    case '6': return 'l';
    case '7': return 'y';
    case '8': return 'k';
    case '9': return 'u';
#else
    case '1': return 'B';
    case '2': return 'J';
    case '3': return 'N';
    case '4': return 'H';
    case '6': return 'L';
    case '7': return 'Y';
    case '8': return 'K';
    case '9': return 'U';

Deletion in crawl-ref/source/libutil.cc at line 48 [11.2494093]
B:BD[25.2394] → [3.637:643]
```
    }
```
Deletion in crawl-ref/source/libutil.cc at line 49 [11.2494093]
B:BD[25.2395] → [25.2395:2418]
```
    return (keyin);
}
```
Deletion in crawl-ref/source/libutil.cc at line 232 [11.2494093]
∅:D[9.622751] → [14.325426:325428]
B:BD[14.325426] → [14.325426:325428]
∅:D[29.2211] → [11.2494347:2494399]
∅:D[14.325428] → [11.2494347:2494399]
B:BD[11.2494347] → [11.2494347:2494399]
B:BD[11.2494399] → [9.622752:622793]
∅:D[9.622793] → [11.2494443:2494444]
B:BD[11.2494443] → [11.2494443:2494444]
B:BD[11.2494444] → [30.1341:1433]
B:BD[30.1433] → [9.622794:622847]
∅:D[9.622847] → [11.2494642:2494648]
B:BD[11.2494642] → [11.2494642:2494648]
B:BD[11.2494648] → [9.622848:622951]
∅:D[9.622951] → [11.2494648:2494714]
B:BD[11.2494648] → [11.2494648:2494714]
B:BD[11.2494714] → [9.622952:622995]
∅:D[9.622995] → [11.2494760:2495072]
B:BD[11.2494760] → [11.2494760:2495072]
B:BD[11.2495072] → [9.622996:623021]
∅:D[9.623021] → [11.2495100:2495113]
B:BD[11.2495100] → [11.2495100:2495113]
B:BD[11.2495113] → [14.325429:325454]
```
}
void get_input_line( char *const buff, int len )
{
    buff[0] = 0;         // just in case
#if defined(UNIX)
    get_input_line_from_curses( buff, len ); // implemented in libunix.cc
#elif defined(WIN32CONSOLE)
    getstr( buff, len );
#else
    // [dshaligram] Turn on the cursor for DOS.
#ifdef DOS
    _setcursortype(_NORMALCURSOR);
#endif
    fgets( buff, len, stdin );  // much safer than gets()
#endif
    buff[ len - 1 ] = 0;  // just in case 
    // Removing white space from the end in order to get rid of any
    // newlines or carriage returns that any of the above might have 
    // left there (ie fgets especially).  -- bwr
    const int end = strlen( buff ); 
    int i; 
    for (i = end - 1; i >= 0; i++) 
    {
        if (isspace( buff[i] ))
            buff[i] = 0;
        else
            break;
    }
```

Deletion in crawl-ref/source/libutil.cc at line 234 [11.2494093]

B:BD[14.325457] → [14.325457:325468]

B:BD[14.325468] → [9.623022:623046]

∅:D[9.623046] → [14.325492:325513]

B:BD[14.325492] → [14.325492:325513]

B:BD[14.325513] → [9.623047:623104]

∅:D[9.623104] → [14.325558:326349]

B:BD[14.325558] → [14.325558:326349]

B:BD[14.326349] → [9.623105:623180]

∅:D[9.623180] → [14.326425:326474]

B:BD[14.326425] → [14.326425:326474]

B:BD[14.326474] → [24.574:869]

∅:D[24.869] → [14.326474:326762]

B:BD[14.326474] → [14.326474:326762]

B:BD[14.326762] → [9.623181:623252]

∅:D[9.623252] → [14.326825:327067]

B:BD[14.326825] → [14.326825:327067]

B:BD[14.327067] → [9.623253:623288]

∅:D[9.623288] → [14.327094:327363]

B:BD[14.327094] → [14.327094:327363]

B:BD[14.327363] → [9.623289:623416]

∅:D[9.623416] → [14.327624:327626]

B:BD[14.327624] → [14.327624:327626]

B:BD[14.327626] → [9.623417:623526]

∅:D[9.623526] → [14.327769:327770]

B:BD[14.327769] → [14.327769:327770]

B:BD[14.327770] → [9.623527:623558]

B:BD[9.623558] → [31.5901:5904]

#ifdef DOS
static int getch_ck()
{
    int c = getch();
    if (!c)
    {
        switch (c = getch())
        {
        case 'O':  return CK_END;
        case 'P':  return CK_DOWN;
        case 'I':  return CK_PGUP;
        case 'H':  return CK_UP;
        case 'G':  return CK_HOME;
        case 'K':  return CK_LEFT;
        case 'Q':  return CK_PGDN;
        case 'M':  return CK_RIGHT;
        case 119:  return CK_CTRL_HOME;
        case 141:  return CK_CTRL_UP;
        case 132:  return CK_CTRL_PGUP;
        case 116:  return CK_CTRL_RIGHT;
        case 118:  return CK_CTRL_PGDN;
        case 145:  return CK_CTRL_DOWN;
        case 117:  return CK_CTRL_END;
        case 115:  return CK_CTRL_LEFT;
        case 'S':  return CK_DELETE;
        }
    }
    return c;
}
#endif
// Hacky wrapper around getch() that returns CK_ codes for keys
// we want to use in cancelable_get_line() and menus.
int c_getch()
{
#if defined(DOS) || defined(UNIX) || defined(WIN32CONSOLE)
    return getch_ck();
#else
    return getch();
#endif
}
// Wrapper around gotoxy that can draw a fake cursor for Unix terms where
// cursoring over darkgray or black causes problems.
void cursorxy(int x, int y)
{
#ifdef UNIX
    if (Options.use_fake_cursor)
        fakecursorxy(x, y);
    else
        gotoxy(x, y);
#else
    gotoxy(x, y);
#endif
}
// cprintf that knows how to wrap down lines (primitive, but what the heck)
int wrapcprintf( int wrapcol, const char *s, ... )
{
    char buf[1000]; // Hard max
    va_list args;
    va_start(args, s);
    // XXX: If snprintf isn't available, vsnprintf probably isn't, either.
    int len = vsnprintf(buf, sizeof buf, s, args);
    int olen = len;
    va_end(args);
    char *run = buf;
    while (len > 0)
    {
        int x = wherex(), y = wherey();
        if (x > wrapcol) // Somebody messed up!
            return 0;
        
        int avail = wrapcol - x + 1;
        int c = 0;
        if (len > avail)
        {
            c = run[avail];
            run[avail] = 0;
        }
        cprintf("%s", run);
        
        if (len > avail)
            run[avail] = c;
        if ((len -= avail) > 0)
            gotoxy(1, y + 1);
        run += avail;
    }
    return (olen);
}
int cancelable_get_line( char *buf, int len, int maxcol,
                         input_history *mh, int (*keyproc)(int &ch) )
{
    line_reader reader(buf, len, maxcol);
    reader.set_input_history(mh);
    reader.set_keyproc(keyproc);
    return reader.read_line();
}

Deletion in crawl-ref/source/libutil.cc at line 497 [11.2494093]

B:BD[14.337045] → [14.337045:337046]

B:BD[14.337198] → [14.337198:337199]

B:BD[14.338549] → [14.338549:339529]

B:BD[14.339529] → [9.624541:627060]

B:BD[9.627060] → [32.4749:4772]

∅:D[32.4772] → [9.627060:627080]

B:BD[9.627060] → [9.627060:627080]

B:BD[9.627080] → [32.4773:4801]

∅:D[32.4801] → [9.627101:629913]

B:BD[9.627101] → [9.627101:629913]

∅:D[9.629913] → [14.339529:339531]

B:BD[14.339529] → [14.339529:339531]


/////////////////////////////////////////////////////////////
// input_history
//
input_history::input_history(size_t size)
    : history(), pos(), maxsize(size)
{
    if (maxsize < 2)
        maxsize = 2;
    pos = history.end();
}
void input_history::new_input(const std::string &s)
{
    history.remove(s);
    if (history.size() == maxsize)
        history.pop_front();
    history.push_back(s);
    // Force the iterator to the end (also revalidates it)
    go_end();
}
const std::string *input_history::prev()
{
    if (history.empty())
        return NULL;
    if (pos == history.begin())
        pos = history.end();
    return &*--pos;
}
const std::string *input_history::next()
{
    if (history.empty())
        return NULL;
    if (pos == history.end() || ++pos == history.end())
        pos = history.begin();
    return &*pos;
}
void input_history::go_end()
{
    pos = history.end();
}
void input_history::clear()
{
    history.clear();
    go_end();
}
/////////////////////////////////////////////////////////////////////////
// line_reader
line_reader::line_reader(char *buf, size_t sz, int wrap)
    : buffer(buf), bufsz(sz), history(NULL), start_x(0),
      start_y(0), keyfn(NULL), wrapcol(wrap), cur(NULL),
      length(0), pos(-1)
{
}
std::string line_reader::get_text() const
{
    return (buffer);
}
void line_reader::set_input_history(input_history *i)
{
    history = i;
}
void line_reader::set_keyproc(keyproc fn)
{
    keyfn = fn;
}
void line_reader::cursorto(int ncx)
{
    int x = (start_x + ncx - 1) % wrapcol + 1;
    int y = start_y + (start_x + ncx - 1) / wrapcol;
    ::gotoxy(x, y);
}
int line_reader::read_line(bool clear_previous)
{
    if (bufsz <= 0) return false;
    cursor_control coff(true);
    if (clear_previous)
        *buffer = 0;
    start_x = wherex();
    start_y = wherey();
    length = strlen(buffer);
    // Remember the previous cursor position, if valid.
    if (pos < 0 || pos > length)
        pos = length;
    cur = buffer + pos;
    if (length)
        wrapcprintf(wrapcol, "%s", buffer);
    if (pos != length)
        cursorto(pos);
    if (history)
        history->go_end();
    for ( ; ; )
    {
        int ch = c_getch();
        if (keyfn)
        {
            int whattodo = (*keyfn)(ch);
            if (whattodo == 0)
            {
                buffer[length] = 0;
                if (history && length)
                    history->new_input(buffer);
                return (0);
            }
            else if (whattodo == -1)
            {
                buffer[length] = 0;                
                return (ch);
            }
        }
        int ret = process_key(ch);
        if (ret != -1)
            return (ret);
    }
}
void line_reader::backspace()
{
    if (pos)
    {
        --cur;
        char *c = cur;
        while (*c)
        {
            *c = c[1];
            c++;
        }
        --pos;
        --length;
        cursorto(pos);
        buffer[length] = 0;
        wrapcprintf( wrapcol, "%s ", cur );
        cursorto(pos);
    }
}
bool line_reader::is_wordchar(int c)
{
    return isalnum(c) || c == '_' || c == '-';
}
void line_reader::killword()
{
    if (!pos || cur == buffer)
        return;
    bool foundwc = false;
    while (pos)
    {
        if (is_wordchar(cur[-1]))
            foundwc = true;
        else if (foundwc)
            break;
        backspace();
    }
}
int line_reader::process_key(int ch)
{
    switch (ch)
    {
    case CONTROL('G'):
    case CK_ESCAPE:
        return (CK_ESCAPE);
    case CK_UP:
    case CK_DOWN:
    {
        if (!history)
            break;
        const std::string *text = 
                    ch == CK_UP? history->prev() : history->next();
        if (text)
        {
            int olen = length;
            length = text->length();
            if (length >= (int) bufsz)
                length = bufsz - 1;
            memcpy(buffer, text->c_str(), length);
            buffer[length] = 0;
            cursorto(0);
            int clear = length < olen? olen - length : 0;
            wrapcprintf(wrapcol, "%s%*s", buffer, clear, "");
            pos = length;
            cur = buffer + pos;
            cursorto(pos);
        }
        break;
    }
    case CK_ENTER:
        buffer[length] = 0;
        if (history && length)
            history->new_input(buffer);
        return (0);
    case CONTROL('K'):
    {
        // Kill to end of line
        int erase = length - pos;
        if (erase)
        {
            length = pos;
            buffer[length] = 0;
            wrapcprintf( wrapcol, "%*s", erase, "" );
            cursorto(pos);
        }
        break;
    }
    case CK_DELETE:
        if (pos < length)
        {
            char *c = cur;
            while (c - buffer < length)
            {
                *c = c[1];
                c++;
            }
            --length;
            cursorto(pos);
            buffer[length] = 0;
            wrapcprintf( wrapcol, "%s ", cur );
            cursorto(pos);
        }
        break;
    case CK_BKSP:
        backspace();
        break;
    case CONTROL('W'):
        killword();
        break;
    case CK_LEFT:
        if (pos)
        {
            --pos;
            cur = buffer + pos;
            cursorto(pos);
        }
        break;
    case CK_RIGHT:
        if (pos < length)
        {
            ++pos;
            cur = buffer + pos;
            cursorto(pos);
        }
        break;
    case CK_HOME:
    case CONTROL('A'):
        pos = 0;
        cur = buffer + pos;
        cursorto(pos);
        break;
    case CK_END:
    case CONTROL('E'):
        pos = length;
        cur = buffer + pos;
        cursorto(pos);
        break;
    default:
        if (isprint(ch) && length < (int) bufsz - 1)
        {
            if (pos < length)
            {
                char *c = buffer + length - 1;
                while (c >= cur)
                {
                    c[1] = *c;
                    c--;
                }
            }
            *cur++ = (char) ch;
            ++length;
            ++pos;
            putch(ch);
            if (pos < length)
            {
                buffer[length] = 0;
                wrapcprintf( wrapcol, "%s", cur );
            }
            cursorto(pos);
        }
        break;
    }
    return (-1);
}

Insertion in crawl-ref/source/libunix.h at line 53 [11.2548819]
[23.1177]
[23.1177]
```
void set_mouse_enabled(bool enabled);
```
Insertion in crawl-ref/source/libunix.cc at line 46 [11.2550041]
[11.2551705]
[11.2551705]
```
#include "cio.h"
```

Insertion in crawl-ref/source/libunix.cc at line 227 [11.2550041]

[33.1223]

[11.2555375]

}
void set_mouse_enabled(bool enabled)
{
#ifdef NCURSES_MOUSE_VERSION
    const int mask = enabled? ALL_MOUSE_EVENTS | REPORT_MOUSE_POSITION : 0;
    mousemask(mask, NULL);
#endif
}
#ifdef NCURSES_MOUSE_VERSION
static int proc_mouse_event(int c, const MEVENT *me)
{
    crawl_view.mousep.x = me->x + 1;
    crawl_view.mousep.y = me->y + 1;
    if (!crawl_state.mouse_enabled)
        return (CK_MOUSE_MOVE);
    c_mouse_event cme(crawl_view.mousep);
    if (me->bstate & BUTTON1_CLICKED)
        cme.bstate |= c_mouse_event::BUTTON1;
    else if (me->bstate & BUTTON1_DOUBLE_CLICKED)
        cme.bstate |= c_mouse_event::BUTTON1_DBL;
    else if (me->bstate & BUTTON2_CLICKED)
        cme.bstate |= c_mouse_event::BUTTON2;
    else if (me->bstate & BUTTON2_DOUBLE_CLICKED)
        cme.bstate |= c_mouse_event::BUTTON2_DBL;
    else if (me->bstate & BUTTON3_CLICKED)
        cme.bstate |= c_mouse_event::BUTTON3;
    else if (me->bstate & BUTTON3_DOUBLE_CLICKED)
        cme.bstate |= c_mouse_event::BUTTON3_DBL;
    else if (me->bstate & BUTTON4_CLICKED)
        cme.bstate |= c_mouse_event::BUTTON4;
    else if (me->bstate & BUTTON4_DOUBLE_CLICKED)
        cme.bstate |= c_mouse_event::BUTTON4_DBL;
    
    if (cme)
    {
        new_mouse_event(cme);
        return (CK_MOUSE_CLICK);
    }
    return (CK_MOUSE_MOVE);

Insertion in crawl-ref/source/libunix.cc at line 272 [11.2550041]
[11.2555377]
[11.2555377]
```
#endif
```

Insertion in crawl-ref/source/libunix.cc at line 274 [11.2550041]

[11.2555378]

[11.2555629]

static int raw_m_getch()
{
    const int c = getch();
    switch (c)
    {
#ifdef NCURSES_MOUSE_VERSION
    case KEY_MOUSE:
    {
        MEVENT me;
        getmouse(&me);
        return (proc_mouse_event(c, &me));
    }
#endif
    default:
        return (c);
    }
}

Insertion in crawl-ref/source/libunix.cc at line 292 [11.2550041]

[11.2555630]

[33.1224]

int m_getch()
{
    int c;
    do
        c = raw_m_getch();
    while ((c == CK_MOUSE_MOVE || c == CK_MOUSE_CLICK)
           && !crawl_state.mouse_enabled);
    return (c);
}

Replacement in crawl-ref/source/libunix.cc at line 305 [11.2550041]
∅:D[33.1241] → [14.339611:339632]
B:BD[14.339611] → [14.339611:339632]
```
    int c = getch();
```
[33.1241]
[33.1242]
```
    int c = m_getch();
```
Insertion in crawl-ref/source/libunix.cc at line 466 [11.2550041]
[34.3141]
[11.2563536]
```
    set_mouse_enabled(false);
```
Insertion in crawl-ref/source/libdos.h at line 14 [9.630690]
[35.407]
[28.1325]
```
int getch_ck();
void set_mouse_enabled(bool enabled) { }
```

Insertion in crawl-ref/source/libdos.cc at line 94 [9.630803]

[34.3914]

}
int getch_ck()
{
    int c = getch();
    if (!c)
    {
        switch (c = getch())
        {
        case 'O':  return CK_END;
        case 'P':  return CK_DOWN;
        case 'I':  return CK_PGUP;
        case 'H':  return CK_UP;
        case 'G':  return CK_HOME;
        case 'K':  return CK_LEFT;
        case 'Q':  return CK_PGDN;
        case 'M':  return CK_RIGHT;
        case 119:  return CK_CTRL_HOME;
        case 141:  return CK_CTRL_UP;
        case 132:  return CK_CTRL_PGUP;
        case 116:  return CK_CTRL_RIGHT;
        case 118:  return CK_CTRL_PGDN;
        case 145:  return CK_CTRL_DOWN;
        case 117:  return CK_CTRL_END;
        case 115:  return CK_CTRL_LEFT;
        case 'S':  return CK_DELETE;
        }
    }
    return c;
}
int m_getch()
{
    return getch();

Insertion in crawl-ref/source/item_use.cc at line 38 [11.2781507]
[11.2782819]
[11.2782819]
```
#include "cio.h"
```
Insertion in crawl-ref/source/initfile.cc at line 562 [11.2957258]
[9.791253]
[33.2086]
```
    mouse_input = false;
    
```

Insertion in crawl-ref/source/initfile.cc at line 1878 [11.2957258]

[36.4587]

[37.10580]

    else if (key == "mouse_input")
    {
        mouse_input = read_bool(field, mouse_input);
    }

Insertion in crawl-ref/source/externs.h at line 1188 [11.3270163]

[27.2311]

[8.13648]

    bool mouse_enabled;     // True if mouse input is currently relevant.

Replacement in crawl-ref/source/externs.h at line 1209 [11.3270163]

B:BD[38.2147] → [8.13765:13837]

∅:D[8.13837] → [33.2691:2921]

B:BD[33.2691] → [33.2691:2921]

B:BD[33.2921] → [8.13838:13916]

    game_state() : waiting_for_command(false), terminal_resized(false),
                   io_inited(false), need_save(false), saving_game(false),
                   updating_scores(false), shopping(false), seen_hups(0),
                   unicode_ok(false), glyph2strfn(NULL), multibyte_strlen(NULL),
                   terminal_resize_handler(NULL), terminal_resize_check(NULL)

[38.2147]

[8.13916]

    game_state() : mouse_enabled(false), waiting_for_command(false),
                   terminal_resized(false), io_inited(false), need_save(false),
                   saving_game(false), updating_scores(false), shopping(false),
                   seen_hups(0), unicode_ok(false), glyph2strfn(NULL),
                   multibyte_strlen(NULL), terminal_resize_handler(NULL),
                   terminal_resize_check(NULL)

Insertion in crawl-ref/source/externs.h at line 1294 [11.3270163]
[37.13911]
[37.13911]
```
    coord_def mousep;              // Where the mouse is.
```
Insertion in crawl-ref/source/externs.h at line 1466 [11.3270163]
[37.15064]
[37.15064]
```
    bool        mouse_input;
    
```
Insertion in crawl-ref/source/enum.h at line 664 [11.3287960]
[36.8721]
[9.906435]
```
    
    CMD_MOUSE_MOVE,
    CMD_MOUSE_CLICK,
```

Insertion in crawl-ref/source/direct.h at line 36 [11.3696722]

[7.5129]

void terse_describe_square(const coord_def &c);
void full_describe_square(const coord_def &c);

Insertion in crawl-ref/source/direct.cc at line 35 [11.3697945]
[11.3698675]
[39.182]
```
#include "cio.h"
```
Replacement in crawl-ref/source/direct.cc at line 420 [11.3697945]
B:BD[11.3701077] → [40.285:310]
```
        int i, mid, oid;
```
[11.3701077]
[41.6137]
```
        int i, mid;
```

Replacement in crawl-ref/source/direct.cc at line 632 [11.3697945]

B:BD[41.10760] → [40.311:423]

∅:D[40.423] → [41.10872:10895]

B:BD[41.10872] → [41.10872:10895]

B:BD[41.10895] → [40.424:425]

∅:D[40.425] → [41.10895:10939]

B:BD[41.10895] → [41.10895:10939]

B:BD[41.10939] → [40.426:701]

∅:D[40.701] → [42.275:289]

B:BD[43.3325] → [42.275:289]

B:BD[42.289] → [40.702:790]

∅:D[40.790] → [42.507:552]

B:BD[42.507] → [42.507:552]

B:BD[42.552] → [40.791:894]

∅:D[40.894] → [42.697:711]

B:BD[42.697] → [42.697:711]

B:BD[42.711] → [40.895:896]

            // Don't give out information for things outside LOS
            if (!see_grid(moves.tx, moves.ty))
                break;
            mid = mgrd[moves.tx][moves.ty];
            oid = igrd[moves.tx][moves.ty];
            if (mid != NON_MONSTER && player_monster_visible(&menv[mid]))
            {
                // First priority: monsters
                describe_monsters(menv[mid]);
            }
            else if (oid != NON_ITEM)
            {
                // Second priority: objects
                describe_item( mitm[oid] );
            }
            else
            {
                // Third priority: features
                describe_feature_wide(moves.tx, moves.ty);
            }

[41.10760]

[39.617]

            full_describe_square(moves.target());

Deletion in crawl-ref/source/direct.cc at line 634 [11.3697945]
B:BD[39.650] → [39.650:705]
```
            redraw_screen();
            mesclr(true);
```

Replacement in crawl-ref/source/direct.cc at line 715 [11.3697945]

∅:D[44.1815] → [45.2935:3169]

B:BD[41.12277] → [45.2935:3169]

            if ( !in_vlos(grid2viewX(moves.tx), grid2viewY(moves.ty)) )
                describe_oos_square(moves.tx, moves.ty);
            else if ( in_bounds(moves.tx, moves.ty) )
                describe_cell(moves.tx, moves.ty);

[44.1815]

[11.3704355]

            terse_describe_square(moves.target());

Insertion in crawl-ref/source/direct.cc at line 753 [11.3697945]

[9.976419]

[46.10503]

void terse_describe_square(const coord_def &c)
{
    if (!see_grid(c.x, c.y))
        describe_oos_square(c.x, c.y);
    else if (in_bounds(c) )
        describe_cell(c.x, c.y);
}
void full_describe_square(const coord_def &c)
{
    // Don't give out information for things outside LOS
    if (!see_grid(c.x, c.y))
        return;
    const int mid = mgrd(c);
    const int oid = igrd(c);
    if (mid != NON_MONSTER && player_monster_visible(&menv[mid]))
    {
        // First priority: monsters
        describe_monsters(menv[mid]);
    }
    else if (oid != NON_ITEM)
    {
        // Second priority: objects
        describe_item( mitm[oid] );
    }
    else
    {
        // Third priority: features
        describe_feature_wide(c.x, c.y);
    }
    redraw_screen();
    mesclr(true);
}

Insertion in crawl-ref/source/debug.cc at line 40 [11.4016436]
[47.3577]
[5.570]
```
#include "cio.h"
```
Insertion in crawl-ref/source/clua.cc at line 12 [14.483969]
[14.484097]
[9.1205730]
```
#include "cio.h"
```

File addition: cio.h (----------)

[48.24]

/*
 *  File:       cio.h
 *  Summary:    System independent console IO functions 
 *
 *  Modified for Crawl Reference by $Author: dshaligram $ on $Date: 2007-06-14T18:14:26.828542Z $
 */
#ifndef CIO_H
#define CIO_H
#include "AppHdr.h"
#include "externs.h"
#include "defines.h"
#include <cctype>
#include <string>
#include <vector>
void cursorxy(int x, int y);
// Read one key, flag it as a mouse event if appropriate, but apply no
// other conversions. Defined in lib$OS.cc, not in cio.cc.
int m_getch();
// A getch() that flags mouse events and returns a consistent set of key codes
// for all platforms for a small subset of the keys Crawl is interested in.
int c_getch();
// Converts a key to a direction key, converting keypad and other sequences
// to vi key sequences (shifted/control key directions are also handled). Non
// direction keys (hopefully) pass through unmangled.
int unmangle_direction_keys(int keyin, int keymap = 0,
                            bool fake_ctrl = true, bool fake_shift = true);
void get_input_line( char *const buff, int len );
// In view.cc, declared here for default argument to cancelable_get_line()
int get_number_of_cols(void);
class input_history;
// Returns zero if user entered text and pressed Enter, otherwise returns the 
// key pressed that caused the exit, usually Escape.
//
// If keyproc is provided, it must return 1 for normal processing, 0 to exit
// normally (pretend the user pressed Enter), or -1 to exit as if the user
// pressed Escape
int cancelable_get_line( char *buf, 
                         int len, 
                         int wrapcol = get_number_of_cols(),
                         input_history *mh = NULL,
                         int (*keyproc)(int &c) = NULL );
struct c_mouse_event
{
    coord_def pos;
    int       bstate;
    enum button_state_type
    {
        BUTTON1        = 0x1,
        BUTTON1_DBL    = 0x2,
        BUTTON2        = 0x4,
        BUTTON2_DBL    = 0x8,
        BUTTON3        = 0x10,
        BUTTON3_DBL    = 0x20,
        BUTTON4        = 0x40,
        BUTTON4_DBL    = 0x80,
        BUTTON_SCRL_UP = 0x100,
        BUTTON_SCRL_DN = 0x200
    };
    c_mouse_event() : pos(-1, -1), bstate(0)
    {
    }
    c_mouse_event(const coord_def &c, int state = 0) : pos(c), bstate(state)
    {
    }
    // Returns true for valid events.
    operator bool () const
    {
        return (bstate);
    }
    bool left_clicked() const
    {
        return (bstate & BUTTON1);
    }
    bool right_clicked() const
    {
        return (bstate & BUTTON3);
    }
    bool scroll_up() const
    {
        return (bstate & (BUTTON4 | BUTTON4_DBL | BUTTON_SCRL_UP));
    }
    bool scroll_down() const
    {
        return (bstate & (BUTTON2 | BUTTON2_DBL | BUTTON_SCRL_DN));
    }
};
coord_def     get_mouse_pos();
c_mouse_event get_mouse_event();
void          new_mouse_event(const c_mouse_event &ce);
void          flush_mouse_events();
void          c_input_reset(bool enable_mouse, bool flush = false);
// Keys that getch() must return for keys Crawl is interested in.
enum KEYS
{
    CK_ENTER  = '\r',
    CK_BKSP   = 8,
    CK_ESCAPE = ESCAPE,
    // 128 is off-limits because it's the code that's used when running
    CK_DELETE = 129,
    // This sequence of enums should not be rearranged.
    CK_UP,
    CK_DOWN,
    CK_LEFT,
    CK_RIGHT,
    CK_INSERT,
    CK_HOME,
    CK_END,
    CK_CLEAR,
    CK_PGUP,
    CK_PGDN,
    CK_SHIFT_UP,
    CK_SHIFT_DOWN,
    CK_SHIFT_LEFT,
    CK_SHIFT_RIGHT,
    CK_SHIFT_INSERT,
    CK_SHIFT_HOME,
    CK_SHIFT_END,
    CK_SHIFT_CLEAR,
    CK_SHIFT_PGUP,
    CK_SHIFT_PGDN,
    CK_CTRL_UP,
    CK_CTRL_DOWN,
    CK_CTRL_LEFT,
    CK_CTRL_RIGHT,
    CK_CTRL_INSERT,
    CK_CTRL_HOME,
    CK_CTRL_END,
    CK_CTRL_CLEAR,
    CK_CTRL_PGUP,
    CK_CTRL_PGDN,
    // Mouse codes.
    CK_MOUSE_MOVE  = 10001,
    CK_MOUSE_CLICK
};
class cursor_control
{
public:
    cursor_control(bool cursor_enabled) 
        : cstate(is_cursor_enabled()), smartcstate(is_smart_cursor_enabled())
    {
        enable_smart_cursor(false);
        set_cursor_enabled(cursor_enabled);
    }
    ~cursor_control() {
        set_cursor_enabled(cstate);
        enable_smart_cursor(smartcstate);
    }
private:
    bool cstate;
    bool smartcstate;
};
// Reads lines of text; used internally by cancelable_get_line.
class line_reader
{
public:
    line_reader(char *buffer, size_t bufsz, 
                int wrap_col = get_number_of_cols());
    typedef int (*keyproc)(int &key);
    int read_line(bool clear_previous = true);
    std::string get_text() const;
    void set_input_history(input_history *ih);
    void set_keyproc(keyproc fn);
protected:
    void cursorto(int newcpos);
    int process_key(int ch);
    void backspace();
    void killword();
    bool is_wordchar(int c);
private:
    char            *buffer;
    size_t          bufsz;
    input_history   *history;
    int             start_x, start_y;
    keyproc         keyfn;
    int             wrapcol;
    // These are subject to change during editing.
    char            *cur;
    int             length;
    int             pos;
};
#endif

File addition: cio.cc (----------)

[48.24]

/*
 *  File:       cio.cc
 *  Summary:    Platform-independent console IO functions.
 *
 *  Modified for Crawl Reference by $Author: dshaligram $ on $Date: 2007-06-14T18:14:26.828542Z $
 */
#include "AppHdr.h"
#include "cio.h"
#include "externs.h"
#include "macro.h"
#include <queue>
#ifdef UNIX
static keycode_type numpad2vi(keycode_type key)
{
    if (key >= '1' && key <= '9')
    {
        const char *vikeys = "bjnh.lyku";
        return keycode_type(vikeys[key - '1']);
    }
    return (key);
}
#endif
int unmangle_direction_keys(int keyin, int km, bool fake_ctrl, bool fake_shift)
{
    const KeymapContext keymap = static_cast<KeymapContext>(km);
#ifdef UNIX
    // Kludging running and opening as two character sequences
    // for Unix systems.  This is an easy way out... all the
    // player has to do is find a termcap and numlock setting
    // that will get curses the numbers from the keypad.  This
    // will hopefully be easy.
    /* can we say yuck? -- haranp */
    if (fake_ctrl && keyin == '*')
    {
        keyin = getchm(keymap);
        // return control-key
        keyin = CONTROL(toupper(numpad2vi(keyin)));
    }
    else if (fake_shift && keyin == '/')
    {
        keyin = getchm(keymap);
        // return shift-key
        keyin = toupper(numpad2vi(keyin));
    }
#else
    // Old DOS keypad support
    if (keyin == 0)
    {
        /* FIXME haranp - hackiness */
        const char DOSidiocy[10]     = { "OPQKSMGHI" };
        const char DOSunidiocy[10]   = { "bjnh.lyku" };
        const int DOScontrolidiocy[9] =
        {
            117, 145, 118, 115, 76, 116, 119, 141, 132
        };
        keyin = getchm(keymap);
        for (int j = 0; j < 9; ++j )
        {
            if (keyin == DOSidiocy[j])
            {
                keyin = DOSunidiocy[j];
                break;
            }
            if (keyin == DOScontrolidiocy[j])
            {
                keyin = CONTROL(toupper(DOSunidiocy[j]));
                break;
            }
        }
    }
#endif
    // [dshaligram] More lovely keypad mangling.
    switch (keyin)
    {
#ifdef UNIX
    case '1': return 'b';
    case '2': return 'j';
    case '3': return 'n';
    case '4': return 'h';
    case '6': return 'l';
    case '7': return 'y';
    case '8': return 'k';
    case '9': return 'u';
#else
    case '1': return 'B';
    case '2': return 'J';
    case '3': return 'N';
    case '4': return 'H';
    case '6': return 'L';
    case '7': return 'Y';
    case '8': return 'K';
    case '9': return 'U';
#endif
    }
    return (keyin);
}
void get_input_line( char *const buff, int len )
{
    buff[0] = 0;         // just in case
#if defined(UNIX)
    get_input_line_from_curses( buff, len ); // implemented in libunix.cc
#elif defined(WIN32CONSOLE)
    getstr( buff, len );
#else
    // [dshaligram] Turn on the cursor for DOS.
#ifdef DOS
    _setcursortype(_NORMALCURSOR);
#endif
    fgets( buff, len, stdin );  // much safer than gets()
#endif
    buff[ len - 1 ] = 0;  // just in case 
    // Removing white space from the end in order to get rid of any
    // newlines or carriage returns that any of the above might have 
    // left there (ie fgets especially).  -- bwr
    const int end = strlen( buff ); 
    int i; 
    for (i = end - 1; i >= 0; i++) 
    {
        if (isspace( buff[i] ))
            buff[i] = 0;
        else
            break;
    }
}
// Hacky wrapper around getch() that returns CK_ codes for keys
// we want to use in cancelable_get_line() and menus.
int c_getch()
{
#if defined(DOS) || defined(UNIX) || defined(WIN32CONSOLE)
    return getch_ck();
#else
    return m_getch();
#endif
}
// Wrapper around gotoxy that can draw a fake cursor for Unix terms where
// cursoring over darkgray or black causes problems.
void cursorxy(int x, int y)
{
#ifdef UNIX
    if (Options.use_fake_cursor)
        fakecursorxy(x, y);
    else
        gotoxy(x, y);
#else
    gotoxy(x, y);
#endif
}
// cprintf that knows how to wrap down lines (primitive, but what the heck)
int wrapcprintf( int wrapcol, const char *s, ... )
{
    char buf[1000]; // Hard max
    va_list args;
    va_start(args, s);
    // XXX: If snprintf isn't available, vsnprintf probably isn't, either.
    int len = vsnprintf(buf, sizeof buf, s, args);
    int olen = len;
    va_end(args);
    char *run = buf;
    while (len > 0)
    {
        int x = wherex(), y = wherey();
        if (x > wrapcol) // Somebody messed up!
            return 0;
        
        int avail = wrapcol - x + 1;
        int c = 0;
        if (len > avail)
        {
            c = run[avail];
            run[avail] = 0;
        }
        cprintf("%s", run);
        
        if (len > avail)
            run[avail] = c;
        if ((len -= avail) > 0)
            gotoxy(1, y + 1);
        run += avail;
    }
    return (olen);
}
int cancelable_get_line( char *buf, int len, int maxcol,
                         input_history *mh, int (*keyproc)(int &ch) )
{
    line_reader reader(buf, len, maxcol);
    reader.set_input_history(mh);
    reader.set_keyproc(keyproc);
    return reader.read_line();
}
/////////////////////////////////////////////////////////////
// input_history
//
input_history::input_history(size_t size)
    : history(), pos(), maxsize(size)
{
    if (maxsize < 2)
        maxsize = 2;
    pos = history.end();
}
void input_history::new_input(const std::string &s)
{
    history.remove(s);
    if (history.size() == maxsize)
        history.pop_front();
    history.push_back(s);
    // Force the iterator to the end (also revalidates it)
    go_end();
}
const std::string *input_history::prev()
{
    if (history.empty())
        return NULL;
    if (pos == history.begin())
        pos = history.end();
    return &*--pos;
}
const std::string *input_history::next()
{
    if (history.empty())
        return NULL;
    if (pos == history.end() || ++pos == history.end())
        pos = history.begin();
    return &*pos;
}
void input_history::go_end()
{
    pos = history.end();
}
void input_history::clear()
{
    history.clear();
    go_end();
}
/////////////////////////////////////////////////////////////////////////
// line_reader
line_reader::line_reader(char *buf, size_t sz, int wrap)
    : buffer(buf), bufsz(sz), history(NULL), start_x(0),
      start_y(0), keyfn(NULL), wrapcol(wrap), cur(NULL),
      length(0), pos(-1)
{
}
std::string line_reader::get_text() const
{
    return (buffer);
}
void line_reader::set_input_history(input_history *i)
{
    history = i;
}
void line_reader::set_keyproc(keyproc fn)
{
    keyfn = fn;
}
void line_reader::cursorto(int ncx)
{
    int x = (start_x + ncx - 1) % wrapcol + 1;
    int y = start_y + (start_x + ncx - 1) / wrapcol;
    ::gotoxy(x, y);
}
int line_reader::read_line(bool clear_previous)
{
    if (bufsz <= 0) return false;
    cursor_control coff(true);
    if (clear_previous)
        *buffer = 0;
    start_x = wherex();
    start_y = wherey();
    length = strlen(buffer);
    // Remember the previous cursor position, if valid.
    if (pos < 0 || pos > length)
        pos = length;
    cur = buffer + pos;
    if (length)
        wrapcprintf(wrapcol, "%s", buffer);
    if (pos != length)
        cursorto(pos);
    if (history)
        history->go_end();
    for ( ; ; )
    {
        int ch = c_getch();
        if (keyfn)
        {
            int whattodo = (*keyfn)(ch);
            if (whattodo == 0)
            {
                buffer[length] = 0;
                if (history && length)
                    history->new_input(buffer);
                return (0);
            }
            else if (whattodo == -1)
            {
                buffer[length] = 0;                
                return (ch);
            }
        }
        int ret = process_key(ch);
        if (ret != -1)
            return (ret);
    }
}
void line_reader::backspace()
{
    if (pos)
    {
        --cur;
        char *c = cur;
        while (*c)
        {
            *c = c[1];
            c++;
        }
        --pos;
        --length;
        cursorto(pos);
        buffer[length] = 0;
        wrapcprintf( wrapcol, "%s ", cur );
        cursorto(pos);
    }
}
bool line_reader::is_wordchar(int c)
{
    return isalnum(c) || c == '_' || c == '-';
}
void line_reader::killword()
{
    if (!pos || cur == buffer)
        return;
    bool foundwc = false;
    while (pos)
    {
        if (is_wordchar(cur[-1]))
            foundwc = true;
        else if (foundwc)
            break;
        backspace();
    }
}
int line_reader::process_key(int ch)
{
    switch (ch)
    {
    case CONTROL('G'):
    case CK_ESCAPE:
        return (CK_ESCAPE);
    case CK_UP:
    case CK_DOWN:
    {
        if (!history)
            break;
        const std::string *text = 
                    ch == CK_UP? history->prev() : history->next();
        if (text)
        {
            int olen = length;
            length = text->length();
            if (length >= (int) bufsz)
                length = bufsz - 1;
            memcpy(buffer, text->c_str(), length);
            buffer[length] = 0;
            cursorto(0);
            int clear = length < olen? olen - length : 0;
            wrapcprintf(wrapcol, "%s%*s", buffer, clear, "");
            pos = length;
            cur = buffer + pos;
            cursorto(pos);
        }
        break;
    }
    case CK_ENTER:
        buffer[length] = 0;
        if (history && length)
            history->new_input(buffer);
        return (0);
    case CONTROL('K'):
    {
        // Kill to end of line
        int erase = length - pos;
        if (erase)
        {
            length = pos;
            buffer[length] = 0;
            wrapcprintf( wrapcol, "%*s", erase, "" );
            cursorto(pos);
        }
        break;
    }
    case CK_DELETE:
        if (pos < length)
        {
            char *c = cur;
            while (c - buffer < length)
            {
                *c = c[1];
                c++;
            }
            --length;
            cursorto(pos);
            buffer[length] = 0;
            wrapcprintf( wrapcol, "%s ", cur );
            cursorto(pos);
        }
        break;
    case CK_BKSP:
        backspace();
        break;
    case CONTROL('W'):
        killword();
        break;
    case CK_LEFT:
        if (pos)
        {
            --pos;
            cur = buffer + pos;
            cursorto(pos);
        }
        break;
    case CK_RIGHT:
        if (pos < length)
        {
            ++pos;
            cur = buffer + pos;
            cursorto(pos);
        }
        break;
    case CK_HOME:
    case CONTROL('A'):
        pos = 0;
        cur = buffer + pos;
        cursorto(pos);
        break;
    case CK_END:
    case CONTROL('E'):
        pos = length;
        cur = buffer + pos;
        cursorto(pos);
        break;
    default:
        if (isprint(ch) && length < (int) bufsz - 1)
        {
            if (pos < length)
            {
                char *c = buffer + length - 1;
                while (c >= cur)
                {
                    c[1] = *c;
                    c--;
                }
            }
            *cur++ = (char) ch;
            ++length;
            ++pos;
            putch(ch);
            if (pos < length)
            {
                buffer[length] = 0;
                wrapcprintf( wrapcol, "%s", cur );
            }
            cursorto(pos);
        }
        break;
    }
    return (-1);
}
/////////////////////////////////////////////////////////////////////////////
// Of mice and other mice.
static std::queue<c_mouse_event> mouse_events;
coord_def get_mouse_pos()
{
    // lib$(OS) has to maintain mousep. This function is just the messenger.
    return (crawl_view.mousep);
}
c_mouse_event get_mouse_event()
{
    if (mouse_events.empty())
        return c_mouse_event();
    c_mouse_event ce = mouse_events.front();
    mouse_events.pop();
    return (ce);
}
void new_mouse_event(const c_mouse_event &ce)
{
    mouse_events.push(ce);
}
void flush_mouse_events()
{
    while (!mouse_events.empty())
        mouse_events.pop();
}
void c_input_reset(bool enable_mouse, bool flush)
{
    crawl_state.mouse_enabled = (enable_mouse && Options.mouse_input);
    set_mouse_enabled(crawl_state.mouse_enabled);
    if (flush)
        flush_mouse_events();
}

Insertion in crawl-ref/source/beam.cc at line 37 [11.4128068]
[11.4128951]
[11.4128951]
```
#include "cio.h"
```
Insertion in crawl-ref/source/acr.cc at line 77 [11.4397395]
[11.4399988]
[49.7585]
```
#include "cio.h"
```
Replacement in crawl-ref/source/acr.cc at line 927 [11.4397395]
∅:D[33.3196] → [28.2357:2400]
∅:D[8.14167] → [28.2357:2400]
B:BD[28.2357] → [28.2357:2400]
```
        command_type cmd = get_next_cmd();
```
[8.14167]
[8.14168]
```
        c_input_reset(true);
        
        const command_type cmd = get_next_cmd();
```

Insertion in crawl-ref/source/acr.cc at line 932 [11.4397395]

[8.14217]

[11.4420577]


        if (cmd != CMD_MOUSE_MOVE)
            c_input_reset(false);

Insertion in crawl-ref/source/acr.cc at line 941 [11.4397395]

[28.2643]


        if (cmd != CMD_MOUSE_MOVE)
            c_input_reset(false, true);

Deletion in crawl-ref/source/acr.cc at line 1140 [11.4397395]
B:BD[9.1265304] → [16.90662:90699]
```
//        Options.tut_made_note = 0;
```

Deletion in crawl-ref/source/acr.cc at line 1354 [11.4397395]

B:BD[14.551979] → [16.91125:91197]

∅:D[50.11873] → [14.551979:552167]

∅:D[16.91197] → [14.551979:552167]

B:BD[14.551979] → [14.551979:552167]

        if (Options.tut_explored)
            Options.tut_explored = 0;
        if (you.level_type == LEVEL_LABYRINTH || you.level_type == LEVEL_ABYSS)
        {
            mpr("It would help if you knew where you were, first.");
            break;
        }

Replacement in crawl-ref/source/acr.cc at line 1419 [11.4397395]

B:BD[11.4435764] → [11.4435764:4435816]

        yell();                 /* in effects.cc */

[11.4435764]

[11.4435816]

        yell();
        break;
    case CMD_MOUSE_MOVE:
        break;
    case CMD_MOUSE_CLICK:
    {
        // XXX: We should probably use specific commands such as
        // CMD_MOUSE_TRAVEL and get rid of CMD_MOUSE_CLICK and
        // CMD_MOUSE_MOVE.
        c_mouse_event cme = get_mouse_event();
        if (cme && crawl_view.in_view_viewport(cme.pos))
        {
            const coord_def dest = view2grid(cme.pos);
            if (cme.left_clicked())
            {
                if (in_bounds(dest))
                    start_travel(dest.x, dest.y);
            }
            else if (cme.right_clicked())
            {
                if (see_grid(dest.x, dest.y))
                    full_describe_square(dest);
                else
                    mpr("You can't see that place.");
            }
        }

Insertion in crawl-ref/source/acr.cc at line 1448 [11.4397395]
[11.4435831]
[11.4435831]
```
    }
```

Insertion in crawl-ref/source/acr.cc at line 2701 [11.4397395]

[9.1277380]


    case CK_MOUSE_MOVE:  return CMD_MOUSE_MOVE;
    case CK_MOUSE_CLICK: return CMD_MOUSE_CLICK;

Experimental mouse support for ncurses (enable with mouse_input=yes in

Dependencies

In channels

Change contents

Insertion in crawl-ref/source/view.cc at line 40 [11.16817]

Replacement in crawl-ref/source/view.cc at line 2522 [11.16817]

Insertion in crawl-ref/source/view.cc at line 2609 [11.16817]

Insertion in crawl-ref/source/view.cc at line 2612 [11.16817]

Replacement in crawl-ref/source/view.cc at line 2647 [11.16817]

Insertion in crawl-ref/source/view.cc at line 2811 [11.16817]

Replacement in crawl-ref/source/tutorial.cc at line 9 [16.5936]

Insertion in crawl-ref/source/travel.cc at line 17 [14.39949]

Insertion in crawl-ref/source/travel.cc at line 2556 [14.39949]

Insertion in crawl-ref/source/stash.cc at line 11 [14.147324]

Replacement in crawl-ref/source/spl-book.h at line 51 [11.395672]

Replacement in crawl-ref/source/spl-book.cc at line 28 [11.397614]

Replacement in crawl-ref/source/spl-book.cc at line 688 [11.397614]

Replacement in crawl-ref/source/spl-book.cc at line 830 [11.397614]

Replacement in crawl-ref/source/spl-book.cc at line 838 [11.397614]

Replacement in crawl-ref/source/skills2.cc at line 1821 [11.647133]

Replacement in crawl-ref/source/skills2.cc at line 1823 [11.647133]

Deletion in crawl-ref/source/skills2.cc at line 1825 [11.647133]

Deletion in crawl-ref/source/skills2.cc at line 1826 [11.647133]

Replacement in crawl-ref/source/skills2.cc at line 1842 [11.647133]

Replacement in crawl-ref/source/skills2.cc at line 1846 [11.647133]

Replacement in crawl-ref/source/skills2.cc at line 1933 [11.647133]

Replacement in crawl-ref/source/skills2.cc at line 1946 [11.647133]

Insertion in crawl-ref/source/skills2.cc at line 1960 [11.647133]

Replacement in crawl-ref/source/skills2.cc at line 1962 [11.647133]

Replacement in crawl-ref/source/skills2.cc at line 1970 [11.647133]

Replacement in crawl-ref/source/skills2.cc at line 1972 [11.647133]

Replacement in crawl-ref/source/skills2.cc at line 1975 [11.647133]

Insertion in crawl-ref/source/skills2.cc at line 1977 [11.647133]

Replacement in crawl-ref/source/skills2.cc at line 1981 [11.647133]

Replacement in crawl-ref/source/skills2.cc at line 1983 [11.647133]

Replacement in crawl-ref/source/skills2.cc at line 1989 [11.647133]

Replacement in crawl-ref/source/skills2.cc at line 1992 [11.647133]

Replacement in crawl-ref/source/skills2.cc at line 1998 [11.647133]

Replacement in crawl-ref/source/skills2.cc at line 2001 [11.647133]

Insertion in crawl-ref/source/skills2.cc at line 2003 [11.647133]

Deletion in crawl-ref/source/skills2.cc at line 2005 [11.647133]

Deletion in crawl-ref/source/skills2.cc at line 2007 [11.647133]

Replacement in crawl-ref/source/shopping.cc at line 28 [11.759950]

Deletion in crawl-ref/source/player.cc at line 2933 [11.962854]

Replacement in crawl-ref/source/player.cc at line 2941 [11.962854]

Replacement in crawl-ref/source/player.cc at line 2943 [11.962854]

Replacement in crawl-ref/source/player.cc at line 2945 [11.962854]

Replacement in crawl-ref/source/player.cc at line 2952 [11.962854]

Replacement in crawl-ref/source/player.cc at line 2957 [11.962854]

Deletion in crawl-ref/source/player.cc at line 2963 [11.962854]

Insertion in crawl-ref/source/notes.cc at line 13 [9.370339]

Insertion in crawl-ref/source/newgame.cc at line 74 [11.1132300]

Replacement in crawl-ref/source/message.cc at line 27 [11.1993826]

Insertion in crawl-ref/source/menu.cc at line 10 [14.261322]

Insertion in crawl-ref/source/makefile.obj at line 10 [22.79]

Insertion in crawl-ref/source/macro.cc at line 47 [11.2457534]

Replacement in crawl-ref/source/macro.cc at line 581 [11.2457534]

Replacement in crawl-ref/source/macro.cc at line 659 [11.2457534]

Replacement in crawl-ref/source/macro.cc at line 664 [11.2457534]

Replacement in crawl-ref/source/macro.cc at line 716 [11.2457534]

Replacement in crawl-ref/source/libw32c.h at line 31 [11.2475780]

Insertion in crawl-ref/source/libw32c.h at line 52 [11.2475780]

Insertion in crawl-ref/source/libw32c.cc at line 224 [11.2476860]

Replacement in crawl-ref/source/libw32c.cc at line 238 [11.2476860]

Replacement in crawl-ref/source/libw32c.cc at line 368 [11.2476860]

Replacement in crawl-ref/source/libw32c.cc at line 380 [11.2476860]

Replacement in crawl-ref/source/libw32c.cc at line 415 [11.2476860]

Replacement in crawl-ref/source/libw32c.cc at line 629 [11.2476860]

Replacement in crawl-ref/source/libw32c.cc at line 639 [11.2476860]

Insertion in crawl-ref/source/libw32c.cc at line 789 [11.2476860]

Replacement in crawl-ref/source/libw32c.cc at line 866 [11.2476860]

Replacement in crawl-ref/source/libw32c.cc at line 874 [11.2476860]

Replacement in crawl-ref/source/libw32c.cc at line 910 [11.2476860]

Replacement in crawl-ref/source/libw32c.cc at line 914 [11.2476860]

Replacement in crawl-ref/source/libw32c.cc at line 941 [11.2476860]

Replacement in crawl-ref/source/libw32c.cc at line 956 [11.2476860]

Replacement in crawl-ref/source/libutil.h at line 3 [11.2493627]

Deletion in crawl-ref/source/libutil.h at line 21 [11.2493627]

Deletion in crawl-ref/source/libutil.h at line 49 [11.2493627]

Deletion in crawl-ref/source/libutil.h at line 55 [11.2493627]