[SOLVED] get cursor position in c

esmn · 05-31-2012, 03:04 PM

Is there any way to get cursor position in c?(no ncurses please)
this code report the cursor position:

Code:

echo -e "\033[6n"

how can I use it in c?

BeaverusIV · 05-31-2012, 04:59 PM

I would have a look at how curses does it. You might be able to pick a few commands out.

hydraMax · 06-01-2012, 01:21 AM

Quote:

Originally Posted by esmn

Is there any way to get cursor position in c?(no ncurses please)
this code report the cursor position:

Code:

echo -e "\033[6n"

how can I use it in c?

The ideal approach is to use the nice API from a toolkit, such as GTK+ or one of the many others available. However, you can do this more directly with the XLIB functions. One approach, at least, is to grab the pointer, and then catch the next button press event. From some code I wrote a while back:

Code:

	    Window rootw = XDefaultRootWindow(disp);
	    XEvent evt;
	    int err = XGrabPointer(disp,
				   rootw,
				   False,
				   ButtonPressMask,
				   GrabModeAsync,
				   GrabModeAsync,
				   None,
				   csr,
				   CurrentTime);
	    switch(err) {
            // ...
	    }
	    XNextEvent(disp, &evt);
            // ...
	    printf("Absolute coordinates: %d,%d\n", evt.xbutton.x_root, evt.xbutton.y_root);

All the commands used above have manual pages: XGrabPointer(3), XNextEvent(3), etc.

hydraMax · 06-01-2012, 01:24 AM

ERm... You probably meant the "terminal" cursor, didn't you?

esmn · 06-01-2012, 02:55 AM

Quote:

ERm... You probably meant the "terminal" cursor, didn't you?

yes. It's a terminal program.
but thanks for your reply.

NevemTeve · 06-01-2012, 03:47 AM

