int key_offset = (mod & MOD_ALT) ? 3000 : 0;

    const int key_offset = (mod & MOD_ALT) ? 3000 : 0;

    bool is_ascii = ((keysym.unicode & 0xFF80) == 0);
    return is_ascii ? (keysym.unicode & 0x7F) + key_offset : 0;

    const bool is_ascii = ((keysym.unicode & 0xFF80) == 0);
    return (is_ascii ? (keysym.unicode & 0x7F) + key_offset : 0);

    return res;

    return (res);

    const unsigned int ticks_per_redraw = 80;

    const unsigned int ticks_per_redraw = 100;

    m_tooltip.clear();
    m_region_msg->alt_text().clear();

    // Don't update tool tips etc. in targetting mode.
    const bool mouse_target_mode
                = (mouse_control::current_mode() == MOUSE_MODE_TARGET_PATH
                   || mouse_control::current_mode() == MOUSE_MODE_TARGET_DIR);

            ticks = SDL_GetTicks();

            if (!mouse_target_mode)
            {
                ticks = SDL_GetTicks();

            last_loc = cur_loc;

                last_loc = cur_loc;

            if (event.type != SDL_USEREVENT)
            {
                tiles.clear_text_tags(TAG_CELL_DESC);
                m_region_msg->alt_text().clear();
            }

                if (event.type != SDL_USEREVENT)
                {
                    tiles.clear_text_tags(TAG_CELL_DESC);
                    m_region_msg->alt_text().clear();
                }

            // TODO enne - need to find a better time to decide when
            // to generate a tip or some way to say "yes, but unchanged".
            if (ticks > m_last_tick_moved)
            {
                m_region_msg->alt_text().clear();
                for (unsigned int i = 0;
                    i < m_layers[m_active_layer].m_regions.size(); i++)

                // TODO enne - need to find a better time to decide when
                // to generate a tip or some way to say "yes, but unchanged".
                if (tip_loc != cur_loc && ticks > m_last_tick_moved)

                    Region *reg = m_layers[m_active_layer].m_regions[i];
                    if (!reg->inside(m_mouse.x, m_mouse.y))
                        continue;
                    if (reg->update_alt_text(m_region_msg->alt_text()))
                        break;

                    m_region_msg->alt_text().clear();
                    for (unsigned int i = 0;
                         i < m_layers[m_active_layer].m_regions.size(); ++i)
                    {
                        Region *reg = m_layers[m_active_layer].m_regions[i];
                        if (!reg->inside(m_mouse.x, m_mouse.y))
                            continue;
                        if (reg->update_alt_text(m_region_msg->alt_text()))
                            break;
                    }

                    mouse_event.mod = m_key_mod;

                    mouse_event.mod  = m_key_mod;

        bool timeout = ((ticks - m_last_tick_moved
                         > (unsigned int)Options.tile_tooltip_ms)
                         && ticks > m_last_tick_moved);
        if (timeout)
            tip_loc = cur_loc;

        if (mouse_target_mode)
        {
            if (get_cursor() == you.pos())
                redraw();
        }
        else
        {
            const bool timeout = (ticks > m_last_tick_moved
                                  && (ticks - m_last_tick_moved
                                      > (unsigned int)Options.tile_tooltip_ms));
            if (timeout)
                tip_loc = cur_loc;

        if (tip_loc == cur_loc)
        {
            tiles.clear_text_tags(TAG_CELL_DESC);
            if (m_tooltip.empty())

            if (tip_loc == cur_loc)

                for (unsigned int i = 0;
                    i < m_layers[m_active_layer].m_regions.size(); i++)

                tiles.clear_text_tags(TAG_CELL_DESC);
                if (Options.tile_tooltip_ms > 0 && m_tooltip.empty())

                    Region *reg = m_layers[m_active_layer].m_regions[i];
                    if (!reg->inside(m_mouse.x, m_mouse.y))
                        continue;
                    if (reg->update_tip_text(m_tooltip))
                        break;

                    for (unsigned int i = 0;
                         i < m_layers[m_active_layer].m_regions.size(); ++i)
                    {
                        Region *reg = m_layers[m_active_layer].m_regions[i];
                        if (!reg->inside(m_mouse.x, m_mouse.y))
                            continue;
                        if (reg->update_tip_text(m_tooltip))
                            break;
                    }
                    m_need_redraw = true;

                m_need_redraw = true;

            }
            else
            {
// Don't redraw the cursor if we're just zooming by.
#if 0
                if (last_loc != cur_loc)
                    m_need_redraw = true;
#endif
                m_tooltip.clear();
                tip_loc.reset();

        }
        else
        {
            if (last_loc != cur_loc)
                m_need_redraw = true;
            m_tooltip.clear();
            tip_loc.reset();
        }

        if ((ticks - last_redraw_tick > ticks_per_redraw) || need_redraw())
        {
            redraw();
            last_redraw_tick = ticks;

            if ((ticks - last_redraw_tick > ticks_per_redraw) || need_redraw())
            {
                redraw();
                last_redraw_tick = ticks;
            }

    if (!m_tooltip.empty())

    if (Options.tile_tooltip_ms > 0 && !m_tooltip.empty())

        int cur = 0;
        if (fscanf(fp, "%s", fbuf) != EOF)

        if (fscanf(fp, "%s", fbuf) == EOF)

#if 0
            mpr("Read MODE.");
            if (strcmp(fbuf, "MODE=LOADING") == 0)
                mode0 = TILEP_M_LOADING;
#endif

            // We're currently not interested in the MODE setting. (jpeg)
            fclose(fp);
            return;

        int cur = 0;

        || mouse_control::current_mode() == MOUSE_MODE_TARGET_PATH

        }
/*
        if (p == TILEP_PART_BASE)
        {
            int p0 = (parts[p]-1) & (0xfe);
            if (((1-idx) & 1) == 1)
                p0++;
            parts[p] = p0 + 1;

        else if (idx == TILEP_SHOW_EQUIP)
            parts[p] = TILEP_SHOW_EQUIP;
        else
            parts[p] = 0;
*/
/*
        else if (idx < TILE_MAIN_MAX)
            parts[p] = TILE_MAIN_MAX;
        else if (idx >= TILEP_PLAYER_MAX)
            parts[p] = TILEP_PLAYER_MAX - 1;
        else if (idx < 0)
            parts[p] = 0;
        // TODO enne - is this right? did the old count end at idx not just subtotal?
        else if (idx >= tile_player_part_count[p])
            parts[p] = tile_player_part_count[p] - 1;
//          else if (idx > tilep_parts_total[p]) // bound it
//              parts[p] = tilep_parts_total[p];
        else
            parts[p] = idx;
*/

    mouse_control mc(MOUSE_MODE_TARGET);

    mouse_control mc(needs_path && !just_looking ? MOUSE_MODE_TARGET_PATH
                                                 : MOUSE_MODE_TARGET);

// Do we really need this? (jpeg)
// Looks like the redrawing routine already handles it.
#if 0

                        while (raycopy.pos() != moves.target && l < range)
                        {
                            l++;

                        while (raycopy.pos() != moves.target && range > l++)

                        }

#endif

        bool force_redraw = false;
        bool loop_done = false;

        bool force_redraw     = false;
        bool loop_done        = false;

     MOUSE_MODE_TARGET_PATH,