Lines Matching full:data
14 * WHATSOEVER RESULTING FROM LOSS OF MIND, USE, DATA OR PROFITS, WHETHER
319 struct window_copy_mode_data *data = wme->data;
324 evtimer_del(&data->dragtimer);
329 if (data->cy == 0) {
330 evtimer_add(&data->dragtimer, &tv);
332 } else if (data->cy == screen_size_y(&data->screen) - 1) {
333 evtimer_add(&data->dragtimer, &tv);
402 struct window_copy_mode_data *data;
405 wme->data = data = xcalloc(1, sizeof *data);
407 data->cursordrag = CURSORDRAG_NONE;
408 data->lineflag = LINE_SEL_NONE;
409 data->selflag = SEL_CHAR;
412 data->searchtype = WINDOW_COPY_SEARCHUP;
413 data->searchregex = wp->searchregex;
414 data->searchstr = xstrdup(wp->searchstr);
416 data->searchtype = WINDOW_COPY_OFF;
417 data->searchregex = 0;
418 data->searchstr = NULL;
420 data->searchx = data->searchy = data->searcho = -1;
421 data->searchall = 1;
423 data->jumptype = WINDOW_COPY_OFF;
424 data->jumpchar = NULL;
426 screen_init(&data->screen, screen_size_x(base), screen_size_y(base), 0);
427 screen_set_default_cursor(&data->screen, global_w_options);
428 data->modekeys = options_get_number(wp->window->options, "mode-keys");
430 evtimer_set(&data->dragtimer, window_copy_scroll_timer, wme);
432 return (data);
440 struct window_copy_mode_data *data;
445 data = window_copy_common_init(wme);
446 data->backing = window_copy_clone_screen(base, &data->screen, &cx, &cy,
449 data->cx = cx;
450 if (cy < screen_hsize(data->backing)) {
451 data->cy = 0;
452 data->oy = screen_hsize(data->backing) - cy;
454 data->cy = cy - screen_hsize(data->backing);
455 data->oy = 0;
458 data->scroll_exit = args_has(args, 'e');
459 data->hide_position = args_has(args, 'H');
462 data->screen.hyperlinks = hyperlinks_copy(base->hyperlinks);
463 data->screen.cx = data->cx;
464 data->screen.cy = data->cy;
465 data->mx = data->cx;
466 data->my = screen_hsize(data->backing) + data->cy - data->oy;
467 data->showmark = 0;
469 screen_write_start(&ctx, &data->screen);
470 for (i = 0; i < screen_size_y(&data->screen); i++)
472 screen_write_cursormove(&ctx, data->cx, data->cy, 0);
475 return (&data->screen);
483 struct window_copy_mode_data *data;
487 data = window_copy_common_init(wme);
488 data->viewmode = 1;
490 data->backing = xmalloc(sizeof *data->backing);
491 screen_init(data->backing, sx, screen_size_y(base), UINT_MAX);
492 data->writing = xmalloc(sizeof *data->writing);
493 screen_init(data->writing, sx, screen_size_y(base), 0);
494 data->ictx = input_init(NULL, NULL, NULL);
495 data->mx = data->cx;
496 data->my = screen_hsize(data->backing) + data->cy - data->oy;
497 data->showmark = 0;
499 return (&data->screen);
505 struct window_copy_mode_data *data = wme->data;
507 evtimer_del(&data->dragtimer);
509 free(data->searchmark);
510 free(data->searchstr);
511 free(data->jumpchar);
513 if (data->writing != NULL) {
514 screen_free(data->writing);
515 free(data->writing);
517 if (data->ictx != NULL)
518 input_free(data->ictx);
519 screen_free(data->backing);
520 free(data->backing);
522 screen_free(&data->screen);
523 free(data);
551 struct window_copy_mode_data *data = wme->data;
552 struct screen *backing = data->backing;
553 struct screen *writing = data->writing;
564 input_parse_screen(data->ictx, writing, window_copy_init_ctx_cb,
565 data, text, strlen(text));
569 old_hsize = screen_hsize(data->backing);
571 if (data->backing_written) {
579 data->backing_written = 1;
589 data->oy += screen_hsize(data->backing) - old_hsize;
591 screen_write_start_pane(&ctx, wp, &data->screen);
597 if (screen_hsize(data->backing))
622 struct window_copy_mode_data *data = wme->data;
627 u_int sy = screen_size_y(data->backing);
660 oy = screen_hsize(data->backing) + data->cy - data->oy;
663 if (data->cx != ox) {
664 data->lastcx = data->cx;
665 data->lastsx = ox;
667 data->cx = data->lastcx;
671 if (data->oy + n > screen_hsize(data->backing)) {
672 data->oy = screen_hsize(data->backing);
673 if (data->cy < n)
674 data->cy = 0;
676 data->cy -= n;
678 data->oy += n;
681 if (data->oy < n) {
682 data->oy = 0;
683 if (data->cy + (n - data->oy) >= sy)
684 data->cy = sy - 1;
686 data->cy += n - data->oy;
688 data->oy -= n;
692 data->cursordrag = CURSORDRAG_NONE;
694 if (data->screen.sel == NULL || !data->rectflag) {
695 py = screen_hsize(data->backing) + data->cy - data->oy;
697 if ((data->cx >= data->lastsx && data->cx != px) ||
698 data->cx > px)
702 if (scroll_exit && data->oy == 0) {
707 if (data->searchmark != NULL && !data->timeout)
708 window_copy_search_marks(wme, NULL, data->searchregex, 1);
722 struct window_copy_mode_data *data = wme->data;
723 struct screen *s = &data->screen;
726 oy = screen_hsize(data->backing) + data->cy - data->oy;
729 if (data->cx != ox) {
730 data->lastcx = data->cx;
731 data->lastsx = ox;
733 data->cx = data->lastcx;
743 if (data->oy + n > screen_hsize(data->backing)) {
744 data->oy = screen_hsize(data->backing);
745 if (data->cy < n)
746 data->cy = 0;
748 data->cy -= n;
750 data->oy += n;
752 if (data->screen.sel == NULL || !data->rectflag) {
753 py = screen_hsize(data->backing) + data->cy - data->oy;
755 if ((data->cx >= data->lastsx && data->cx != px) ||
756 data->cx > px)
760 if (data->searchmark != NULL && !data->timeout)
761 window_copy_search_marks(wme, NULL, data->searchregex, 1);
780 struct window_copy_mode_data *data = wme->data;
781 struct screen *s = &data->screen;
784 oy = screen_hsize(data->backing) + data->cy - data->oy;
787 if (data->cx != ox) {
788 data->lastcx = data->cx;
789 data->lastsx = ox;
791 data->cx = data->lastcx;
801 if (data->oy < n) {
802 data->oy = 0;
803 if (data->cy + (n - data->oy) >= screen_size_y(data->backing))
804 data->cy = screen_size_y(data->backing) - 1;
806 data->cy += n - data->oy;
808 data->oy -= n;
810 if (data->screen.sel == NULL || !data->rectflag) {
811 py = screen_hsize(data->backing) + data->cy - data->oy;
813 if ((data->cx >= data->lastsx && data->cx != px) ||
814 data->cx > px)
818 if (scroll_exit && data->oy == 0)
820 if (data->searchmark != NULL && !data->timeout)
821 window_copy_search_marks(wme, NULL, data->searchregex, 1);
830 struct window_copy_mode_data *data = wme->data;
833 oy = screen_hsize(data->backing) + data->cy - data->oy;
847 struct window_copy_mode_data *data = wme->data;
848 struct screen *s = &data->screen;
851 oy = screen_hsize(data->backing) + data->cy - data->oy;
852 maxy = screen_hsize(data->backing) + screen_size_y(s) - 1;
868 struct window_copy_mode_data *data = wme->data;
869 struct grid *gd = data->screen.grid;
878 struct window_copy_mode_data *data = wme->data;
879 struct grid *gd = data->screen.grid;
889 struct window_copy_mode_data *data = wme->data;
890 struct grid *gd = data->screen.grid;
892 return (format_grid_hyperlink(gd, data->cx, gd->hsize + data->cy,
893 &data->screen));
901 struct window_copy_mode_data *data = wme->data;
903 return (window_copy_get_word(wp, data->cx, data->cy));
911 struct window_copy_mode_data *data = wme->data;
913 return (window_copy_get_line(wp, data->cy));
921 struct window_copy_mode_data *data = wme->data;
923 return (window_copy_match_at_cursor(data));
929 struct window_copy_mode_data *data = wme->data;
930 u_int hsize = screen_hsize(data->backing);
933 gl = grid_get_line(data->backing->grid, hsize - data->oy);
936 format_add(ft, "scroll_position", "%d", data->oy);
937 format_add(ft, "rectangle_toggle", "%d", data->rectflag);
939 format_add(ft, "copy_cursor_x", "%d", data->cx);
940 format_add(ft, "copy_cursor_y", "%d", data->cy);
942 if (data->screen.sel != NULL) {
943 format_add(ft, "selection_start_x", "%d", data->selx);
944 format_add(ft, "selection_start_y", "%d", data->sely);
945 format_add(ft, "selection_end_x", "%d", data->endselx);
946 format_add(ft, "selection_end_y", "%d", data->endsely);
948 if (data->cursordrag != CURSORDRAG_NONE)
952 if (data->endselx != data->selx || data->endsely != data->sely)
961 format_add(ft, "search_present", "%d", data->searchmark != NULL);
962 format_add(ft, "search_timed_out", "%d", data->timeout);
963 if (data->searchcount != -1) {
964 format_add(ft, "search_count", "%d", data->searchcount);
965 format_add(ft, "search_count_partial", "%d", data->searchmore);
978 struct window_copy_mode_data *data = wme->data;
979 struct screen *s = &data->screen;
981 int search = (data->searchmark != NULL);
990 if (search && !data->timeout)
991 window_copy_search_marks(wme, NULL, data->searchregex, 0);
992 data->searchx = data->cx;
993 data->searchy = data->cy;
994 data->searcho = data->oy;
1000 struct window_copy_mode_data *data = wme->data;
1001 struct screen *s = &data->screen;
1002 struct grid *gd = data->backing->grid;
1007 cx = data->cx;
1008 cy = gd->hsize + data->cy - data->oy;
1012 screen_resize_cursor(data->backing, sx, sy, 1, 0, 0);
1016 data->cx = cx;
1018 data->cy = 0;
1019 data->oy = gd->hsize - cy;
1021 data->cy = cy - gd->hsize;
1022 data->oy = 0;
1043 struct window_copy_mode_data *data = wme->data;
1056 free(data->searchstr);
1057 data->searchstr = expanded;
1059 free(data->searchstr);
1060 data->searchstr = xstrdup(ss);
1104 struct window_copy_mode_data *data = wme->data;
1111 data->lineflag = LINE_SEL_NONE;
1112 data->selflag = SEL_CHAR;
1121 struct window_copy_mode_data *data = wme->data;
1123 data->cursordrag = CURSORDRAG_NONE;
1124 data->lineflag = LINE_SEL_NONE;
1125 data->selflag = SEL_CHAR;
1133 struct window_copy_mode_data *data = wme->data;
1135 data->cx = 0;
1136 data->cy = screen_size_y(&data->screen) - 1;
1168 struct window_copy_mode_data *data = wme->data;
1185 ocx = data->cx;
1186 ocy = data->cy;
1187 ooy = data->oy;
1210 data->cx = ocx;
1211 data->cy = ocy;
1212 data->oy = ooy;
1252 struct window_copy_mode_data *data = wme->data;
1271 ocx = data->cx;
1272 ocy = data->cy;
1273 ooy = data->oy;
1275 data->selflag = SEL_CHAR;
1298 data->cx = ocx;
1299 data->cy = ocy;
1300 data->oy = ooy;
1389 struct window_copy_mode_data *data = wme->data;
1392 cy = data->cy;
1395 if (cy == data->cy && data->oy == 0)
1415 struct window_copy_mode_data *data = wme->data;
1419 window_copy_cursor_right(wme, data->screen.sel != NULL &&
1420 data->rectflag);
1430 struct window_copy_mode_data *data = wme->data;
1434 scroll_up = data->cy - to;
1436 oy = screen_hsize(data->backing) - data->oy;
1439 * oy is the maximum scroll down amount, while data->oy is the maximum
1442 if (scroll_up > 0 && data->oy >= delta) {
1444 data->cy -= delta;
1447 data->cy += delta;
1458 struct window_copy_mode_data *data = cs->wme->data;
1461 bottom = screen_size_y(&data->screen) - 1;
1469 struct window_copy_mode_data *data = cs->wme->data;
1472 mid_value = (screen_size_y(&data->screen) - 1) / 2;
1507 struct window_copy_mode_data *data = wme->data;
1511 if (window_copy_pagedown1(wme, 1, data->scroll_exit))
1546 struct window_copy_mode_data *data = wme->data;
1548 data->hide_position = !data->hide_position;
1556 struct window_copy_mode_data *data = wme->data;
1557 struct screen *s = data->backing;
1560 oy = screen_hsize(s) + data->cy - data->oy;
1561 if (data->lineflag == LINE_SEL_RIGHT_LEFT && oy == data->endsely)
1564 data->cy = screen_size_y(&data->screen) - 1;
1565 data->cx = window_copy_find_length(wme, screen_hsize(s) + data->cy);
1566 data->oy = 0;
1568 if (data->searchmark != NULL && !data->timeout)
1569 window_copy_search_marks(wme, NULL, data->searchregex, 1);
1578 struct window_copy_mode_data *data = wme->data;
1581 oy = screen_hsize(data->backing) + data->cy - data->oy;
1582 if (data->lineflag == LINE_SEL_LEFT_RIGHT && oy == data->sely)
1585 data->cy = 0;
1586 data->cx = 0;
1587 data->oy = screen_hsize(data->backing);
1589 if (data->searchmark != NULL && !data->timeout)
1590 window_copy_search_marks(wme, NULL, data->searchregex, 1);
1599 struct window_copy_mode_data *data = wme->data;
1602 switch (data->jumptype) {
1627 struct window_copy_mode_data *data = wme->data;
1630 switch (data->jumptype) {
1655 struct window_copy_mode_data *data = wme->data;
1657 data->cx = 0;
1658 data->cy = (screen_size_y(&data->screen) - 1) / 2;
1669 struct window_copy_mode_data *data = wme->data;
1670 struct screen *s = data->backing;
1679 px = data->cx;
1680 py = screen_hsize(s) + data->cy - data->oy;
1692 if (gc.data.size != 1 || (gc.flags & GRID_FLAG_PADDING))
1695 found = *gc.data.data;
1699 if (data->modekeys == MODEKEY_EMACS) {
1733 if (gc.data.size == 1 &&
1735 if (*gc.data.data == found)
1737 else if (*gc.data.data == start)
1755 struct window_copy_mode_data *data = wme->data;
1756 struct screen *s = data->backing;
1766 px = data->cx;
1767 py = screen_hsize(s) + data->cy - data->oy;
1780 if (gc.data.size != 1 || (gc.flags & GRID_FLAG_PADDING))
1783 found = *gc.data.data;
1791 if (cp != NULL && data->modekeys == MODEKEY_VI) {
1792 sx = data->cx;
1793 sy = screen_hsize(s) + data->cy - data->oy;
1798 px = data->cx;
1799 py = screen_hsize(s) + data->cy - data->oy;
1801 if (gc.data.size == 1 &&
1803 strchr(close, *gc.data.data) != NULL)
1811 if (data->modekeys == MODEKEY_EMACS) {
1854 if (gc.data.size == 1 &&
1856 if (*gc.data.data == found)
1858 else if (*gc.data.data == end)
1937 struct window_copy_mode_data *data = wme->data;
1939 data->selflag = SEL_CHAR;
1949 struct window_copy_mode_data *data = wme->data;
1953 if (window_copy_pagedown1(wme, 0, data->scroll_exit))
2023 struct window_copy_mode_data *data = wme->data;
2025 data->lineflag = LINE_SEL_NONE;
2035 struct window_copy_mode_data *data = wme->data;
2037 data->lineflag = LINE_SEL_NONE;
2047 struct window_copy_mode_data *data = wme->data;
2049 data->lineflag = LINE_SEL_NONE;
2050 window_copy_rectangle_set(wme, !data->rectflag);
2059 struct window_copy_mode_data *data = wme->data;
2064 if (data->scroll_exit && data->oy == 0)
2073 struct window_copy_mode_data *data = wme->data;
2078 if (data->oy == 0)
2098 struct window_copy_mode_data *data = wme->data;
2101 if (data->searchtype == WINDOW_COPY_SEARCHUP) {
2103 window_copy_search_up(wme, data->searchregex);
2104 } else if (data->searchtype == WINDOW_COPY_SEARCHDOWN) {
2106 window_copy_search_down(wme, data->searchregex);
2115 struct window_copy_mode_data *data = wme->data;
2118 if (data->searchtype == WINDOW_COPY_SEARCHUP) {
2120 window_copy_search_down(wme, data->searchregex);
2121 } else if (data->searchtype == WINDOW_COPY_SEARCHDOWN) {
2123 window_copy_search_up(wme, data->searchregex);
2132 struct window_copy_mode_data *data = wme->data;
2135 data->lineflag = LINE_SEL_LEFT_RIGHT;
2136 data->rectflag = 0;
2137 data->selflag = SEL_LINE;
2138 data->dx = data->cx;
2139 data->dy = screen_hsize(data->backing) + data->cy - data->oy;
2142 data->selrx = data->cx;
2143 data->selry = screen_hsize(data->backing) + data->cy - data->oy;
2144 data->endselry = data->selry;
2147 data->endselry = screen_hsize(data->backing) + data->cy - data->oy;
2148 data->endselrx = window_copy_find_length(wme, data->endselry);
2162 struct window_copy_mode_data *data = wme->data;
2165 data->lineflag = LINE_SEL_LEFT_RIGHT;
2166 data->rectflag = 0;
2167 data->selflag = SEL_WORD;
2168 data->dx = data->cx;
2169 data->dy = screen_hsize(data->backing) + data->cy - data->oy;
2171 data->separators = options_get_string(session_options,
2173 window_copy_cursor_previous_word(wme, data->separators, 0);
2174 px = data->cx;
2175 py = screen_hsize(data->backing) + data->cy - data->oy;
2176 data->selrx = px;
2177 data->selry = py;
2183 if (grid_get_line(data->backing->grid, nexty)->flags &
2184 GRID_LINE_WRAPPED && nextx > screen_size_x(data->backing) - 1) {
2190 window_copy_cursor_next_word_end(wme, data->separators, 1);
2192 window_copy_update_cursor(wme, px, data->cy);
2194 window_copy_redraw_lines(wme, data->cy, 1);
2196 data->endselrx = data->cx;
2197 data->endselry = screen_hsize(data->backing) + data->cy - data->oy;
2198 if (data->dy > data->endselry) {
2199 data->dy = data->endselry;
2200 data->dx = data->endselrx;
2201 } else if (data->dx > data->endselrx)
2202 data->dx = data->endselrx;
2210 struct window_copy_mode_data *data = cs->wme->data;
2212 data->mx = data->cx;
2213 data->my = screen_hsize(data->backing) + data->cy - data->oy;
2214 data->showmark = 1;
2231 struct window_copy_mode_data *data = wme->data;
2233 data->cx = 0;
2234 data->cy = 0;
2341 struct window_copy_mode_data *data = wme->data;
2346 data->jumptype = WINDOW_COPY_JUMPBACKWARD;
2347 free(data->jumpchar);
2348 data->jumpchar = utf8_fromcstr(arg0);
2359 struct window_copy_mode_data *data = wme->data;
2364 data->jumptype = WINDOW_COPY_JUMPFORWARD;
2365 free(data->jumpchar);
2366 data->jumpchar = utf8_fromcstr(arg0);
2377 struct window_copy_mode_data *data = wme->data;
2382 data->jumptype = WINDOW_COPY_JUMPTOBACKWARD;
2383 free(data->jumpchar);
2384 data->jumpchar = utf8_fromcstr(arg0);
2395 struct window_copy_mode_data *data = wme->data;
2400 data->jumptype = WINDOW_COPY_JUMPTOFORWARD;
2401 free(data->jumpchar);
2402 data->jumpchar = utf8_fromcstr(arg0);
2440 struct window_copy_mode_data *data = wme->data;
2446 if (data->searchstr != NULL) {
2447 data->searchtype = WINDOW_COPY_SEARCHUP;
2448 data->searchregex = 1;
2449 data->timeout = 0;
2460 struct window_copy_mode_data *data = wme->data;
2466 if (data->searchstr != NULL) {
2467 data->searchtype = WINDOW_COPY_SEARCHUP;
2468 data->searchregex = 0;
2469 data->timeout = 0;
2480 struct window_copy_mode_data *data = wme->data;
2486 if (data->searchstr != NULL) {
2487 data->searchtype = WINDOW_COPY_SEARCHDOWN;
2488 data->searchregex = 1;
2489 data->timeout = 0;
2500 struct window_copy_mode_data *data = wme->data;
2506 if (data->searchstr != NULL) {
2507 data->searchtype = WINDOW_COPY_SEARCHDOWN;
2508 data->searchregex = 0;
2509 data->timeout = 0;
2520 struct window_copy_mode_data *data = wme->data;
2522 const char *ss = data->searchstr;
2526 data->timeout = 0;
2531 if (data->searchx == -1 || data->searchy == -1) {
2532 data->searchx = data->cx;
2533 data->searchy = data->cy;
2534 data->searcho = data->oy;
2536 data->cx = data->searchx;
2537 data->cy = data->searchy;
2538 data->oy = data->searcho;
2548 data->searchtype = WINDOW_COPY_SEARCHUP;
2549 data->searchregex = 0;
2550 free(data->searchstr);
2551 data->searchstr = xstrdup(arg0);
2558 data->searchtype = WINDOW_COPY_SEARCHDOWN;
2559 data->searchregex = 0;
2560 free(data->searchstr);
2561 data->searchstr = xstrdup(arg0);
2575 struct window_copy_mode_data *data = wme->data;
2577 const char *ss = data->searchstr;
2581 data->timeout = 0;
2586 if (data->searchx == -1 || data->searchy == -1) {
2587 data->searchx = data->cx;
2588 data->searchy = data->cy;
2589 data->searcho = data->oy;
2591 data->cx = data->searchx;
2592 data->cy = data->searchy;
2593 data->oy = data->searcho;
2603 data->searchtype = WINDOW_COPY_SEARCHDOWN;
2604 data->searchregex = 0;
2605 free(data->searchstr);
2606 data->searchstr = xstrdup(arg0);
2613 data->searchtype = WINDOW_COPY_SEARCHUP;
2614 data->searchregex = 0;
2615 free(data->searchstr);
2616 data->searchstr = xstrdup(arg0);
2630 struct window_copy_mode_data *data = wme->data;
2632 if (data->viewmode)
2635 screen_free(data->backing);
2636 free(data->backing);
2637 data->backing = window_copy_clone_screen(&wp->base, &data->screen, NULL,
3084 struct window_copy_mode_data *data = wme->data;
3131 if (strncmp(command, "search-", 7) != 0 && data->searchmark != NULL) {
3138 data->searchx = data->searchy = -1;
3155 struct window_copy_mode_data *data = wme->data;
3156 struct grid *gd = data->backing->grid;
3159 data->cx = px;
3161 if (py >= gd->hsize - data->oy && py < gd->hsize - data->oy + gd->sy)
3162 data->cy = py - (gd->hsize - data->oy);
3167 data->cy = py;
3170 data->cy = py - gd->hsize;
3173 data->cy = py - offset;
3175 data->oy = gd->hsize - offset;
3178 if (!no_redraw && data->searchmark != NULL && !data->timeout)
3179 window_copy_search_marks(wme, NULL, data->searchregex, 1);
3193 ud = &gc.data;
3195 sud = &sgc.data;
3197 if (*sud->data == '\t' && sud->size == 1 && gc.flags & GRID_FLAG_TAB)
3204 return (tolower(ud->data[0]) == sud->data[0]);
3206 return (memcmp(ud->data, sud->data, ud->size) == 0);
3238 padding += gc.data.width - 1;
3282 padding += gc.data.width - 1;
3431 return (&gce->data.data);
3439 utf8_to_data(gl->extddata[gce->offset].data, &ud);
3449 memcpy(copy, ud.data, ud.size);
3543 /* Map start of C string containing UTF-8 data to grid cell position. */
3559 /* Populate the array of cell data. */
3624 /* Free cell data. */
3798 window_copy_move_after_search_mark(struct window_copy_mode_data *data,
3801 struct screen *s = data->backing;
3804 if (window_copy_search_mark_at(data, *fx, *fy, &start) == 0 &&
3805 data->searchmark[start] != 0) {
3806 while (window_copy_search_mark_at(data, *fx, *fy, &at) == 0) {
3807 if (data->searchmark[at] != data->searchmark[start])
3828 struct window_copy_mode_data *data = wme->data;
3829 struct screen *s = data->backing, ss;
3832 const char *str = data->searchstr;
3840 data->searchdirection = direction;
3842 if (data->timeout)
3845 if (data->searchall || wp->searchstr == NULL ||
3848 data->searchall = 0;
3851 if (visible_only == 0 && data->searchmark != NULL)
3857 fx = data->cx;
3858 fy = screen_hsize(data->backing) - data->oy + data->cy;
3882 if (data->searchmark != NULL)
3883 window_copy_move_after_search_mark(data, &fx,
3903 fx = data->cx;
3904 fy = screen_hsize(data->backing) - data->oy + data->cy;
3911 window_copy_search_mark_at(data, fx, fy, &at) == 0 &&
3913 data->searchmark != NULL &&
3914 data->searchmark[at] == data->searchmark[at - 1]) {
3915 window_copy_move_after_search_mark(data, &fx, &fy,
3920 fx = data->cx;
3921 fy = screen_hsize(data->backing) - data->oy + data->cy;
3930 window_copy_move_after_search_mark(data, &fx,
3932 data->cx = fx;
3933 data->cy = fy - screen_hsize(data->backing) +
3934 data-> oy;
3941 if (window_copy_search_mark_at(data, fx, fy,
3943 while (window_copy_search_mark_at(data, fx, fy,
3945 data->searchmark != NULL &&
3946 data->searchmark[at] ==
3947 data->searchmark[start]) {
3948 data->cx = fx;
3949 data->cy = fy -
3950 screen_hsize(data->backing) +
3951 data-> oy;
3967 window_copy_visible_lines(struct window_copy_mode_data *data, u_int *start,
3970 struct grid *gd = data->backing->grid;
3973 for (*start = gd->hsize - data->oy; *start > 0; (*start)--) {
3978 *end = gd->hsize - data->oy + gd->sy;
3982 window_copy_search_mark_at(struct window_copy_mode_data *data, u_int px,
3985 struct screen *s = data->backing;
3988 if (py < gd->hsize - data->oy)
3990 if (py > gd->hsize - data->oy + gd->sy - 1)
3992 *at = ((py - (gd->hsize - data->oy)) * gd->sx) + px;
4003 window_copy_search_mark_match(struct window_copy_mode_data *data, u_int px,
4006 struct grid *gd = data->backing->grid;
4010 if (window_copy_search_mark_at(data, px, py, &b) == 0) {
4017 w += gc.data.width - 1;
4020 if (data->searchmark[i] != 0)
4022 data->searchmark[i] = data->searchgen;
4024 if (data->searchgen == UCHAR_MAX)
4025 data->searchgen = 1;
4027 data->searchgen++;
4037 struct window_copy_mode_data *data = wme->data;
4038 struct screen *s = data->backing, ss;
4052 width = screen_write_strlen("%s", data->searchstr);
4056 data->searchstr);
4062 cis = window_copy_is_lowercase(data->searchstr);
4080 window_copy_visible_lines(data, &start, &end);
4088 free(data->searchmark);
4089 data->searchmark = xcalloc(sx, sy);
4090 data->searchgen = 1;
4099 if (gc.data.width > 2)
4100 width += gc.data.width - 1;
4110 px += window_copy_search_mark_match(data, px, py, width,
4116 data->timeout = 1;
4124 if (data->timeout) {
4131 window_copy_visible_lines(data, &start, &end);
4139 data->searchcount = 1000;
4141 data->searchcount = 100;
4143 data->searchcount = 10;
4145 data->searchcount = -1;
4146 data->searchmore = 1;
4148 data->searchcount = nfound;
4149 data->searchmore = 0;
4164 struct window_copy_mode_data *data = wme->data;
4166 free(data->searchmark);
4167 data->searchmark = NULL;
4185 struct window_copy_mode_data *data = wme->data;
4192 if (lineno < 0 || (u_int)lineno > screen_hsize(data->backing))
4193 lineno = screen_hsize(data->backing);
4195 data->oy = lineno;
4201 window_copy_match_start_end(struct window_copy_mode_data *data, u_int at,
4204 struct grid *gd = data->backing->grid;
4206 u_char mark = data->searchmark[at];
4209 while (*start != 0 && data->searchmark[*start] == mark)
4211 if (data->searchmark[*start] != mark)
4213 while (*end != last && data->searchmark[*end] == mark)
4215 if (data->searchmark[*end] != mark)
4220 window_copy_match_at_cursor(struct window_copy_mode_data *data)
4222 struct grid *gd = data->backing->grid;
4225 u_int sx = screen_size_x(data->backing);
4229 if (data->searchmark == NULL)
4232 cy = screen_hsize(data->backing) - data->oy + data->cy;
4233 if (window_copy_search_mark_at(data, data->cx, cy, &at) != 0)
4235 if (data->searchmark[at] == 0) {
4237 if (at == 0 || data->searchmark[--at] == 0)
4240 window_copy_match_start_end(data, at, &start, &end);
4250 grid_get_cell(gd, px, gd->hsize + py - data->oy, &gc);
4256 buf = xrealloc(buf, len + gc.data.size + 1);
4257 memcpy(buf + len, gc.data.data, gc.data.size);
4258 len += gc.data.size;
4272 struct window_copy_mode_data *data = wme->data;
4277 if (data->showmark && fy == data->my) {
4279 if (fx == data->mx)
4291 if (data->searchmark == NULL)
4294 if (window_copy_search_mark_at(data, fx, fy, ¤t) != 0)
4296 mark = data->searchmark[current];
4300 cy = screen_hsize(data->backing) - data->oy + data->cy;
4301 if (window_copy_search_mark_at(data, data->cx, cy, &cursor) == 0) {
4305 data->searchdirection) {
4306 if (data->searchmark[cursor - 1] == mark) {
4310 } else if (data->searchmark[cursor] == mark)
4313 window_copy_match_start_end(data, cursor, &start, &end);
4346 struct window_copy_mode_data *data = wme->data;
4347 struct grid *gd = data->backing->grid;
4354 if (fx + gc.data.width <= nx) {
4367 struct window_copy_mode_data *data = wme->data;
4370 if (data == NULL)
4372 hsize = screen_hsize(data->backing);
4374 *offset = hsize - data->oy;
4384 struct window_copy_mode_data *data = wme->data;
4385 struct screen *s = &data->screen;
4389 u_int hsize = screen_hsize(data->backing);
4405 window_copy_write_one(wme, ctx, py, hsize - data->oy + py,
4408 if (py == 0 && s->rupper < s->rlower && !data->hide_position) {
4420 if (py == data->cy && data->cx == screen_size_x(s)) {
4441 struct window_copy_mode_data *data = wme->data;
4442 struct grid *gd = data->backing->grid;
4445 new_y = data->cy;
4458 if (data->selflag == SEL_WORD) {
4459 /* Last grid line in data coordinates. */
4460 if (end < gd->sy + data->oy - 1)
4470 struct window_copy_mode_data *data = wme->data;
4477 screen_write_cursormove(&ctx, data->cx, data->cy, 0);
4486 struct window_copy_mode_data *data = wme->data;
4488 window_copy_redraw_lines(wme, 0, screen_size_y(&data->screen));
4495 struct window_copy_mode_data *data = wme->data;
4498 xx = data->cx;
4499 yy = screen_hsize(data->backing) + data->cy - data->oy;
4500 switch (data->selflag) {
4505 if (data->dy > yy || (data->dy == yy && data->dx > xx)) {
4508 data->separators, &xx, &yy);
4512 data->endselx = data->endselrx;
4513 data->endsely = data->endselry;
4519 data->separators, &xx, &yy);
4523 data->selx = data->selrx;
4524 data->sely = data->selry;
4531 if (data->dy > yy) {
4537 data->endselx = data->endselrx;
4538 data->endsely = data->endselry;
4541 if (yy < data->endselry)
4542 yy = data->endselry;
4546 data->selx = data->selrx;
4547 data->sely = data->selry;
4554 data->selx = xx;
4555 data->sely = yy;
4557 data->endselx = xx;
4558 data->endsely = yy;
4565 struct window_copy_mode_data *data = wme->data;
4567 switch (data->cursordrag) {
4583 struct window_copy_mode_data *data = wme->data;
4584 struct screen *s = &data->screen;
4588 old_cx = data->cx; old_cy = data->cy;
4589 data->cx = cx; data->cy = cy;
4592 if (data->cx == screen_size_x(s))
4593 window_copy_redraw_lines(wme, data->cy, 1);
4596 screen_write_cursormove(&ctx, data->cx, data->cy, 0);
4604 struct window_copy_mode_data *data = wme->data;
4606 data->selx = data->cx;
4607 data->sely = screen_hsize(data->backing) + data->cy - data->oy;
4609 data->endselx = data->selx;
4610 data->endsely = data->sely;
4612 data->cursordrag = CURSORDRAG_ENDSEL;
4621 struct window_copy_mode_data *data = wme->data;
4622 struct screen *s = &data->screen;
4629 ty = screen_hsize(data->backing) - data->oy;
4632 if (!data->rectflag)
4637 if (!data->rectflag)
4654 struct window_copy_mode_data *data = wme->data;
4655 struct screen *s = &data->screen;
4657 if (s->sel == NULL && data->lineflag == LINE_SEL_NONE)
4667 struct window_copy_mode_data *data = wme->data;
4668 struct screen *s = &data->screen;
4678 sx = data->selx;
4679 sy = data->sely;
4683 endsx = data->endselx;
4684 endsy = data->endsely;
4699 screen_set_selection(s, sx, sy, endsx, endsy, data->rectflag,
4700 data->modekeys, &gc);
4702 if (data->rectflag && may_redraw) {
4708 cy = data->cy;
4709 if (data->cursordrag == CURSORDRAG_ENDSEL) {
4732 struct window_copy_mode_data *data = wme->data;
4733 struct screen *s = &data->screen;
4740 if (data->screen.sel == NULL && data->lineflag == LINE_SEL_NONE) {
4741 buf = window_copy_match_at_cursor(data);
4760 xx = data->endselx;
4761 yy = data->endsely;
4762 if (yy < data->sely || (yy == data->sely && xx < data->selx)) {
4764 ex = data->selx; ey = data->sely;
4766 sx = data->selx; sy = data->sely;
4789 if (data->rectflag) {
4794 if (data->cursordrag == CURSORDRAG_ENDSEL)
4795 selx = data->selx;
4797 selx = data->endselx;
4798 if (selx < data->cx) {
4801 lastex = data->cx;
4802 restex = data->cx;
4805 lastex = data->cx + 1;
4806 restex = data->cx + 1;
4814 firstsx = data->cx;
4815 restsx = data->cx;
4834 /* Don't bother if no data. */
4842 if (~grid_get_line(data->backing->grid, ey)->flags &
4959 struct window_copy_mode_data *data = wme->data;
4960 struct grid *gd = data->backing->grid;
4996 utf8_copy(&ud, &gc.data);
4998 s = tty_acs_get(NULL, ud.data[0]);
4999 if (s != NULL && strlen(s) <= sizeof ud.data) {
5001 memcpy(ud.data, s, ud.size);
5006 memcpy(*buf + *off, ud.data, ud.size);
5021 struct window_copy_mode_data *data = wme->data;
5024 screen_clear_selection(&data->screen);
5026 data->cursordrag = CURSORDRAG_NONE;
5027 data->lineflag = LINE_SEL_NONE;
5028 data->selflag = SEL_CHAR;
5030 py = screen_hsize(data->backing) + data->cy - data->oy;
5032 if (data->cx > px)
5033 window_copy_update_cursor(wme, px, data->cy);
5040 struct window_copy_mode_data *data = wme->data;
5042 return (grid_in_set(data->backing->grid, px, py, set));
5048 struct window_copy_mode_data *data = wme->data;
5050 return (grid_line_length(data->backing->grid, py));
5056 struct window_copy_mode_data *data = wme->data;
5057 struct screen *back_s = data->backing;
5061 px = data->cx;
5063 py = hsize + data->cy - data->oy;
5064 oldy = data->cy;
5069 window_copy_acquire_cursor_up(wme, hsize, data->oy, oldy, px, py);
5075 struct window_copy_mode_data *data = wme->data;
5076 struct screen *back_s = data->backing;
5080 px = data->cx;
5082 py = hsize + data->cy - data->oy;
5083 oldy = data->cy;
5088 window_copy_acquire_cursor_up(wme, hsize, data->oy, oldy, px, py);
5094 struct window_copy_mode_data *data = wme->data;
5095 struct screen *back_s = data->backing;
5099 px = data->cx;
5101 py = hsize + data->cy - data->oy;
5102 oldy = data->cy;
5105 if (data->screen.sel != NULL && data->rectflag)
5111 data->oy, oldy, px, py, 0);
5117 struct window_copy_mode_data *data = wme->data;
5118 struct screen *s = &data->screen;
5121 if (s->sel == NULL && data->lineflag == LINE_SEL_NONE)
5124 if (data->lineflag == LINE_SEL_LEFT_RIGHT)
5125 data->lineflag = LINE_SEL_RIGHT_LEFT;
5126 else if (data->lineflag == LINE_SEL_RIGHT_LEFT)
5127 data->lineflag = LINE_SEL_LEFT_RIGHT;
5129 switch (data->cursordrag) {
5132 data->cursordrag = CURSORDRAG_ENDSEL;
5135 data->cursordrag = CURSORDRAG_SEL;
5139 selx = data->endselx;
5140 sely = data->endsely;
5141 if (data->cursordrag == CURSORDRAG_SEL) {
5142 selx = data->selx;
5143 sely = data->sely;
5146 cy = data->cy;
5147 yy = screen_hsize(data->backing) + data->cy - data->oy;
5149 data->cx = selx;
5151 hsize = screen_hsize(data->backing);
5152 if (sely < hsize - data->oy) { /* above */
5153 data->oy = hsize - sely;
5154 data->cy = 0;
5155 } else if (sely > hsize - data->oy + screen_size_y(s)) { /* below */
5156 data->oy = hsize - sely + screen_size_y(s) - 1;
5157 data->cy = screen_size_y(s) - 1;
5159 data->cy = cy + sely - yy;
5168 struct window_copy_mode_data *data = wme->data;
5169 struct screen *back_s = data->backing;
5173 px = data->cx;
5175 py = hsize + data->cy - data->oy;
5176 oldy = data->cy;
5181 window_copy_acquire_cursor_up(wme, hsize, data->oy, oldy, px, py);
5187 struct window_copy_mode_data *data = wme->data;
5188 struct screen *back_s = data->backing;
5192 px = data->cx;
5194 py = hsize + data->cy - data->oy;
5195 oldy = data->cy;
5201 data->oy, oldy, px, py, 0);
5207 struct window_copy_mode_data *data = wme->data;
5208 struct screen *s = &data->screen;
5212 norectsel = data->screen.sel == NULL || !data->rectflag;
5213 oy = screen_hsize(data->backing) + data->cy - data->oy;
5215 if (norectsel && data->cx != ox) {
5216 data->lastcx = data->cx;
5217 data->lastsx = ox;
5220 if (data->lineflag == LINE_SEL_LEFT_RIGHT && oy == data->sely)
5223 if (scroll_only || data->cy == 0) {
5225 data->cx = data->lastcx;
5228 if (data->cy == screen_size_y(s) - 1)
5229 window_copy_redraw_lines(wme, data->cy, 1);
5231 window_copy_redraw_lines(wme, data->cy, 2);
5235 window_copy_update_cursor(wme, data->lastcx,
5236 data->cy - 1);
5238 window_copy_update_cursor(wme, data->cx, data->cy - 1);
5240 if (data->cy == screen_size_y(s) - 1)
5241 window_copy_redraw_lines(wme, data->cy, 1);
5243 window_copy_redraw_lines(wme, data->cy, 2);
5248 py = screen_hsize(data->backing) + data->cy - data->oy;
5250 if ((data->cx >= data->lastsx && data->cx != px) ||
5251 data->cx > px)
5253 window_copy_update_cursor(wme, px, data->cy);
5255 window_copy_redraw_lines(wme, data->cy, 1);
5259 if (data->lineflag == LINE_SEL_LEFT_RIGHT)
5261 py = screen_hsize(data->backing) + data->cy - data->oy;
5262 if (data->rectflag)
5263 px = screen_size_x(data->backing);
5266 window_copy_update_cursor(wme, px, data->cy);
5268 window_copy_redraw_lines(wme, data->cy, 1);
5270 else if (data->lineflag == LINE_SEL_RIGHT_LEFT)
5272 window_copy_update_cursor(wme, 0, data->cy);
5274 window_copy_redraw_lines(wme, data->cy, 1);
5281 struct window_copy_mode_data *data = wme->data;
5282 struct screen *s = &data->screen;
5286 norectsel = data->screen.sel == NULL || !data->rectflag;
5287 oy = screen_hsize(data->backing) + data->cy - data->oy;
5289 if (norectsel && data->cx != ox) {
5290 data->lastcx = data->cx;
5291 data->lastsx = ox;
5294 if (data->lineflag == LINE_SEL_RIGHT_LEFT && oy == data->endsely)
5297 if (scroll_only || data->cy == screen_size_y(s) - 1) {
5299 data->cx = data->lastcx;
5301 if (scroll_only && data->cy > 0)
5302 window_copy_redraw_lines(wme, data->cy - 1, 2);
5305 window_copy_update_cursor(wme, data->lastcx,
5306 data->cy + 1);
5308 window_copy_update_cursor(wme, data->cx, data->cy + 1);
5310 window_copy_redraw_lines(wme, data->cy - 1, 2);
5314 py = screen_hsize(data->backing) + data->cy - data->oy;
5316 if ((data->cx >= data->lastsx && data->cx != px) ||
5317 data->cx > px)
5319 window_copy_update_cursor(wme, px, data->cy);
5321 window_copy_redraw_lines(wme, data->cy, 1);
5325 if (data->lineflag == LINE_SEL_LEFT_RIGHT)
5327 py = screen_hsize(data->backing) + data->cy - data->oy;
5328 if (data->rectflag)
5329 px = screen_size_x(data->backing);
5332 window_copy_update_cursor(wme, px, data->cy);
5334 window_copy_redraw_lines(wme, data->cy, 1);
5336 else if (data->lineflag == LINE_SEL_RIGHT_LEFT)
5338 window_copy_update_cursor(wme, 0, data->cy);
5340 window_copy_redraw_lines(wme, data->cy, 1);
5347 struct window_copy_mode_data *data = wme->data;
5348 struct screen *back_s = data->backing;
5352 px = data->cx + 1;
5354 py = hsize + data->cy - data->oy;
5355 oldy = data->cy;
5358 if (grid_reader_cursor_jump(&gr, data->jumpchar)) {
5361 screen_size_y(back_s), data->oy, oldy, px, py, 0);
5368 struct window_copy_mode_data *data = wme->data;
5369 struct screen *back_s = data->backing;
5373 px = data->cx;
5375 py = hsize + data->cy - data->oy;
5376 oldy = data->cy;
5380 if (grid_reader_cursor_jump_back(&gr, data->jumpchar)) {
5382 window_copy_acquire_cursor_up(wme, hsize, data->oy, oldy, px,
5390 struct window_copy_mode_data *data = wme->data;
5391 struct screen *back_s = data->backing;
5395 px = data->cx + 2;
5397 py = hsize + data->cy - data->oy;
5398 oldy = data->cy;
5401 if (grid_reader_cursor_jump(&gr, data->jumpchar)) {
5405 screen_size_y(back_s), data->oy, oldy, px, py, 0);
5412 struct window_copy_mode_data *data = wme->data;
5413 struct screen *back_s = data->backing;
5417 px = data->cx;
5419 py = hsize + data->cy - data->oy;
5420 oldy = data->cy;
5425 if (grid_reader_cursor_jump_back(&gr, data->jumpchar)) {
5428 window_copy_acquire_cursor_up(wme, hsize, data->oy, oldy, px,
5437 struct window_copy_mode_data *data = wme->data;
5438 struct screen *back_s = data->backing;
5442 px = data->cx;
5444 py = hsize + data->cy - data->oy;
5445 oldy = data->cy;
5451 data->oy, oldy, px, py, 0);
5460 struct window_copy_mode_data *data = wme->data;
5462 struct screen *back_s = data->backing;
5466 px = data->cx;
5468 py = hsize + data->cy - data->oy;
5489 struct window_copy_mode_data *data = wme->data;
5491 struct screen *back_s = data->backing;
5495 px = data->cx;
5497 py = hsize + data->cy - data->oy;
5498 oldy = data->cy;
5510 data->oy, oldy, px, py, no_reset);
5518 struct window_copy_mode_data *data = wme->data;
5519 struct screen *back_s = data->backing;
5523 px = data->cx;
5525 py = hsize + data->cy - data->oy;
5539 struct window_copy_mode_data *data = wme->data;
5541 struct screen *back_s = data->backing;
5551 px = data->cx;
5553 py = hsize + data->cy - data->oy;
5554 oldy = data->cy;
5559 window_copy_acquire_cursor_up(wme, hsize, data->oy, oldy, px, py);
5566 struct window_copy_mode_data *data = wme->data;
5567 struct screen *s = data->backing;
5570 u_int line = gd->hsize - data->oy + data->cy;
5597 data->cx = 0;
5599 data->cy = line - gd->hsize;
5600 data->oy = 0;
5602 data->cy = 0;
5603 data->oy = gd->hsize - line;
5614 struct window_copy_mode_data *data = wme->data;
5615 struct screen *s = &data->screen;
5618 if (data->oy < ny)
5619 ny = data->oy;
5622 data->oy -= ny;
5624 if (data->searchmark != NULL && !data->timeout)
5625 window_copy_search_marks(wme, NULL, data->searchregex, 1);
5639 screen_write_cursormove(&ctx, data->cx, data->cy, 0);
5648 struct window_copy_mode_data *data = wme->data;
5649 struct screen *s = &data->screen;
5652 if (ny > screen_hsize(data->backing))
5655 if (data->oy > screen_hsize(data->backing) - ny)
5656 ny = screen_hsize(data->backing) - data->oy;
5659 data->oy += ny;
5661 if (data->searchmark != NULL && !data->timeout)
5662 window_copy_search_marks(wme, NULL, data->searchregex, 1);
5673 screen_write_cursormove(&ctx, data->cx, data->cy, 0);
5681 struct window_copy_mode_data *data = wme->data;
5684 data->rectflag = rectflag;
5686 py = screen_hsize(data->backing) + data->cy - data->oy;
5688 if (data->cx > px)
5689 window_copy_update_cursor(wme, px, data->cy);
5722 struct window_copy_mode_data *data;
5743 data = wme->data;
5744 yg = screen_hsize(data->backing) + y - data->oy;
5745 if (x < data->selrx || x > data->endselrx || yg != data->selry)
5746 data->selflag = SEL_CHAR;
5747 switch (data->selflag) {
5749 if (data->separators != NULL) {
5752 data->separators, &x, &y);
5753 y -= screen_hsize(data->backing) - data->oy;
5775 struct window_copy_mode_data *data;
5793 data = wme->data;
5794 evtimer_del(&data->dragtimer);
5798 old_cx = data->cx;
5799 old_cy = data->cy;
5804 if (old_cy != data->cy || old_cx == data->cx) {
5806 evtimer_add(&data->dragtimer, &tv);
5808 } else if (y == screen_size_y(&data->screen) - 1) {
5809 evtimer_add(&data->dragtimer, &tv);
5820 struct window_copy_mode_data *data;
5834 data = wme->data;
5835 evtimer_del(&data->dragtimer);
5841 struct window_copy_mode_data *data = wme->data;
5844 tmx = data->cx;
5845 tmy = screen_hsize(data->backing) + data->cy - data->oy;
5846 data->cx = data->mx;
5847 if (data->my < screen_hsize(data->backing)) {
5848 data->cy = 0;
5849 data->oy = screen_hsize(data->backing) - data->my;
5851 data->cy = data->my - screen_hsize(data->backing);
5852 data->oy = 0;
5854 data->mx = tmx;
5855 data->my = tmy;
5856 data->showmark = 1;