static gchar *
get_selected (BtCrashRecoverDialog * self)
{
GtkTreeModel *model;
GtkTreeIter iter;
gchar *log_name = NULL;
if (check_selection (self, &model, &iter)) {
gtk_tree_model_get (model, &iter, COL_LOG_NAME, &log_name, -1);
}
return log_name;
}
/*
* Erase a large portion of the screen: the whole screen, or the
* whole line, or parts thereof.
*/
static void erase_lots (int line_only, int from_begin, int to_end) {
unsigned long *startpos, *endpos;
if (line_only) {
startpos = cpos - curs_x;
endpos = startpos + cols+1;
} else {
startpos = scrtop;
endpos = startpos + rows * (cols+1);
}
if (!from_begin)
startpos = cpos;
if (!to_end)
endpos = cpos;
check_selection (startpos, endpos);
while (startpos < endpos)
*startpos++ = ERASE_CHAR;
}
static void
on_delete_clicked (GtkButton * button, gpointer user_data)
{
BtCrashRecoverDialog *self = BT_CRASH_RECOVER_DIALOG (user_data);
gchar *log_name = get_selected (self);
if (log_name) {
if (g_remove (log_name)) {
GST_WARNING ("failed removing '%s': %s", log_name, g_strerror (errno));
}
remove_selected (self);
g_free (log_name);
/* if that was the last entry, close dialog */
if (!check_selection (self, NULL, NULL)) {
gtk_dialog_response (GTK_DIALOG (self), GTK_RESPONSE_CLOSE);
}
}
}
/*
* Insert or delete characters within the current line. n is +ve if
* insertion is desired, and -ve for deletion.
*/
static void insch (int n) {
int dir = (n < 0 ? -1 : +1);
int m;
n = (n < 0 ? -n : n);
if (n > cols - curs_x)
n = cols - curs_x;
m = cols - curs_x - n;
check_selection (cpos, cpos+n);
if (dir < 0) {
memmove (cpos, cpos+n, m*TSIZE);
while (n--)
cpos[m++] = ERASE_CHAR;
} else {
memmove (cpos+n, cpos, m*TSIZE);
while (n--)
cpos[n] = ERASE_CHAR;
}
}
static void
remove_selected (BtCrashRecoverDialog * self)
{
GtkTreeModel *model;
GtkTreeIter iter;
if (check_selection (self, &model, &iter)) {
GtkTreeIter next_iter = iter;
gboolean have_next = gtk_tree_model_iter_next (model, &next_iter);
gtk_list_store_remove (GTK_LIST_STORE (model), &iter);
if (!have_next) {
have_next = gtk_tree_model_get_iter_first (model, &next_iter);
}
if (have_next) {
gtk_tree_selection_select_iter (gtk_tree_view_get_selection (GTK_TREE_VIEW
(self->priv->entries_list)), &next_iter);
}
}
}
static long subdev_do_ioctl(struct file *file, unsigned int cmd, void *arg)
{
struct video_device *vdev = video_devdata(file);
struct v4l2_subdev *sd = vdev_to_v4l2_subdev(vdev);
struct v4l2_fh *vfh = file->private_data;
#if defined(CPTCFG_VIDEO_V4L2_SUBDEV_API)
struct v4l2_subdev_fh *subdev_fh = to_v4l2_subdev_fh(vfh);
int rval;
#endif
switch (cmd) {
case VIDIOC_QUERYCTRL:
return v4l2_queryctrl(vfh->ctrl_handler, arg);
case VIDIOC_QUERY_EXT_CTRL:
return v4l2_query_ext_ctrl(vfh->ctrl_handler, arg);
case VIDIOC_QUERYMENU:
return v4l2_querymenu(vfh->ctrl_handler, arg);
case VIDIOC_G_CTRL:
return v4l2_g_ctrl(vfh->ctrl_handler, arg);
case VIDIOC_S_CTRL:
return v4l2_s_ctrl(vfh, vfh->ctrl_handler, arg);
case VIDIOC_G_EXT_CTRLS:
return v4l2_g_ext_ctrls(vfh->ctrl_handler, arg);
case VIDIOC_S_EXT_CTRLS:
return v4l2_s_ext_ctrls(vfh, vfh->ctrl_handler, arg);
case VIDIOC_TRY_EXT_CTRLS:
return v4l2_try_ext_ctrls(vfh->ctrl_handler, arg);
case VIDIOC_DQEVENT:
if (!(sd->flags & V4L2_SUBDEV_FL_HAS_EVENTS))
return -ENOIOCTLCMD;
return v4l2_event_dequeue(vfh, arg, file->f_flags & O_NONBLOCK);
case VIDIOC_SUBSCRIBE_EVENT:
return v4l2_subdev_call(sd, core, subscribe_event, vfh, arg);
case VIDIOC_UNSUBSCRIBE_EVENT:
return v4l2_subdev_call(sd, core, unsubscribe_event, vfh, arg);
#ifdef CPTCFG_VIDEO_ADV_DEBUG
case VIDIOC_DBG_G_REGISTER:
{
struct v4l2_dbg_register *p = arg;
if (!capable(CAP_SYS_ADMIN))
return -EPERM;
return v4l2_subdev_call(sd, core, g_register, p);
}
case VIDIOC_DBG_S_REGISTER:
{
struct v4l2_dbg_register *p = arg;
if (!capable(CAP_SYS_ADMIN))
return -EPERM;
return v4l2_subdev_call(sd, core, s_register, p);
}
#endif
case VIDIOC_LOG_STATUS: {
int ret;
pr_info("%s: ================= START STATUS =================\n",
sd->name);
ret = v4l2_subdev_call(sd, core, log_status);
pr_info("%s: ================== END STATUS ==================\n",
sd->name);
return ret;
}
#if defined(CPTCFG_VIDEO_V4L2_SUBDEV_API)
case VIDIOC_SUBDEV_G_FMT: {
struct v4l2_subdev_format *format = arg;
rval = check_format(sd, format);
if (rval)
return rval;
return v4l2_subdev_call(sd, pad, get_fmt, subdev_fh->pad, format);
}
case VIDIOC_SUBDEV_S_FMT: {
struct v4l2_subdev_format *format = arg;
rval = check_format(sd, format);
if (rval)
return rval;
return v4l2_subdev_call(sd, pad, set_fmt, subdev_fh->pad, format);
}
case VIDIOC_SUBDEV_G_CROP: {
struct v4l2_subdev_crop *crop = arg;
struct v4l2_subdev_selection sel;
rval = check_crop(sd, crop);
if (rval)
return rval;
memset(&sel, 0, sizeof(sel));
sel.which = crop->which;
sel.pad = crop->pad;
sel.target = V4L2_SEL_TGT_CROP;
rval = v4l2_subdev_call(
sd, pad, get_selection, subdev_fh->pad, &sel);
crop->rect = sel.r;
return rval;
}
case VIDIOC_SUBDEV_S_CROP: {
struct v4l2_subdev_crop *crop = arg;
struct v4l2_subdev_selection sel;
rval = check_crop(sd, crop);
if (rval)
return rval;
memset(&sel, 0, sizeof(sel));
sel.which = crop->which;
sel.pad = crop->pad;
sel.target = V4L2_SEL_TGT_CROP;
sel.r = crop->rect;
rval = v4l2_subdev_call(
sd, pad, set_selection, subdev_fh->pad, &sel);
crop->rect = sel.r;
return rval;
}
case VIDIOC_SUBDEV_ENUM_MBUS_CODE: {
struct v4l2_subdev_mbus_code_enum *code = arg;
if (code->which != V4L2_SUBDEV_FORMAT_TRY &&
code->which != V4L2_SUBDEV_FORMAT_ACTIVE)
return -EINVAL;
if (code->pad >= sd->entity.num_pads)
return -EINVAL;
return v4l2_subdev_call(sd, pad, enum_mbus_code, subdev_fh->pad,
code);
}
case VIDIOC_SUBDEV_ENUM_FRAME_SIZE: {
struct v4l2_subdev_frame_size_enum *fse = arg;
if (fse->which != V4L2_SUBDEV_FORMAT_TRY &&
fse->which != V4L2_SUBDEV_FORMAT_ACTIVE)
return -EINVAL;
if (fse->pad >= sd->entity.num_pads)
return -EINVAL;
return v4l2_subdev_call(sd, pad, enum_frame_size, subdev_fh->pad,
fse);
}
case VIDIOC_SUBDEV_G_FRAME_INTERVAL: {
struct v4l2_subdev_frame_interval *fi = arg;
if (fi->pad >= sd->entity.num_pads)
return -EINVAL;
return v4l2_subdev_call(sd, video, g_frame_interval, arg);
}
case VIDIOC_SUBDEV_S_FRAME_INTERVAL: {
struct v4l2_subdev_frame_interval *fi = arg;
if (fi->pad >= sd->entity.num_pads)
return -EINVAL;
return v4l2_subdev_call(sd, video, s_frame_interval, arg);
}
case VIDIOC_SUBDEV_ENUM_FRAME_INTERVAL: {
struct v4l2_subdev_frame_interval_enum *fie = arg;
if (fie->which != V4L2_SUBDEV_FORMAT_TRY &&
fie->which != V4L2_SUBDEV_FORMAT_ACTIVE)
return -EINVAL;
if (fie->pad >= sd->entity.num_pads)
return -EINVAL;
return v4l2_subdev_call(sd, pad, enum_frame_interval, subdev_fh->pad,
fie);
}
case VIDIOC_SUBDEV_G_SELECTION: {
struct v4l2_subdev_selection *sel = arg;
rval = check_selection(sd, sel);
if (rval)
return rval;
return v4l2_subdev_call(
sd, pad, get_selection, subdev_fh->pad, sel);
}
case VIDIOC_SUBDEV_S_SELECTION: {
struct v4l2_subdev_selection *sel = arg;
rval = check_selection(sd, sel);
if (rval)
return rval;
return v4l2_subdev_call(
sd, pad, set_selection, subdev_fh->pad, sel);
}
case VIDIOC_G_EDID: {
struct v4l2_subdev_edid *edid = arg;
rval = check_edid(sd, edid);
if (rval)
return rval;
return v4l2_subdev_call(sd, pad, get_edid, edid);
}
case VIDIOC_S_EDID: {
struct v4l2_subdev_edid *edid = arg;
rval = check_edid(sd, edid);
if (rval)
return rval;
return v4l2_subdev_call(sd, pad, set_edid, edid);
}
case VIDIOC_SUBDEV_DV_TIMINGS_CAP: {
struct v4l2_dv_timings_cap *cap = arg;
if (cap->pad >= sd->entity.num_pads)
return -EINVAL;
return v4l2_subdev_call(sd, pad, dv_timings_cap, cap);
}
case VIDIOC_SUBDEV_ENUM_DV_TIMINGS: {
struct v4l2_enum_dv_timings *dvt = arg;
if (dvt->pad >= sd->entity.num_pads)
return -EINVAL;
return v4l2_subdev_call(sd, pad, enum_dv_timings, dvt);
}
case VIDIOC_SUBDEV_QUERY_DV_TIMINGS:
return v4l2_subdev_call(sd, video, query_dv_timings, arg);
case VIDIOC_SUBDEV_G_DV_TIMINGS:
return v4l2_subdev_call(sd, video, g_dv_timings, arg);
case VIDIOC_SUBDEV_S_DV_TIMINGS:
return v4l2_subdev_call(sd, video, s_dv_timings, arg);
#endif
default:
return v4l2_subdev_call(sd, core, ioctl, cmd, arg);
}
return 0;
}
/*
* Remove everything currently in `inbuf' and stick it up on the
* in-memory display. There's a big state machine in here to
* process escape sequences...
*/
void term_out(void) {
int c;
int must_update = FALSE;
while ( (c = inbuf_getc()) != -1) {
#ifdef LOG
{
static FILE *fp = NULL;
if (!fp) fp = fopen("putty.log", "wb");
if (fp) fputc (c, fp);
}
#endif
switch (termstate) {
case TOPLEVEL:
do_toplevel:
switch (c) {
case '\005': /* terminal type query */
ldisc->send ("\033[?1;2c", 7);
break;
case '\007':
beep();
disptop = scrtop;
must_update = TRUE;
break;
case '\b':
if (curs_x == 0 && curs_y > 0)
curs_x = cols-1, curs_y--;
else if (wrapnext)
wrapnext = FALSE;
else
curs_x--;
fix_cpos;
disptop = scrtop;
must_update = TRUE;
break;
case '\016':
cset = 1;
break;
case '\017':
cset = 0;
break;
case '\033':
termstate = SEEN_ESC;
break;
case 0233:
termstate = SEEN_CSI;
esc_nargs = 1;
esc_args[0] = ARG_DEFAULT;
esc_query = FALSE;
break;
case 0235:
termstate = SEEN_OSC;
esc_args[0] = 0;
break;
case '\r':
curs_x = 0;
wrapnext = FALSE;
fix_cpos;
disptop = scrtop;
must_update = TRUE;
break;
case '\013':
case '\014':
case '\n':
if (curs_y == marg_b)
scroll (marg_t, marg_b, 1, TRUE);
else if (curs_y < rows-1)
curs_y++;
if (cfg.lfhascr)
curs_x = 0;
fix_cpos;
wrapnext = FALSE;
disptop = scrtop;
nl_count++;
break;
case '\t':
do {
curs_x++;
} while (curs_x < cols-1 && !tabs[curs_x]);
if (curs_x >= cols)
curs_x = cols-1;
{
unsigned long *old_cpos = cpos;
fix_cpos;
check_selection (old_cpos, cpos);
}
disptop = scrtop;
must_update = TRUE;
break;
default:
if (c >= ' ' && c != 0234) {
if (wrapnext) {
cpos[1] = ATTR_WRAPPED;
if (curs_y == marg_b)
scroll (marg_t, marg_b, 1, TRUE);
else if (curs_y < rows-1)
curs_y++;
curs_x = 0;
fix_cpos;
wrapnext = FALSE;
nl_count++;
}
if (insert)
insch (1);
check_selection (cpos, cpos+1);
*cpos++ = xlat_tty2scr((unsigned char)c) | curr_attr |
(c <= 0x7F ? cset_attr[cset] : ATTR_ASCII);
curs_x++;
if (curs_x == cols) {
cpos--;
curs_x--;
wrapnext = wrap;
}
disptop = scrtop;
}
}
break;
case IGNORE_NEXT:
termstate = TOPLEVEL;
break;
case OSC_MAYBE_ST:
/*
* This state is virtually identical to SEEN_ESC, with the
* exception that we have an OSC sequence in the pipeline,
* and _if_ we see a backslash, we process it.
*/
if (c == '\\') {
do_osc();
termstate = TOPLEVEL;
break;
}
/* else fall through */
case SEEN_ESC:
termstate = TOPLEVEL;
switch (c) {
case '\005': case '\007': case '\b': case '\016': case '\017':
case '\033': case 0233: case 0234: case 0235: case '\r':
case '\013': case '\014': case '\n': case '\t':
termstate = TOPLEVEL;
goto do_toplevel; /* hack... */
case ' ': /* some weird sequence? */
termstate = IGNORE_NEXT;
break;
case '[': /* enter CSI mode */
termstate = SEEN_CSI;
esc_nargs = 1;
esc_args[0] = ARG_DEFAULT;
esc_query = FALSE;
break;
case ']': /* xterm escape sequences */
termstate = SEEN_OSC;
esc_args[0] = 0;
break;
case '(': /* should set GL */
termstate = SET_GL;
break;
case ')': /* should set GR */
termstate = SET_GR;
break;
case '7': /* save cursor */
save_cursor (TRUE);
break;
case '8': /* restore cursor */
save_cursor (FALSE);
disptop = scrtop;
must_update = TRUE;
break;
case '=':
app_keypad_keys = TRUE;
break;
case '>':
app_keypad_keys = FALSE;
break;
case 'D': /* exactly equivalent to LF */
if (curs_y == marg_b)
scroll (marg_t, marg_b, 1, TRUE);
else if (curs_y < rows-1)
curs_y++;
fix_cpos;
wrapnext = FALSE;
disptop = scrtop;
nl_count++;
break;
case 'E': /* exactly equivalent to CR-LF */
curs_x = 0;
wrapnext = FALSE;
if (curs_y == marg_b)
scroll (marg_t, marg_b, 1, TRUE);
else if (curs_y < rows-1)
curs_y++;
fix_cpos;
wrapnext = FALSE;
nl_count++;
disptop = scrtop;
break;
case 'M': /* reverse index - backwards LF */
if (curs_y == marg_t)
scroll (marg_t, marg_b, -1, TRUE);
else if (curs_y > 0)
curs_y--;
fix_cpos;
wrapnext = FALSE;
disptop = scrtop;
must_update = TRUE;
break;
case 'Z': /* terminal type query */
ldisc->send ("\033[?6c", 5);
break;
case 'c': /* restore power-on settings */
power_on();
fix_cpos;
disptop = scrtop;
must_update = TRUE;
break;
case '#': /* ESC # 8 fills screen with Es :-) */
termstate = SEEN_ESCHASH;
break;
case 'H': /* set a tab */
tabs[curs_x] = TRUE;
break;
}
break;
case SEEN_CSI:
termstate = TOPLEVEL; /* default */
switch (c) {
case '\005': case '\007': case '\b': case '\016': case '\017':
case '\033': case 0233: case 0234: case 0235: case '\r':
case '\013': case '\014': case '\n': case '\t':
termstate = TOPLEVEL;
goto do_toplevel; /* hack... */
case '0': case '1': case '2': case '3': case '4':
case '5': case '6': case '7': case '8': case '9':
if (esc_nargs <= ARGS_MAX) {
if (esc_args[esc_nargs-1] == ARG_DEFAULT)
esc_args[esc_nargs-1] = 0;
esc_args[esc_nargs-1] =
10 * esc_args[esc_nargs-1] + c - '0';
}
termstate = SEEN_CSI;
break;
case ';':
if (++esc_nargs <= ARGS_MAX)
esc_args[esc_nargs-1] = ARG_DEFAULT;
termstate = SEEN_CSI;
break;
case '?':
esc_query = TRUE;
termstate = SEEN_CSI;
break;
case 'A': /* move up N lines */
move (curs_x, curs_y - def(esc_args[0], 1), 1);
disptop = scrtop;
must_update = TRUE;
break;
case 'B': case 'e': /* move down N lines */
move (curs_x, curs_y + def(esc_args[0], 1), 1);
disptop = scrtop;
must_update = TRUE;
break;
case 'C': case 'a': /* move right N cols */
move (curs_x + def(esc_args[0], 1), curs_y, 1);
disptop = scrtop;
must_update = TRUE;
break;
case 'D': /* move left N cols */
move (curs_x - def(esc_args[0], 1), curs_y, 1);
disptop = scrtop;
must_update = TRUE;
break;
case 'E': /* move down N lines and CR */
move (0, curs_y + def(esc_args[0], 1), 1);
disptop = scrtop;
must_update = TRUE;
break;
case 'F': /* move up N lines and CR */
move (0, curs_y - def(esc_args[0], 1), 1);
disptop = scrtop;
must_update = TRUE;
break;
case 'G': case '`': /* set horizontal posn */
move (def(esc_args[0], 1) - 1, curs_y, 0);
disptop = scrtop;
must_update = TRUE;
break;
case 'd': /* set vertical posn */
move (curs_x, (dec_om ? marg_t : 0) + def(esc_args[0], 1) - 1,
(dec_om ? 2 : 0));
disptop = scrtop;
must_update = TRUE;
break;
case 'H': case 'f': /* set horz and vert posns at once */
if (esc_nargs < 2)
esc_args[1] = ARG_DEFAULT;
move (def(esc_args[1], 1) - 1,
(dec_om ? marg_t : 0) + def(esc_args[0], 1) - 1,
(dec_om ? 2 : 0));
disptop = scrtop;
must_update = TRUE;
break;
case 'J': /* erase screen or parts of it */
{
unsigned int i = def(esc_args[0], 0) + 1;
if (i > 3)
i = 0;
erase_lots(FALSE, !!(i & 2), !!(i & 1));
}
disptop = scrtop;
must_update = TRUE;
break;
case 'K': /* erase line or parts of it */
{
unsigned int i = def(esc_args[0], 0) + 1;
if (i > 3)
i = 0;
erase_lots(TRUE, !!(i & 2), !!(i & 1));
}
disptop = scrtop;
must_update = TRUE;
break;
case 'L': /* insert lines */
if (curs_y <= marg_b)
scroll (curs_y, marg_b, -def(esc_args[0], 1), FALSE);
disptop = scrtop;
must_update = TRUE;
break;
case 'M': /* delete lines */
if (curs_y <= marg_b)
scroll (curs_y, marg_b, def(esc_args[0], 1), FALSE);
disptop = scrtop;
must_update = TRUE;
break;
case '@': /* insert chars */
insch (def(esc_args[0], 1));
disptop = scrtop;
must_update = TRUE;
break;
case 'P': /* delete chars */
insch (-def(esc_args[0], 1));
disptop = scrtop;
must_update = TRUE;
break;
case 'c': /* terminal type query */
ldisc->send ("\033[?6c", 5);
break;
case 'n': /* cursor position query */
if (esc_args[0] == 6) {
char buf[32];
sprintf (buf, "\033[%d;%dR", curs_y + 1, curs_x + 1);
ldisc->send (buf, strlen(buf));
}
break;
case 'h': /* toggle a mode to high */
toggle_mode (esc_args[0], esc_query, TRUE);
break;
case 'l': /* toggle a mode to low */
toggle_mode (esc_args[0], esc_query, FALSE);
break;
case 'g': /* clear tabs */
if (esc_nargs == 1) {
if (esc_args[0] == 0) {
tabs[curs_x] = FALSE;
} else if (esc_args[0] == 3) {
int i;
for (i = 0; i < cols; i++)
tabs[i] = FALSE;
}
}
break;
case 'r': /* set scroll margins */
if (!esc_query && esc_nargs <= 2) {
int top, bot;
top = def(esc_args[0], 1) - 1;
if (top < 0)
top = 0;
bot = (esc_nargs <= 1 || esc_args[1] == 0 ? rows :
def(esc_args[1], rows)) - 1;
if (bot >= rows)
bot = rows-1;
if (top <= bot) {
marg_t = top;
marg_b = bot;
curs_x = 0;
/*
* I used to think the cursor should be
* placed at the top of the newly marginned
* area. Apparently not: VMS TPU falls over
* if so.
*/
curs_y = 0;
fix_cpos;
disptop = scrtop;
must_update = TRUE;
}
}
break;
case 'm': /* set graphics rendition */
{
int i;
for (i=0; i<esc_nargs; i++) {
switch (def(esc_args[i], 0)) {
case 0: /* restore defaults */
curr_attr = ATTR_DEFAULT; break;
case 1: /* enable bold */
curr_attr |= ATTR_BOLD; break;
case 4: /* enable underline */
case 21: /* (enable double underline) */
curr_attr |= ATTR_UNDER; break;
case 7: /* enable reverse video */
curr_attr |= ATTR_REVERSE; break;
case 22: /* disable bold */
curr_attr &= ~ATTR_BOLD; break;
case 24: /* disable underline */
curr_attr &= ~ATTR_UNDER; break;
case 27: /* disable reverse video */
curr_attr &= ~ATTR_REVERSE; break;
case 30: case 31: case 32: case 33:
case 34: case 35: case 36: case 37:
/* foreground */
curr_attr &= ~ATTR_FGMASK;
curr_attr |= (esc_args[i] - 30) << ATTR_FGSHIFT;
break;
case 39: /* default-foreground */
curr_attr &= ~ATTR_FGMASK;
curr_attr |= ATTR_DEFFG;
break;
case 40: case 41: case 42: case 43:
case 44: case 45: case 46: case 47:
/* background */
curr_attr &= ~ATTR_BGMASK;
curr_attr |= (esc_args[i] - 40) << ATTR_BGSHIFT;
break;
case 49: /* default-background */
curr_attr &= ~ATTR_BGMASK;
curr_attr |= ATTR_DEFBG;
break;
}
}
}
break;
case 's': /* save cursor */
save_cursor (TRUE);
break;
case 'u': /* restore cursor */
save_cursor (FALSE);
disptop = scrtop;
must_update = TRUE;
break;
case 't': /* set page size - ie window height */
request_resize (cols, def(esc_args[0], 24));
deselect();
break;
case 'X': /* write N spaces w/o moving cursor */
{
int n = def(esc_args[0], 1);
unsigned long *p = cpos;
if (n > cols - curs_x)
n = cols - curs_x;
check_selection (cpos, cpos+n);
while (n--)
*p++ = ERASE_CHAR;
disptop = scrtop;
must_update = TRUE;
}
break;
case 'x': /* report terminal characteristics */
{
char buf[32];
int i = def(esc_args[0], 0);
if (i == 0 || i == 1) {
strcpy (buf, "\033[2;1;1;112;112;1;0x");
buf[2] += i;
ldisc->send (buf, 20);
}
}
break;
}
break;
case SET_GL:
case SET_GR:
switch (c) {
case 'A':
cset_attr[termstate == SET_GL ? 0 : 1] = ATTR_GBCHR;
break;
case '0':
cset_attr[termstate == SET_GL ? 0 : 1] = ATTR_LINEDRW;
break;
default: /* specifically, 'B' */
cset_attr[termstate == SET_GL ? 0 : 1] = ATTR_ASCII;
break;
}
termstate = TOPLEVEL;
break;
case SEEN_OSC:
osc_w = FALSE;
switch (c) {
case '\005': case '\007': case '\b': case '\016': case '\017':
case '\033': case 0233: case 0234: case 0235: case '\r':
case '\013': case '\014': case '\n': case '\t':
termstate = TOPLEVEL;
goto do_toplevel; /* hack... */
case 'P': /* Linux palette sequence */
termstate = SEEN_OSC_P;
osc_strlen = 0;
break;
case 'R': /* Linux palette reset */
palette_reset();
term_invalidate();
termstate = TOPLEVEL;
break;
case 'W': /* word-set */
termstate = SEEN_OSC_W;
osc_w = TRUE;
break;
case '0': case '1': case '2': case '3': case '4':
case '5': case '6': case '7': case '8': case '9':
esc_args[0] = 10 * esc_args[0] + c - '0';
break;
case 'L':
/*
* Grotty hack to support xterm and DECterm title
* sequences concurrently.
*/
if (esc_args[0] == 2) {
esc_args[0] = 1;
break;
}
/* else fall through */
default:
termstate = OSC_STRING;
osc_strlen = 0;
}
break;
case OSC_STRING:
if (c == 0234 || c == '\007') {
/*
* These characters terminate the string; ST and BEL
* terminate the sequence and trigger instant
* processing of it, whereas ESC goes back to SEEN_ESC
* mode unless it is followed by \, in which case it is
* synonymous with ST in the first place.
*/
do_osc();
termstate = TOPLEVEL;
} else if (c == '\033')
termstate = OSC_MAYBE_ST;
else if (osc_strlen < OSC_STR_MAX)
osc_string[osc_strlen++] = c;
break;
case SEEN_OSC_P:
{
int max = (osc_strlen == 0 ? 21 : 16);
int val;
if (c >= '0' && c <= '9')
val = c - '0';
else if (c >= 'A' && c <= 'A'+max-10)
val = c - 'A' + 10;
else if (c >= 'a' && c <= 'a'+max-10)
val = c - 'a' + 10;
else
termstate = TOPLEVEL;
osc_string[osc_strlen++] = val;
if (osc_strlen >= 7) {
palette_set (osc_string[0],
osc_string[1] * 16 + osc_string[2],
osc_string[3] * 16 + osc_string[4],
osc_string[5] * 16 + osc_string[6]);
term_invalidate();
termstate = TOPLEVEL;
}
}
break;
case SEEN_OSC_W:
switch (c) {
case '\005': case '\007': case '\b': case '\016': case '\017':
case '\033': case 0233: case 0234: case 0235: case '\r':
case '\013': case '\014': case '\n': case '\t':
termstate = TOPLEVEL;
goto do_toplevel; /* hack... */
case '0': case '1': case '2': case '3': case '4':
case '5': case '6': case '7': case '8': case '9':
esc_args[0] = 10 * esc_args[0] + c - '0';
break;
default:
termstate = OSC_STRING;
osc_strlen = 0;
}
break;
case SEEN_ESCHASH:
if (c == '8') {
unsigned long *p = scrtop;
int n = rows * (cols+1);
while (n--)
*p++ = ATTR_DEFAULT | 'E';
disptop = scrtop;
must_update = TRUE;
check_selection (scrtop, scrtop + rows * (cols+1));
}
termstate = TOPLEVEL;
break;
}
check_selection (cpos, cpos+1);
}
if (must_update || nl_count > MAXNL)
term_update();
}
void selection_cb(GtkWidget *ob, long data)
{
char str[256];
switch(data)
{
case 1:
selection_start = cur_pos;
calc_timecode(cur_pos,1);
gtk_label_set_text(GTK_LABEL(gtk_xlav->FSelStart),timecode);
break;
case 2:
selection_end = cur_pos;
calc_timecode(cur_pos,1);
gtk_label_set_text(GTK_LABEL(gtk_xlav->FSelEnd),timecode);
break;
case 3: /* Clear */
selection_start = -1;
selection_end = -1;
gtk_label_set_text(GTK_LABEL(gtk_xlav->FSelStart),"-:--:--:--");
gtk_label_set_text(GTK_LABEL(gtk_xlav->FSelEnd),"-:--:--:--");
break;
case 4: /* Cut */
case 5: /* Copy */
if(check_selection()) return;
sprintf(str,"e%c %d %d\n",(data==4)?'u':'o',selection_start,selection_end);
write(out_pipe,str,strlen(str));
if(data==4)
{
selection_start = -1;
selection_end = -1;
gtk_label_set_text(GTK_LABEL(gtk_xlav->FSelStart),"-:--:--:--");
gtk_label_set_text(GTK_LABEL(gtk_xlav->FSelEnd),"-:--:--:--");
}
break;
case 6: /* Paste */
if(check_selection()) return;
selection_start = -1;
selection_end = -1;
gtk_label_set_text(GTK_LABEL(gtk_xlav->FSelStart),"-:--:--:--");
gtk_label_set_text(GTK_LABEL(gtk_xlav->FSelEnd),"-:--:--:--");
write(out_pipe,"ep\n",3);
break;
case 7: /* Save All */
savetype=SAVE_ALL;
create_file_selection();
break;
case 8: /* Save */
if(check_selection()) return;
savetype=SAVE_SEL;
create_file_selection();
break;
case 11:
if(selection_start >= 0)
{
sprintf(str,"s%d\n",selection_start);
write(out_pipe,str,strlen(str));
}
else
printf("Selection Start is not set!\n");
break;
case 12:
if(selection_end >= 0)
{
sprintf(str,"s%d\n",selection_end);
write(out_pipe,str,strlen(str));
}
else
printf("Selection End is not set!\n");
break;
default:
printf("selection %ld\n",data);
}
}
void ximsStart()
{
int ret;
UserSelection *sel = &userSel;
OpStateVal oldOpState = OpState;
DPR(("ximsStart(): OpState=%s OpErrCode=%s[%d]\n",
StateName(), error_name(OpErrCode), OpErrCode));
OpState = State_Start;
#ifdef DEBUG
if (DebugLvl > 1) pr_UserSelection(sel);
#endif
ret = NoError;
if (oldOpState == State_Select_Err) {
/* don't change OpErrCode */
OpState = State_Start_Err;
return;
}
if (oldOpState == State_Select_Canceled) {
clear_UserSelection(sel);
ret = ErrNoSelection;
} else { /* save selection */
if (!(OpFlag & FLAG_NOSAVE) && (sel->flag & F_SELECT_CHANGED)) {
if (save_user_selection(sel, NULL) != NoError) {
DPR(("save_user_selection(): failed\n"));
put_xims_warnmsg(ErrSaveSelection, 0, 0, 0);
/* ret = ErrSaveSelection; */
}
}
}
if (ret != NoError) {
OpErrCode = ret;
OpState = State_Start_Err;
return;
}
if ((ret = check_selection(sel)) != NoError) {
if (ret == ErrIsNone || ret == ErrNotRun) {
build_run_env(sel); /* for make_new_environ() */
}
OpErrCode = ret;
OpState = State_Start_Done;
return;
}
build_run_env(sel);
if (useWINDOW()) /* initilaize Xt */
init_window_env();
ret = run_ims(sel);
OpErrCode = ret;
OpState = ret == NoError ? State_Start_Done : State_Start_Err;
return;
}