Return the character at the x,y of this console.

    .. deprecated:: 8.4
        Array access performs significantly faster than using this function.
        See :any:`Console.ch`.
164559
def console_get_char(con: tcod.console.Console, x: int, y: int) -> int:
    
    return lib.TCOD_console_get_char(_console(con), x, y)
85967
def console_get_char_background(
    con: tcod.console.Console, x: int, y: int
) -> Color:
    
    return Color._new_from_cdata(
        lib.TCOD_console_get_char_background(_console(con), x, y)
    )
414471
def lookup_character_keycode(self, character):
        
        keysym = self.string_to_keysym.get(character, 0)
        if keysym == 0:
            keysym = self.string_to_keysym.get(KEYSYMS[character], 0)
        return self.display.keysym_to_keycode(keysym)
887790
def xy(self):
        """"""
        if self._xy != (None, None):
            self._x, self._y = self._xy

        if self._x is not None and self._y is not None:
            x = self._x
            if self._x > 1:
                x = self._x / 65555
            y = self._y
            if self._y > 1:
                y = self._y / 65555
            return (x, y)

        return None
955669
def _assign_ascii_character(self, y_prev, y, y_next):  # noqa for complexity
            ''''''
            char = '?'
            if y_next > y and y_prev > y:
                char = '-'
            elif y_next < y and y_prev < y:
                char = '-'
            elif y_prev < y and y == y_next:
                char = '-'
            elif y_prev == y and y_next < y:
                char = '-'
            elif y_next > y:
                char = '/'
            elif y_next < y:
                char = '\\'
            elif y_prev < y:
                char = '/'
            elif y_prev > y:
                char = '\\'
            elif y_next == y:
                char = '-'
            elif y == y_prev:
                char = '-'
            return char
298509
def get_x():
    '''
    
    '''
    cmd = 'setxkbmap -query | grep layout'
    out = __salt__['cmd.run'](cmd, python_shell=True).split(':')
    return out[1].strip()
1012533
def console_get_char_foreground(
    con: tcod.console.Console, x: int, y: int
) -> Color:
    
    return Color._new_from_cdata(
        lib.TCOD_console_get_char_foreground(_console(con), x, y)
    )
1185712
def get_char(self, offset=0):
        """"""
        if not self.has_space(offset=offset):
            return ''

        return self.string[self.pos + offset]
646014
def console_fill_char(con: tcod.console.Console, arr: Sequence[int]) -> None:
    
    if isinstance(arr, np.ndarray):
        # numpy arrays, use numpy's ctypes functions
        np_array = np.ascontiguousarray(arr, dtype=np.intc)
        carr = ffi.cast("int *", np_array.ctypes.data)
    else:
        # otherwise convert using the ffi module
        carr = ffi.new("int[]", arr)

    lib.TCOD_console_fill_char(_console(con), carr)
1070415
function (c) {

// If a c parameter is provided, verify that it matches the current character.

            if (c && c !== ch) {
                error("Expected '" + c + "' instead of '" + ch + "'");
            }

// Get the next character. When there are no more characters,
// return the empty string.

            ch = text.charAt(at);
            at += 1;
            return ch;
        }
1248189
def pos(self, x=None, y=None):
        '''
        if x is None:
            info = CONSOLE_SCREEN_BUFFER_INFO()
            self.GetConsoleScreenBufferInfo(self.hout, byref(info))
            return (info.dwCursorPosition.X, info.dwCursorPosition.Y)
        else:
            return self.SetConsoleCursorPosition(self.hout, 
                                                 self.fixcoord(x, y))
40120
def char_repl(x):
    """"""
    r = ""
    for c in x:
        if ord(c) > 255:
            r += "?"
        else:
            r += c
    return r
110562
function Decoder() {
    var skip = 0 // how many bits we have from the previous character
    var byte = 0 // current byte we're producing

    this.output = ''

    // Consume a character from the stream, store
    // the output in this.output. As before, better
    // to use update().
    this.readChar = function(char) {
        if (typeof char != 'string'){
            if (typeof char == 'number') {
                char = String.fromCharCode(char)
            }
        }
        char = char.toLowerCase()
        var val = lookup()[char]
        if (typeof val == 'undefined') {
            // character does not exist in our lookup table
            return // skip silently. An alternative would be:
            // throw Error('Could not find character "' + char + '" in lookup table.')
        }
        val <<= 3 // move to the high bits
        byte |= val >>> skip
        skip += 5
        if (skip >= 8) {
            // we have enough to preduce output
            this.output += String.fromCharCode(byte)
            skip -= 8
            if (skip > 0) byte = (val << (5 - skip)) & 255
            else byte = 0
        }

    }

    this.finish = function(check) {
        var output = this.output + (skip < 0 ? alphabet[bits >> 3] : '') + (check ? '$' : '')
        this.output = ''
        return output
    }
}
1182603
def display_char(self,x,y,char):
	
	self.send_cmd("T"+str(x+1)+","+str(y+1)+","+char)
969164
def get_value_by_xy(self, x, y):
        
        if x < self.xMin or x > self.xMax or y < self.yMin or y > self.yMax:
            return None
            # raise ValueError("The x or y value must be within the Min and Max!")
        else:
            row = self.nRows - int(numpy.ceil((y - self.yMin) / self.dx))
            col = int(numpy.floor((x - self.xMin) / self.dx))
            value = self.data[row][col]
            if value == self.noDataValue:
                return None
            else:
                return value
827044
def get_symbol(x):
    
    hdl = SymbolHandle()
    check_call(_LIB.MXAutogradGetSymbol(x.handle, ctypes.byref(hdl)))
    return Symbol(hdl)
811201
private static int hexToInt(char c) {
        if ('0' <= c && c <= '9') {
            return c - '0';
        } else if ('a' <= c && c <= 'f') {
            return 10 + (c - 'a');
        } else if ('A' <= c && c <= 'F') {
            return 10 + (c - 'A');
        } else {
            return -1;
        }
    }