guacamole-spice-protocol/src/protocols/ssh/terminal.c

857 lines
25 KiB
C
Raw Normal View History

/* ***** BEGIN LICENSE BLOCK *****
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
*
* The contents of this file are subject to the Mozilla Public License Version
* 1.1 (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* The Original Code is libguac-client-ssh.
*
* The Initial Developer of the Original Code is
* Michael Jumper.
* Portions created by the Initial Developer are Copyright (C) 2011
* the Initial Developer. All Rights Reserved.
*
* Contributor(s):
* James Muehlner <dagger10k@users.sourceforge.net>
*
* Alternatively, the contents of this file may be used under the terms of
* either the GNU General Public License Version 2 or later (the "GPL"), or
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
* in which case the provisions of the GPL or the LGPL are applicable instead
* of those above. If you wish to allow use of your version of this file only
* under the terms of either the GPL or the LGPL, and not to allow others to
* use your version of this file under the terms of the MPL, indicate your
* decision by deleting the provisions above and replace them with the notice
* and other provisions required by the GPL or the LGPL. If you do not delete
* the provisions above, a recipient may use your version of this file under
* the terms of any one of the MPL, the GPL or the LGPL.
*
* ***** END LICENSE BLOCK ***** */
#include <stdlib.h>
#include <stdarg.h>
#include <string.h>
#include <pthread.h>
#include <cairo/cairo.h>
#include <pango/pangocairo.h>
2011-11-26 23:35:45 +00:00
#include <guacamole/socket.h>
#include <guacamole/protocol.h>
#include <guacamole/client.h>
2013-05-22 05:02:11 +00:00
#include <guacamole/error.h>
#include "types.h"
#include "buffer.h"
#include "common.h"
2013-04-25 18:55:50 +00:00
#include "display.h"
#include "terminal.h"
#include "terminal_handlers.h"
void guac_terminal_reset(guac_terminal* term) {
int row;
/* Set current state */
term->char_handler = guac_terminal_echo;
term->active_char_set = 0;
term->char_mapping[0] =
term->char_mapping[1] = NULL;
/* Reset cursor location */
term->cursor_row = term->visible_cursor_row = term->saved_cursor_row = 0;
term->cursor_col = term->visible_cursor_col = term->saved_cursor_col = 0;
/* Clear scrollback, buffer, and scoll region */
term->buffer->top = 0;
term->buffer->length = 0;
term->scroll_start = 0;
term->scroll_end = term->term_height - 1;
term->scroll_offset = 0;
/* Reset flags */
term->text_selected = false;
term->application_cursor_keys = false;
term->automatic_carriage_return = false;
term->insert_mode = false;
2013-05-26 08:49:47 +00:00
/* Reset tabs */
term->tab_interval = 8;
memset(term->custom_tabs, 0, sizeof(term->custom_tabs));
/* Clear terminal */
for (row=0; row<term->term_height; row++)
guac_terminal_set_columns(term, row, 0, term->term_width, &(term->default_char));
}
guac_terminal* guac_terminal_create(guac_client* client,
2013-05-26 06:50:13 +00:00
const char* font_name, int font_size,
2012-10-23 08:38:10 +00:00
int width, int height) {
2013-04-26 08:53:19 +00:00
guac_terminal_char default_char = {
.value = 0,
2013-04-26 08:53:19 +00:00
.attributes = {
.foreground = 7,
.background = 0,
.bold = false,
.reverse = false,
.underscore = false
}};
guac_terminal* term = malloc(sizeof(guac_terminal));
term->client = client;
/* Init buffer */
term->buffer = guac_terminal_buffer_alloc(1000, &default_char);
2012-10-23 08:38:10 +00:00
2013-04-25 18:55:50 +00:00
/* Init display */
term->display = guac_terminal_display_alloc(client,
2013-05-26 06:50:13 +00:00
font_name, font_size,
2013-04-26 08:53:19 +00:00
default_char.attributes.foreground,
default_char.attributes.background);
2012-10-23 08:38:10 +00:00
/* Init terminal state */
2013-04-26 08:53:19 +00:00
term->current_attributes = default_char.attributes;
term->default_char = default_char;
2012-10-23 08:38:10 +00:00
term->term_width = width / term->display->char_width;
term->term_height = height / term->display->char_height;
2013-05-22 05:02:11 +00:00
/* Open STDOUT pipe */
if (pipe(term->stdout_pipe_fd)) {
guac_error = GUAC_STATUS_SEE_ERRNO;
guac_error_message = "Unable to open pipe for STDOUT";
free(term);
return NULL;
}
/* Open STDIN pipe */
if (pipe(term->stdin_pipe_fd)) {
guac_error = GUAC_STATUS_SEE_ERRNO;
guac_error_message = "Unable to open pipe for STDIN";
free(term);
return NULL;
}
/* Init terminal lock */
pthread_mutex_init(&(term->lock), NULL);
/* Size display */
guac_terminal_display_resize(term->display,
term->term_width, term->term_height);
/* Init terminal */
guac_terminal_reset(term);
return term;
}
void guac_terminal_free(guac_terminal* term) {
2013-05-22 05:02:11 +00:00
/* Close terminal output pipe */
close(term->stdout_pipe_fd[1]);
close(term->stdout_pipe_fd[0]);
/* Close user input pipe */
close(term->stdin_pipe_fd[1]);
close(term->stdin_pipe_fd[0]);
2013-04-25 18:55:50 +00:00
/* Free display */
guac_terminal_display_free(term->display);
2013-03-24 00:43:35 +00:00
/* Free buffer */
guac_terminal_buffer_free(term->buffer);
}
2013-05-02 21:56:20 +00:00
int guac_terminal_set(guac_terminal* term, int row, int col, int codepoint) {
/* Build character with current attributes */
guac_terminal_char guac_char;
2013-05-02 21:56:20 +00:00
guac_char.value = codepoint;
guac_char.attributes = term->current_attributes;
2013-04-26 08:53:19 +00:00
guac_terminal_set_columns(term, row, col, col, &guac_char);
return 0;
}
void guac_terminal_commit_cursor(guac_terminal* term) {
2013-04-26 08:53:19 +00:00
guac_terminal_char* guac_char;
2013-04-05 20:12:18 +00:00
guac_terminal_buffer_row* old_row;
guac_terminal_buffer_row* new_row;
/* If no change, done */
if (term->visible_cursor_row == term->cursor_row && term->visible_cursor_col == term->cursor_col)
return;
/* Get old and new rows with cursor */
new_row = guac_terminal_buffer_get_row(term->buffer, term->cursor_row, term->cursor_col+1);
old_row = guac_terminal_buffer_get_row(term->buffer, term->visible_cursor_row, term->visible_cursor_col+1);
/* Clear cursor */
guac_char = &(old_row->characters[term->visible_cursor_col]);
guac_char->attributes.cursor = false;
guac_terminal_display_set_columns(term->display, term->visible_cursor_row + term->scroll_offset,
term->visible_cursor_col, term->visible_cursor_col, guac_char);
/* Set cursor */
guac_char = &(new_row->characters[term->cursor_col]);
guac_char->attributes.cursor = true;
guac_terminal_display_set_columns(term->display, term->cursor_row + term->scroll_offset,
term->cursor_col, term->cursor_col, guac_char);
term->visible_cursor_row = term->cursor_row;
term->visible_cursor_col = term->cursor_col;
return;
}
int guac_terminal_write(guac_terminal* term, const char* c, int size) {
while (size > 0) {
term->char_handler(term, *(c++));
size--;
}
return 0;
}
int guac_terminal_scroll_up(guac_terminal* term,
int start_row, int end_row, int amount) {
2013-04-26 17:55:55 +00:00
/* If scrolling entire display, update scroll offset */
if (start_row == 0 && end_row == term->term_height - 1) {
/* Scroll up visibly */
guac_terminal_display_copy_rows(term->display, start_row + amount, end_row, -amount);
/* Advance by scroll amount */
term->buffer->top += amount;
2013-04-28 08:28:49 +00:00
if (term->buffer->top >= term->buffer->available)
term->buffer->top -= term->buffer->available;
term->buffer->length += amount;
2013-04-28 08:28:49 +00:00
if (term->buffer->length > term->buffer->available)
term->buffer->length = term->buffer->available;
/* Update cursor location if within region */
if (term->visible_cursor_row >= start_row &&
term->visible_cursor_row <= end_row)
term->visible_cursor_row -= amount;
}
/* Otherwise, just copy row data upwards */
else
guac_terminal_copy_rows(term, start_row + amount, end_row, -amount);
2013-04-26 17:55:55 +00:00
/* Clear new area */
guac_terminal_clear_range(term,
end_row - amount + 1, 0,
end_row, term->term_width - 1);
2013-04-26 08:53:19 +00:00
return 0;
}
int guac_terminal_scroll_down(guac_terminal* term,
int start_row, int end_row, int amount) {
2013-05-03 05:50:33 +00:00
guac_terminal_copy_rows(term, start_row, end_row - amount, amount);
/* Clear new area */
guac_terminal_clear_range(term,
start_row, 0,
start_row + amount - 1, term->term_width - 1);
2013-04-26 08:53:19 +00:00
return 0;
}
2013-04-26 08:53:19 +00:00
int guac_terminal_clear_columns(guac_terminal* term,
int row, int start_col, int end_col) {
/* Build space */
guac_terminal_char blank;
blank.value = 0;
2013-04-26 08:53:19 +00:00
blank.attributes = term->current_attributes;
2013-04-26 08:53:19 +00:00
/* Clear */
guac_terminal_set_columns(term,
row, start_col, end_col, &blank);
2013-04-26 08:53:19 +00:00
return 0;
}
int guac_terminal_clear_range(guac_terminal* term,
int start_row, int start_col,
int end_row, int end_col) {
/* If not at far left, must clear sub-region to far right */
if (start_col > 0) {
/* Clear from start_col to far right */
2013-04-26 08:53:19 +00:00
guac_terminal_clear_columns(term,
start_row, start_col, term->term_width - 1);
/* One less row to clear */
start_row++;
}
/* If not at far right, must clear sub-region to far left */
if (end_col < term->term_width - 1) {
/* Clear from far left to end_col */
2013-04-26 08:53:19 +00:00
guac_terminal_clear_columns(term, end_row, 0, end_col);
/* One less row to clear */
end_row--;
}
/* Remaining region now guaranteed rectangular. Clear, if possible */
if (start_row <= end_row) {
2013-04-26 08:53:19 +00:00
int row;
for (row=start_row; row<=end_row; row++) {
/* Clear entire row */
guac_terminal_clear_columns(term, row, 0, term->term_width - 1);
}
}
return 0;
}
void guac_terminal_scroll_display_down(guac_terminal* terminal,
int scroll_amount) {
2013-04-05 18:31:46 +00:00
int start_row, end_row;
int dest_row;
int row, column;
/* Limit scroll amount by size of scrollback buffer */
if (scroll_amount > terminal->scroll_offset)
scroll_amount = terminal->scroll_offset;
/* If not scrolling at all, don't bother trying */
2013-04-28 08:28:49 +00:00
if (scroll_amount <= 0)
return;
/* Shift screen up */
if (terminal->term_height > scroll_amount)
2013-04-26 17:55:55 +00:00
guac_terminal_display_copy_rows(terminal->display,
scroll_amount, terminal->term_height - 1,
-scroll_amount);
/* Advance by scroll amount */
terminal->scroll_offset -= scroll_amount;
2013-04-05 18:31:46 +00:00
/* Get row range */
end_row = terminal->term_height - terminal->scroll_offset - 1;
start_row = end_row - scroll_amount + 1;
dest_row = terminal->term_height - scroll_amount;
/* Draw new rows from scrollback */
2013-04-05 18:31:46 +00:00
for (row=start_row; row<=end_row; row++) {
2013-04-25 19:10:01 +00:00
/* Get row from scrollback */
guac_terminal_buffer_row* buffer_row =
guac_terminal_buffer_get_row(terminal->buffer, row, 0);
2013-04-05 19:54:59 +00:00
/* Clear row */
guac_terminal_display_set_columns(terminal->display,
dest_row, 0, terminal->display->width, &(terminal->default_char));
2013-04-25 19:10:01 +00:00
/* Draw row */
guac_terminal_char* current = buffer_row->characters;
for (column=0; column<buffer_row->length; column++)
2013-04-26 17:55:55 +00:00
guac_terminal_display_set_columns(terminal->display,
dest_row, column, column, current++);
/* Next row */
2013-04-05 18:31:46 +00:00
dest_row++;
}
2013-04-26 08:53:19 +00:00
guac_terminal_display_flush(terminal->display);
guac_socket_flush(terminal->client->socket);
}
void guac_terminal_scroll_display_up(guac_terminal* terminal,
int scroll_amount) {
2013-04-05 18:31:46 +00:00
int start_row, end_row;
int dest_row;
int row, column;
/* Limit scroll amount by size of scrollback buffer */
2013-04-28 08:28:49 +00:00
if (terminal->scroll_offset + scroll_amount > terminal->buffer->length - terminal->term_height)
scroll_amount = terminal->buffer->length - terminal->scroll_offset - terminal->term_height;
/* If not scrolling at all, don't bother trying */
2013-04-28 08:28:49 +00:00
if (scroll_amount <= 0)
return;
/* Shift screen down */
if (terminal->term_height > scroll_amount)
2013-04-26 17:55:55 +00:00
guac_terminal_display_copy_rows(terminal->display,
0, terminal->term_height - scroll_amount - 1,
scroll_amount);
/* Advance by scroll amount */
terminal->scroll_offset += scroll_amount;
2013-04-05 18:31:46 +00:00
/* Get row range */
start_row = -terminal->scroll_offset;
end_row = start_row + scroll_amount - 1;
dest_row = 0;
/* Draw new rows from scrollback */
2013-04-05 18:31:46 +00:00
for (row=start_row; row<=end_row; row++) {
2013-04-05 18:31:46 +00:00
/* Get row from scrollback */
2013-04-25 19:10:01 +00:00
guac_terminal_buffer_row* buffer_row =
guac_terminal_buffer_get_row(terminal->buffer, row, 0);
/* Clear row */
guac_terminal_display_set_columns(terminal->display,
dest_row, 0, terminal->display->width, &(terminal->default_char));
/* Draw row */
2013-04-25 19:10:01 +00:00
guac_terminal_char* current = buffer_row->characters;
for (column=0; column<buffer_row->length; column++)
2013-04-26 17:55:55 +00:00
guac_terminal_display_set_columns(terminal->display,
dest_row, column, column, current++);
/* Next row */
2013-04-05 18:31:46 +00:00
dest_row++;
}
2013-04-26 08:53:19 +00:00
guac_terminal_display_flush(terminal->display);
guac_socket_flush(terminal->client->socket);
}
2013-05-06 08:02:23 +00:00
void guac_terminal_select_redraw(guac_terminal* terminal) {
guac_terminal_display_select(terminal->display,
terminal->selection_start_row + terminal->scroll_offset,
terminal->selection_start_column,
terminal->selection_end_row + terminal->scroll_offset,
terminal->selection_end_column);
}
void guac_terminal_select_start(guac_terminal* terminal, int row, int column) {
2013-05-06 08:02:23 +00:00
terminal->selection_start_row =
terminal->selection_end_row = row;
terminal->selection_start_column =
terminal->selection_end_column = column;
terminal->text_selected = true;
guac_terminal_select_redraw(terminal);
}
void guac_terminal_select_update(guac_terminal* terminal, int row, int column) {
2013-05-06 08:02:23 +00:00
if (row != terminal->selection_end_row || column != terminal->selection_end_column) {
terminal->selection_end_row = row;
terminal->selection_end_column = column;
guac_terminal_select_redraw(terminal);
}
}
int __guac_terminal_buffer_string(guac_terminal_buffer_row* row, int start, int end, char* string) {
int length = 0;
int i;
for (i=start; i<=end; i++) {
int codepoint = row->characters[i].value;
/* If not null (blank), add to string */
if (codepoint != 0) {
int bytes = guac_terminal_encode_utf8(codepoint, string);
string += bytes;
length += bytes;
}
}
return length;
}
void guac_terminal_select_end(guac_terminal* terminal, char* string) {
/* Deselect */
2013-05-06 08:02:23 +00:00
terminal->text_selected = false;
guac_terminal_display_commit_select(terminal->display);
guac_terminal_buffer_row* buffer_row;
int row;
int start_row, start_col;
int end_row, end_col;
/* Ensure proper ordering of start and end coords */
if (terminal->selection_start_row <= terminal->selection_end_row) {
start_row = terminal->selection_start_row;
start_col = terminal->selection_start_column;
end_row = terminal->selection_end_row;
end_col = terminal->selection_end_column;
}
else {
end_row = terminal->selection_start_row;
end_col = terminal->selection_start_column;
start_row = terminal->selection_end_row;
start_col = terminal->selection_end_column;
}
/* If only one row, simply copy */
buffer_row = guac_terminal_buffer_get_row(terminal->buffer, start_row, 0);
if (end_row == start_row) {
if (buffer_row->length - 1 < end_col)
end_col = buffer_row->length - 1;
string += __guac_terminal_buffer_string(buffer_row, start_col, end_col, string);
}
/* Otherwise, copy multiple rows */
else {
/* Store first row */
string += __guac_terminal_buffer_string(buffer_row, start_col, buffer_row->length - 1, string);
/* Store all middle rows */
for (row=start_row+1; row<end_row; row++) {
buffer_row = guac_terminal_buffer_get_row(terminal->buffer, row, 0);
*(string++) = '\n';
string += __guac_terminal_buffer_string(buffer_row, 0, buffer_row->length - 1, string);
}
/* Store last row */
buffer_row = guac_terminal_buffer_get_row(terminal->buffer, end_row, 0);
if (buffer_row->length - 1 < end_col)
end_col = buffer_row->length - 1;
*(string++) = '\n';
string += __guac_terminal_buffer_string(buffer_row, 0, end_col, string);
}
/* Null terminator */
*string = 0;
2013-04-26 08:53:19 +00:00
}
2013-04-26 08:53:19 +00:00
void guac_terminal_copy_columns(guac_terminal* terminal, int row,
int start_column, int end_column, int offset) {
2013-04-26 17:55:55 +00:00
2013-04-30 07:20:21 +00:00
guac_terminal_display_copy_columns(terminal->display, row + terminal->scroll_offset,
2013-04-26 17:55:55 +00:00
start_column, end_column, offset);
guac_terminal_buffer_copy_columns(terminal->buffer, row,
start_column, end_column, offset);
/* Update cursor location if within region */
if (row == terminal->visible_cursor_row &&
terminal->visible_cursor_col >= start_column &&
terminal->visible_cursor_col <= end_column)
terminal->visible_cursor_col += offset;
2013-04-26 08:53:19 +00:00
}
2013-04-26 08:53:19 +00:00
void guac_terminal_copy_rows(guac_terminal* terminal,
int start_row, int end_row, int offset) {
2013-04-26 17:55:55 +00:00
guac_terminal_display_copy_rows(terminal->display,
2013-04-30 07:20:21 +00:00
start_row + terminal->scroll_offset, end_row + terminal->scroll_offset, offset);
2013-04-26 17:55:55 +00:00
guac_terminal_buffer_copy_rows(terminal->buffer,
start_row, end_row, offset);
/* Update cursor location if within region */
if (terminal->visible_cursor_row >= start_row &&
terminal->visible_cursor_row <= end_row)
terminal->visible_cursor_row += offset;
2013-04-26 08:53:19 +00:00
}
2013-04-26 08:53:19 +00:00
void guac_terminal_set_columns(guac_terminal* terminal, int row,
int start_column, int end_column, guac_terminal_char* character) {
2013-04-30 07:20:21 +00:00
guac_terminal_display_set_columns(terminal->display, row + terminal->scroll_offset,
start_column, end_column, character);
guac_terminal_buffer_set_columns(terminal->buffer, row,
start_column, end_column, character);
/* If visible cursor in current row, preserve state */
if (row == terminal->visible_cursor_row
&& terminal->visible_cursor_col >= start_column
&& terminal->visible_cursor_col <= end_column) {
/* Create copy of character with cursor attribute set */
guac_terminal_char cursor_character = *character;
cursor_character.attributes.cursor = true;
guac_terminal_display_set_columns(terminal->display, row + terminal->scroll_offset,
terminal->visible_cursor_col, terminal->visible_cursor_col, &cursor_character);
guac_terminal_buffer_set_columns(terminal->buffer, row,
terminal->visible_cursor_col, terminal->visible_cursor_col, &cursor_character);
}
}
static void __guac_terminal_redraw_rect(guac_terminal* term, int start_row, int start_col, int end_row, int end_col) {
int row, col;
/* Redraw region */
for (row=start_row; row<=end_row; row++) {
guac_terminal_buffer_row* buffer_row =
guac_terminal_buffer_get_row(term->buffer, row - term->scroll_offset, 0);
/* Clear row */
guac_terminal_display_set_columns(term->display,
row, start_col, end_col, &(term->default_char));
/* Copy characters */
for (col=start_col; col <= end_col && col < buffer_row->length; col++)
guac_terminal_display_set_columns(term->display, row, col, col,
&(buffer_row->characters[col]));
}
}
2013-05-01 23:54:29 +00:00
void guac_terminal_resize(guac_terminal* term, int width, int height) {
/* If height is decreasing, shift display up */
if (height < term->term_height) {
int shift_amount;
/* Get number of rows actually occupying terminal space */
int used_height = term->buffer->length;
if (used_height > term->term_height)
used_height = term->term_height;
shift_amount = used_height - height;
/* If the new terminal bottom covers N rows, shift up N rows */
if (shift_amount > 0) {
guac_terminal_display_copy_rows(term->display,
shift_amount, term->display->height - 1, -shift_amount);
/* Update buffer top and cursor row based on shift */
term->buffer->top += shift_amount;
term->cursor_row -= shift_amount;
term->visible_cursor_row -= shift_amount;
/* Redraw characters within old region */
__guac_terminal_redraw_rect(term, height - shift_amount, 0, height-1, width-1);
}
}
2013-05-01 23:54:29 +00:00
/* Resize display */
guac_terminal_display_flush(term->display);
guac_terminal_display_resize(term->display, width, height);
/* Reraw any characters on right if widening */
if (width > term->term_width)
__guac_terminal_redraw_rect(term, 0, term->term_width-1, height-1, width-1);
/* If height is increasing, shift display down */
if (height > term->term_height) {
/* If undisplayed rows exist in the buffer, shift them into view */
if (term->term_height < term->buffer->length) {
/* If the new terminal bottom reveals N rows, shift down N rows */
int shift_amount = height - term->term_height;
/* The maximum amount we can shift is the number of undisplayed rows */
int max_shift = term->buffer->length - term->term_height;
if (shift_amount > max_shift)
shift_amount = max_shift;
/* Update buffer top and cursor row based on shift */
term->buffer->top -= shift_amount;
term->cursor_row += shift_amount;
term->visible_cursor_row += shift_amount;
/* If scrolled enough, use scroll to fulfill entire resize */
if (term->scroll_offset >= shift_amount) {
term->scroll_offset -= shift_amount;
/* Draw characters from scroll at bottom */
__guac_terminal_redraw_rect(term, term->term_height, 0, term->term_height + shift_amount - 1, width-1);
}
/* Otherwise, fulfill with as much scroll as possible */
else {
/* Draw characters from scroll at bottom */
__guac_terminal_redraw_rect(term, term->term_height, 0, term->term_height + term->scroll_offset - 1, width-1);
/* Update shift_amount and scroll based on new rows */
shift_amount -= term->scroll_offset;
term->scroll_offset = 0;
/* If anything remains, move screen as necessary */
if (shift_amount > 0) {
guac_terminal_display_copy_rows(term->display,
0, term->display->height - shift_amount - 1, shift_amount);
/* Draw characters at top from scroll */
__guac_terminal_redraw_rect(term, 0, 0, shift_amount - 1, width-1);
}
}
} /* end if undisplayed rows exist */
}
2013-05-01 23:54:29 +00:00
/* Commit new dimensions */
term->term_width = width;
term->term_height = height;
}
int guac_terminal_send_data(guac_terminal* term, const char* data, int length) {
return guac_terminal_write_all(term->stdin_pipe_fd[1], data, length);
}
int guac_terminal_send_string(guac_terminal* term, const char* data) {
return guac_terminal_write_all(term->stdin_pipe_fd[1], data, strlen(data));
}
int guac_terminal_sendf(guac_terminal* term, const char* format, ...) {
int written;
va_list ap;
char buffer[1024];
/* Print to buffer */
va_start(ap, format);
written = vsnprintf(buffer, sizeof(buffer)-1, format, ap);
va_end(ap);
if (written < 0)
return written;
/* Write to STDIN */
return guac_terminal_write_all(term->stdin_pipe_fd[1], buffer, written);
}
2013-05-26 08:49:47 +00:00
void guac_terminal_set_tab(guac_terminal* term, int column) {
int i;
/* Search for available space, set if available */
for (i=0; i<GUAC_TERMINAL_MAX_TABS; i++) {
/* Set tab if space free */
if (term->custom_tabs[i] == 0) {
term->custom_tabs[i] = column+1;
break;
}
}
}
void guac_terminal_unset_tab(guac_terminal* term, int column) {
int i;
/* Search for given tab, unset if found */
for (i=0; i<GUAC_TERMINAL_MAX_TABS; i++) {
/* Unset tab if found */
if (term->custom_tabs[i] == column+1) {
term->custom_tabs[i] = 0;
break;
}
}
}
void guac_terminal_clear_tabs(guac_terminal* term) {
term->tab_interval = 0;
memset(term->custom_tabs, 0, sizeof(term->custom_tabs));
}
int guac_terminal_next_tab(guac_terminal* term, int column) {
int i;
/* Determine tab stop from interval */
int tabstop;
if (term->tab_interval != 0)
tabstop = (column / term->tab_interval + 1) * term->tab_interval;
else
tabstop = term->term_width - 1;
/* Walk custom tabs, trying to find an earlier occurrence */
for (i=0; i<GUAC_TERMINAL_MAX_TABS; i++) {
int custom_tabstop = term->custom_tabs[i] - 1;
if (custom_tabstop != -1 && custom_tabstop > column && custom_tabstop < tabstop)
tabstop = custom_tabstop;
}
return tabstop;
}