Use write(1,buf,len) for writing, read(0,buf,len) for reading... (but first use isatty to check you aren't redirected)

Edit: plus you may want to use termios, if you haven't done it yet (example: http://dtelnet.sourceforge.net/shkeys.c)

esmn · 06-01-2012, 11:43 AM

I use write() read() function:

Code:

/* get_cur_pos.c */
#include <stdio.h>
#include <unistd.h>
#include <termios.h>
int main()
{

	char buf[8];
	int curline;
	char cmd[]="echo -e '\033[6n'";
	struct termios save,raw;
	tcgetattr(0,&save);
	cfmakeraw(&raw); tcsetattr(0,TCSANOW,&raw);
	if (isatty(fileno(stdin))) 
	{
		write(1,cmd,sizeof(cmd));
		read (0 ,buf ,sizeof(buf));

		/* It doesn't work!!?
		sscanf(buf,"%d",curline);
		printf("\n\rCurrent Line: %d\n\r" , curline);
		*/

		printf("\n\rCurrent Line: %c%c\n\r" , buf[2] ,buf[3] );
	}
	tcsetattr(0,TCSANOW,&save);
	return 0;
}

but there are some problems:
-write() function print out "echo -e ' '" in the output:

Code:

esmn@deblin:$ ./get_cur_pos 
echo -e ''
Current Line: 2;
esmn@deblin:$

-sscanf doesn't work properly. so how can I use the result in the program?

-Is there any termios function to get cursor position?

NevemTeve · 06-01-2012, 01:16 PM

You don't write 'echo' to terminal, 'echo' means write in shell... Correction:

Code:

char cmd[]="\033[6n";

Also it's not 'scanf', but 'read'

Nominal Animal · 06-01-2012, 01:56 PM

Quote:

Originally Posted by esmn

there are some problems:
-write() function print out "echo -e ' '" in the output
-sscanf doesn't work properly
-Is there any termios function to get cursor position?

No, there is no termios function to get cursor position.

What you need to do is to use tcsetattr to disable echo (ECHO, fixing your write() problem), set noncanonical input mode (disabling ICANON, fixing your sscanf() problem), and I believe temporarily disable the receiver (disabling CREAD) while conversing with the terminal so that you do not mix actual standard input and console responses.

It is best to first use tcgetattr to get the current settings, save them so that you can restore them later (easiest is just to call it twice, saving the results to different structures), and edit only the relevant bits in the results.

You are going to have very little success with stdio.h, because of the internal caching (especially of input) it does, though. It works fine with unistd.h low-level I/O, though; you just have to check for the exit statuses carefully.

Here is a proof-of-concept shell script:

Code:

#!/bin/bash

# Get current settings.
if ! termios="$(stty -g 2>/dev/null)" ; then
    echo "Not running in a terminal." >&2
    exit 1
fi

# Restore terminal settings when the script exits.
trap "stty '$termios'" EXIT

# Disable ICANON ECHO. Should probably also disable CREAD.
stty -icanon -echo

# Request cursor coordinates
printf '\033[6n'

# Read response from standard input; note, it ends at R, not at newline
read -d "R" rowscols

# Clean up the rowscols (from \033[rows;cols -- the R at end was eaten)
rowscols="${rowscols//[^0-9;]/}"
rowscols=("${rowscols//;/ }")
printf '(row %d, column %d) ' ${rowscols[0]} ${rowscols[1]}

# Reset original terminal settings.
stty "$termios"

I threw together a proof-of-concept C code, too:

Code:

#include <unistd.h>
#include <fcntl.h>
#include <termios.h>
#include <errno.h>

#define   RD_EOF   -1
#define   RD_EIO   -2

static inline int rd(const int fd)
{
    unsigned char   buffer[4];
    ssize_t         n;

    while (1) {

        n = read(fd, buffer, 1);
        if (n > (ssize_t)0)
            return buffer[0];

        else
        if (n == (ssize_t)0)
            return RD_EOF;

        else
        if (n != (ssize_t)-1)
            return RD_EIO;

        else
        if (errno != EINTR && errno != EAGAIN && errno != EWOULDBLOCK)
            return RD_EIO;
    }
}

static inline int wr(const int fd, const char *const data, const size_t bytes)
{
    const char       *head = data;
    const char *const tail = data + bytes;
    ssize_t           n;

    while (head < tail) {

        n = write(fd, head, (size_t)(tail - head));
        if (n > (ssize_t)0)
            head += n;

        else
        if (n != (ssize_t)-1)
            return EIO;

        else
        if (errno != EINTR && errno != EAGAIN && errno != EWOULDBLOCK)
            return errno;
    }

    return 0;
}

/* Return a new file descriptor to the current TTY.
*/
int current_tty(void)
{
    const char *dev;
    int         fd;

    dev = ttyname(STDIN_FILENO);
    if (!dev)
        dev = ttyname(STDOUT_FILENO);
    if (!dev)
        dev = ttyname(STDERR_FILENO);
    if (!dev) {
        errno = ENOTTY;
        return -1;
    }

    do {
        fd = open(dev, O_RDWR | O_NOCTTY);
    } while (fd == -1 && errno == EINTR);
    if (fd == -1)
        return -1;

    return fd;
}

/* As the tty for current cursor position.
 * This function returns 0 if success, errno code otherwise.
 * Actual errno will be unchanged.
*/
int cursor_position(const int tty, int *const rowptr, int *const colptr)
{
    struct termios  saved, temporary;
    int             retval, result, rows, cols, saved_errno;

    /* Bad tty? */
    if (tty == -1)
        return ENOTTY;

    saved_errno = errno;

    /* Save current terminal settings. */
    do {
        result = tcgetattr(tty, &saved);
    } while (result == -1 && errno == EINTR);
    if (result == -1) {
        retval = errno;
        errno = saved_errno;
        return retval;
    }

    /* Get current terminal settings for basis, too. */
    do {
        result = tcgetattr(tty, &temporary);
    } while (result == -1 && errno == EINTR);
    if (result == -1) {
        retval = errno;
        errno = saved_errno;
        return retval;
    }

    /* Disable ICANON, ECHO, and CREAD. */
    temporary.c_lflag &= ~ICANON;
    temporary.c_lflag &= ~ECHO;
    temporary.c_cflag &= ~CREAD;

    /* This loop is only executed once. When broken out,
     * the terminal settings will be restored, and the function
     * will return retval to caller. It's better than goto.
    */
    do {

        /* Set modified settings. */
        do {
            result = tcsetattr(tty, TCSANOW, &temporary);
        } while (result == -1 && errno == EINTR);
        if (result == -1) {
            retval = errno;
            break;
        }

        /* Request cursor coordinates from the terminal. */
        retval = wr(tty, "\033[6n", 4);
        if (retval)
            break;

        /* Assume coordinate reponse parsing fails. */
        retval = EIO;

        /* Expect an ESC. */
        result = rd(tty);
        if (result != 27)
            break;

        /* Expect [ after the ESC. */
        result = rd(tty);
        if (result != '[')
            break;

        /* Parse rows. */
        rows = 0;
        result = rd(tty);
        while (result >= '0' && result <= '9') {
            rows = 10 * rows + result - '0';
            result = rd(tty);
        }

        if (result != ';')
            break;

        /* Parse cols. */
        cols = 0;
        result = rd(tty);
        while (result >= '0' && result <= '9') {
            cols = 10 * cols + result - '0';
            result = rd(tty);
        }

        if (result != 'R')
            break;

        /* Success! */

        if (rowptr)
            *rowptr = rows;

        if (colptr)
            *colptr = cols;

        retval = 0;

    } while (0);

    /* Restore saved terminal settings. */
    do {
        result = tcsetattr(tty, TCSANOW, &saved);
    } while (result == -1 && errno == EINTR);
    if (result == -1 && !retval)
        retval = errno;

    /* Done. */
    return retval;
}

int main(void)
{
    int         fd, row, col;
    char        buffer[64];
    char *const tail = buffer + sizeof(buffer);
    char       *head = buffer + sizeof(buffer);

    fd = current_tty();
    if (fd == -1)
        return 1;

    row = 0;
    col = 0;
    if (cursor_position(fd, &row, &col))
        return 2;

    if (row < 1 || col < 1)
        return 3;

    /* Construct response "(row, col) " from right to left,
     * then output it to standard error, and exit.
    */

    *(--head) = ' ';
    *(--head) = ')';

    {   unsigned int    u = col;
        do {
            *(--head) = '0' + (u % 10U);
            u /= 10U;
        } while (u);
    }

    *(--head) = ' ';
    *(--head) = ',';

    {   unsigned int    u = row;
        do {
            *(--head) = '0' + (u % 10U);
            u /= 10U;
        } while (u);
    }

    *(--head) = '(';

    if (wr(STDERR_FILENO, head, (size_t)(tail - head)))
        return 4;

    return 0;
}

I am not at all sure if disabling CREAD is sufficient to avoid mixing input with terminal output. The code seems to work even when there is pending input in standard input, but I don't know if that behaviour is Linux-specific or standard.

This is why a terminal library like ncurses is so useful: it handles both the input processing, and the conversation with the terminal. If you only need a subset of the functionality, I'm sure you could quite easily write your own, but you'd have to use low-level I/O like I did above. In that case, I'd keep the original terminal settings somewhere, and just flip the current settings when necessary; that saves a lot of unnecessary tcsetattr()/tcgetattr() calls. Also, when reading the terminal response, I'd use longer reads, and everything not a response moved to an input cache; it would be much faster, and would not discard proper input even if interspersed with the terminal responses.

Finally, in noncanonical mode, you can read individual keypresses, not just completed lines.

esmn · 06-02-2012, 03:34 AM

Thanks for complete guidance.

Of course ncurses is very useful but I like to handle terminal with
escape sequences and linux low level function.

irancplusplus · 09-02-2013, 08:12 AM

to be deleted

irancplusplus · 09-03-2013, 12:19 AM

to be deletedd