plomlompom.com Git - plomrogue/blob - src/windows.c

   1 /* windows.c */
   2
   3 #include "windows.h"
   4 #include <stdint.h>    /* for uint8_t, uint16_t, uint32_t */
   5 #include <ncurses.h>   /* for typedefs WINDOW, chtype, wresize(), getmaxx(), */
   6                        /* getmaxy(), supbad(), delwin(), mvwaddch(),         */
   7                        /* mvwaddstr(), newpad(), wnoutrefres(), erase(),     */
   8                        /* werase(), pnoutrefresh(), doupdate()               */
   9 #include <stdlib.h>    /* for malloc(), free() */
  10 #include <string.h>    /* for strlen(), strnlen(), memcpy() */
  11 #include "yx_uint16.h" /* for yx_uint16 coordinates */
  12
  13
  14
  15 /* Fit virtual screen's width to minimum width demanded by current windows'
  16  * geometries. Returns 0 on success, 1 on (pad memory allocation) error.
  17  */
  18 static uint8_t refit_pad(struct WinMeta * wmeta);
  19
  20
  21
  22 /* Update geometry (sizes, positions) of window "w" and its successors in the
  23  * window chain. For the positioning algorithm place_win() is used.
  24  *
  25  * update_wins() returns 0 on success, 1 on (pad/window memory alloc.) error.
  26  */
  27 static uint8_t update_wins(struct WinMeta * wmeta, struct Win * w);
  28 static void place_win(struct WinMeta * wmeta, struct Win * w);
  29
  30
  31
  32 /* Destroy window "w"'s ncurses window (and set w.Frame.curses_win to 0). */
  33 static void destroy_win(struct Win * w);
  34
  35
  36
  37 /* Draw contents of all windows in window chain from window "w" onwards. */
  38 static void draw_wins(struct Win * w);
  39
  40
  41
  42 /* draw_win_borderlines() draws the vertical and horizontal borders of window
  43  * "w" sans corners into the virtual screen "pad", and draws the top border
  44  * line as the windows' title bar (highlighted if the window is described
  45  * active by "active" being set). draw_wins_borderlines().
  46  *
  47  * draw_wins_borderlines() calls draw_win_borderlines() recursively on all
  48  * windows from "w" on. "w_active" is a pointer to the one window that
  49  * draw_win_borderlines() is supposed to handle as the active window.
  50  *
  51  * Finally, draw_wins_bordercorners draws into "pad" the borders of window "w"
  52  * and all its successors.
  53  */
  54 static void draw_win_borderlines(struct Win * w, char active, WINDOW * pad);
  55 static void draw_wins_borderlines(struct Win * w, struct Win * w_active,
  56                                   WINDOW * pad);
  57 static void draw_wins_bordercorners(struct Win * w, WINDOW * pad);
  58
  59
  60
  61 /* Shift active window forwards / backwards in window chain. */
  62 static void shift_win_forward(struct WinMeta * wmeta);
  63 static void shift_win_backward(struct WinMeta * wmeta);
  64
  65
  66
  67 static uint8_t refit_pad(struct WinMeta * wmeta)
  68 {
  69     /* Determine rightmost window column. */
  70     uint16_t lastwincol = 0;
  71     struct Win * w_p = wmeta->chain_start;
  72     while (w_p != 0)
  73     {
  74         if (w_p->start.x + w_p->frame.size.x > lastwincol + 1)
  75         {
  76             lastwincol = w_p->start.x + w_p->frame.size.x - 1;
  77         }
  78         w_p = w_p->next;
  79     }
  80
  81     /* Only resize the pad if the rightmost window column has changed. */
  82     if (getmaxx(wmeta->padframe.curses_win) != lastwincol)
  83     {
  84         return (ERR == wresize(wmeta->padframe.curses_win,
  85                                getmaxy(wmeta->padframe.curses_win),
  86                                lastwincol + 2));
  87     }
  88     return 0;
  89 }
  90
  91
  92
  93 static uint8_t update_wins(struct WinMeta * wmeta, struct Win * w)
  94 {
  95     if (0 != w->frame.curses_win)
  96     {
  97         destroy_win(w);
  98     }
  99     place_win(wmeta, w);
 100     if (0 != refit_pad(wmeta))
 101     {
 102         return 1;
 103     }
 104     WINDOW * test = subpad(wmeta->padframe.curses_win,
 105                            w->frame.size.y, w->frame.size.x,
 106                            w->start.y, w->start.x);
 107     if (NULL == test)
 108     {
 109         return 1;
 110     }
 111     w->frame.curses_win = test;
 112     if (0 != w->next)
 113     {
 114         return update_wins(wmeta, w->next);
 115     }
 116     return 0;
 117 }
 118
 119
 120
 121 static void place_win(struct WinMeta * wmeta, struct Win * w)
 122 {
 123     /* First window goes into the upper-left corner. */
 124     w->start.x = 0;
 125     w->start.y = 1;                             /* Leave space for title bar. */
 126     if (0 != w->prev)
 127     {
 128
 129         /* Non-first window fallbacks to: fit rightwards of rightmost border. */
 130         struct Win * w_top = w->prev;
 131         while (w_top->start.y != 1)
 132         {
 133             w_top = w_top->prev;
 134         }
 135         w->start.x = w_top->start.x + w_top->frame.size.x + 1;
 136
 137         /* Fit window below its predecessor if that one directly thrones over
 138          * empty space wide and high enough.
 139          */
 140         uint16_t w_prev_maxy = w->prev->start.y
 141                                + getmaxy(w->prev->frame.curses_win);
 142         if (   w->frame.size.x <= w->prev->frame.size.x
 143             && w->frame.size.y <  wmeta->padframe.size.y - w_prev_maxy)
 144         {
 145             w->start.x = w->prev->start.x;
 146             w->start.y = w_prev_maxy + 1;
 147         }
 148
 149         /* Failing that, try to open a new sub column below the nearest
 150          * predecessor window that thrones over enough empty space.
 151          */
 152         else
 153         {
 154             struct Win * w_up = w->prev;
 155             struct Win * w_upup = w_up;
 156             uint16_t widthdiff;
 157             while (w_up != w_top)
 158             {
 159                 w_upup = w_up->prev;
 160                 while (1)
 161                 {
 162                     if (w_up->start.y != w_upup->start.y)
 163                     {
 164                         break;
 165                     }
 166                     w_upup = w_upup->prev;
 167                 }
 168                 w_prev_maxy = w_upup->start.y
 169                               + getmaxy(w_upup->frame.curses_win);
 170                 widthdiff = (w_upup->start.x + w_upup->frame.size.x)
 171                             - (w_up->start.x + w_up->frame.size.x);
 172                 if (   w->frame.size.y < wmeta->padframe.size.y - w_prev_maxy
 173                     && w->frame.size.x < widthdiff)
 174                 {
 175                     w->start.x = w_up->start.x + w_up->frame.size.x + 1 ;
 176                     w->start.y = w_prev_maxy + 1;
 177                     break;
 178                 }
 179                 w_up = w_upup;
 180             }
 181         }
 182     }
 183 }
 184
 185
 186
 187 static void destroy_win(struct Win * w)
 188 {
 189     delwin(w->frame.curses_win);
 190     w->frame.curses_win = 0;
 191 }
 192
 193
 194
 195 static void draw_wins(struct Win * w)
 196 {
 197     w->draw(w);
 198     if (0 != w->next)
 199     {
 200         draw_wins(w->next);
 201     }
 202 }
 203
 204
 205
 206 static void draw_win_borderlines(struct Win * w, char active, WINDOW * pad)
 207 {
 208     /* Draw vertical and horizontal border lines. */
 209     uint16_t y, x;
 210     for (y = w->start.y; y <= w->start.y + w->frame.size.y; y++)
 211     {
 212         mvwaddch(pad, y, w->start.x - 1,               '|');
 213         mvwaddch(pad, y, w->start.x + w->frame.size.x, '|');
 214     }
 215     for (x = w->start.x; x <= w->start.x + w->frame.size.x; x++)
 216     {
 217         mvwaddch(pad, w->start.y - 1,               x, '-');
 218         mvwaddch(pad, w->start.y + w->frame.size.y, x, '-');
 219     }
 220
 221     /* Draw as much as possible of the title into center of top border line. */
 222     char min_title_length_visible = 3;  /* min. 1 char + 2 padding/decoration */
 223     if (w->frame.size.x >= min_title_length_visible)
 224     {
 225         uint16_t title_offset = 0;
 226         if (w->frame.size.x > strlen(w->title) + 2)
 227         {
 228             title_offset = (w->frame.size.x - (strlen(w->title) + 2)) / 2;
 229         }                                     /* +2 is for padding/decoration */
 230         uint16_t length_visible = strnlen(w->title, w->frame.size.x - 2);
 231         char title[length_visible + 3];
 232         char decoration = ' ';
 233         if (1 == active)
 234         {
 235             decoration = '$';
 236         }
 237         memcpy(title + 1, w->title, length_visible);
 238         title[0] = title[length_visible + 1] = decoration;
 239         title[length_visible + 2] = '\0';
 240         mvwaddstr(pad, w->start.y - 1, w->start.x + title_offset, title);
 241     }
 242 }
 243
 244
 245
 246 static void draw_wins_borderlines(struct Win * w, struct Win * w_active,
 247                                   WINDOW * pad)
 248 {
 249     char active = 0;
 250     if (w == w_active)
 251     {
 252         active = 1;
 253     }
 254     draw_win_borderlines(w, active, pad);
 255     if (0 != w->next)
 256     {
 257         draw_wins_borderlines(w->next, w_active, pad);
 258     }
 259 }
 260
 261
 262
 263 static void draw_wins_bordercorners(struct Win * w, WINDOW * pad)
 264 {
 265     mvwaddch(pad, w->start.y - 1, w->start.x - 1, '+');
 266     mvwaddch(pad, w->start.y - 1, w->start.x + w->frame.size.x, '+');
 267     mvwaddch(pad, w->start.y + w->frame.size.y, w->start.x - 1, '+');
 268     mvwaddch(pad,
 269              w->start.y + w->frame.size.y, w->start.x + w->frame.size.x, '+');
 270     if (0 != w->next)
 271     {
 272         draw_wins_bordercorners(w->next, pad);
 273     }
 274 }
 275
 276
 277
 278 static void shift_win_forward(struct WinMeta * wmeta)
 279 {
 280     if (wmeta->active == wmeta->chain_end)
 281     {
 282         wmeta->chain_end = wmeta->active->prev;
 283         wmeta->chain_end->next = 0;
 284         wmeta->active->next = wmeta->chain_start;
 285         wmeta->active->next->prev = wmeta->active;
 286         wmeta->chain_start = wmeta->active;
 287         wmeta->chain_start->prev = 0;
 288     }
 289     else
 290     {
 291         struct Win * old_prev = wmeta->active->prev;
 292         struct Win * old_next = wmeta->active->next;
 293         if (wmeta->chain_end == wmeta->active->next)
 294         {
 295             wmeta->chain_end = wmeta->active;
 296             wmeta->active->next = 0;
 297         }
 298         else
 299         {
 300             wmeta->active->next = old_next->next;
 301             wmeta->active->next->prev = wmeta->active;
 302         }
 303         if (wmeta->chain_start == wmeta->active)
 304         {
 305             wmeta->chain_start = old_next;
 306         }
 307         else
 308         {
 309             old_prev->next = old_next;
 310         }
 311         old_next->prev = old_prev;
 312         old_next->next = wmeta->active;
 313         wmeta->active->prev = old_next;
 314     }
 315 }
 316
 317
 318
 319 static void shift_win_backward(struct WinMeta * wmeta)
 320 {
 321     if (wmeta->active == wmeta->chain_start)
 322     {
 323         wmeta->chain_start = wmeta->active->next;
 324         wmeta->chain_start->prev = 0;
 325         wmeta->active->prev = wmeta->chain_end;
 326         wmeta->active->prev->next = wmeta->active;
 327         wmeta->chain_end = wmeta->active;
 328         wmeta->chain_end->next = 0;
 329     }
 330     else
 331     {
 332         struct Win * old_prev = wmeta->active->prev;
 333         struct Win * old_next = wmeta->active->next;
 334         if (wmeta->chain_start == wmeta->active->prev)
 335         {
 336             wmeta->chain_start = wmeta->active;
 337             wmeta->active->prev = 0;
 338         }
 339         else
 340         {
 341             wmeta->active->prev = old_prev->prev;
 342             wmeta->active->prev->next = wmeta->active;
 343         }
 344         if (wmeta->chain_end == wmeta->active)
 345         {
 346             wmeta->chain_end = old_prev;
 347         }
 348         else
 349         {
 350             old_next->prev = old_prev;
 351         }
 352         old_prev->next = old_next;
 353         old_prev->prev = wmeta->active;
 354         wmeta->active->next = old_prev;
 355     }
 356 }
 357
 358
 359
 360 extern uint8_t init_win_meta(WINDOW * screen, struct WinMeta * wmeta)
 361 {
 362     wmeta->screen              = screen;
 363     wmeta->padframe.size.y     = getmaxy(screen);
 364     wmeta->padframe.size.x     = getmaxx(screen);
 365     wmeta->chain_start         = 0;
 366     wmeta->chain_end           = 0;
 367     wmeta->pad_offset          = 0;
 368     WINDOW * test;
 369     test = newpad(wmeta->padframe.size.y, 1);
 370     if (NULL == test)
 371     {
 372         return 1;
 373     }
 374     wmeta->padframe.curses_win = test;
 375     wmeta->active              = 0;
 376     return 0;
 377 }
 378
 379
 380
 381 extern struct Win init_win(struct WinMeta * wmeta, char * title,
 382                            uint16_t height, uint16_t width,
 383                            void * data, void * func)
 384 {
 385     struct Win w;
 386     w.prev             = 0;
 387     w.next             = 0;
 388     w.frame.curses_win = 0;
 389     w.title            = title;
 390     w.data             = data;
 391     w.draw             = func;
 392     if (width > 0)
 393     {
 394         w.frame.size.x = width;
 395     }
 396     else
 397     {
 398         w.frame.size.x = 1;
 399     }
 400     if (height > 0 && height <= wmeta->padframe.size.y - 1)
 401     {
 402         w.frame.size.y = height;
 403     }
 404     else
 405     {
 406         w.frame.size.y = wmeta->padframe.size.y - 1;
 407     }
 408     return w;
 409 }
 410
 411
 412
 413 extern uint8_t append_win(struct WinMeta * wmeta, struct Win * w)
 414 {
 415     if (0 != wmeta->chain_start)
 416     {
 417         w->prev = wmeta->chain_end;
 418         wmeta->chain_end->next = w;
 419     }
 420     else
 421     {
 422         wmeta->active = w;
 423         wmeta->chain_start = w;
 424     }
 425     wmeta->chain_end = w;
 426     return update_wins(wmeta, w);
 427 }
 428
 429
 430
 431 extern uint8_t suspend_win(struct WinMeta * wmeta, struct Win * w)
 432 {
 433     destroy_win(w);
 434
 435     if (wmeta->chain_start != w)
 436     {
 437         w->prev->next = w->next;
 438     }
 439     else
 440     {
 441         wmeta->chain_start = w->next;
 442     }
 443     char pad_refitted = 0;
 444     if (wmeta->chain_end != w)
 445     {
 446         w->next->prev = w->prev;
 447         if (wmeta->active == w)
 448         {
 449             wmeta->active = w->next;
 450         }
 451         if (0 != update_wins(wmeta, w->next)) /* Positioning of successor    */
 452         {                                     /* windows may be affected /    */
 453             return 1;                         /* need correction.             */
 454         }                                     /* Note that update_wins()      */
 455         pad_refitted = 1;                     /* already refits the  pad,     */
 456     }                                         /* voiding later need for that. */
 457     else
 458     {
 459         wmeta->chain_end = w->prev;
 460         if (wmeta->active == w)
 461         {
 462             wmeta->active = w->prev;
 463         }
 464     }
 465
 466     w->prev = 0;
 467     w->next = 0;
 468
 469     if (0 == pad_refitted)
 470     {
 471         return refit_pad(wmeta);
 472     }
 473     return 0;
 474 }
 475
 476
 477
 478 extern void reset_pad_offset(struct WinMeta * wmeta, uint16_t new_offset)
 479 {
 480     if (new_offset >= 0
 481         && (new_offset < wmeta->pad_offset
 482             || new_offset + wmeta->padframe.size.x
 483                < getmaxx(wmeta->padframe.curses_win)))
 484     {
 485         wmeta->pad_offset = new_offset;
 486     }
 487 }
 488
 489
 490
 491 extern uint8_t resize_active_win(struct WinMeta * wmeta, struct yx_uint16 size)
 492 {
 493     if (0 != wmeta->active
 494         && size.x > 0 && size.y > 0
 495         && size.y < wmeta->padframe.size.y)
 496     {
 497         wmeta->active->frame.size = size;
 498         return update_wins(wmeta, wmeta->chain_start); /* Succeeding windows' */
 499     }                                                  /* positioning may be  */
 500     return 0;                                          /* affected.           */
 501 }                                                      /* TODO: Why start at  */
 502                                                        /* chain_start then?   */
 503
 504
 505 extern void cycle_active_win(struct WinMeta * wmeta, char dir)
 506 {
 507     if (0 != wmeta->active)
 508     {
 509         if ('n' == dir)
 510         {
 511             if (wmeta->active->next != 0)
 512             {
 513                 wmeta->active = wmeta->active->next;
 514             }
 515             else
 516             {
 517                 wmeta->active = wmeta->chain_start;
 518             }
 519         }
 520         else
 521         {
 522             if (wmeta->active->prev != 0)
 523             {
 524                 wmeta->active = wmeta->active->prev;
 525             }
 526             else
 527             {
 528                 wmeta->active = wmeta->chain_end;
 529             }
 530         }
 531     }
 532 }
 533
 534
 535
 536 extern uint8_t shift_active_win_old(struct WinMeta * wmeta, char dir)
 537 {
 538     if (0 != wmeta->active                         /* No shifting with less   */
 539         && wmeta->chain_start != wmeta->chain_end  /* than 2 windows visible. */
 540         && (dir == 'f' || dir == 'b'))             /* and wrong dir char.     */
 541     {
 542         struct Win * w_shift = wmeta->active, * w_p, * w_p_next;
 543
 544         /* Check if shifting will lead to wrapping. */
 545         char wrap = 0;
 546         if (   (dir == 'f' && w_shift == wmeta->chain_end)
 547             || (dir == 'b' && w_shift == wmeta->chain_start))
 548         {
 549             wrap = 1;
 550         }
 551
 552         /* Suspend all visible windows, remember their order in wins[]. */
 553         uint16_t i, i_max;
 554         for (w_p  = wmeta->chain_start, i_max = 1;
 555              w_p != wmeta->chain_end;
 556              w_p  = w_p->next)
 557         {
 558             i_max++;
 559         }
 560         struct Win ** wins = malloc(i_max * sizeof(struct Win *));
 561         if (NULL == wins)
 562         {
 563             return 1;
 564         }
 565         for (i = 0, w_p = wmeta->chain_start;
 566              i < i_max;
 567              i++)
 568         {
 569             w_p_next = w_p->next;
 570             suspend_win(wmeta, w_p);
 571             wins[i] = w_p;
 572             w_p = w_p_next;
 573         }
 574
 575         /* Re-append all previously visible windows in the new order. */
 576         if (wrap)
 577         {
 578             if (dir == 'f')
 579             {
 580                 if (0 != append_win(wmeta, w_shift))
 581                 {
 582                     return 1;
 583                 }
 584                 for (i = 0; i < i_max - 1; i++)
 585                 {
 586                     if (0 != append_win(wmeta, wins[i]))
 587                     {
 588                         return 1;
 589                     }
 590                 }
 591             }
 592             else
 593             {
 594                 for (i = 1; i < i_max; i++)
 595                 {
 596                     if (0 != append_win(wmeta, wins[i]))
 597                     {
 598                         return 1;
 599                     }
 600                 }
 601                 if (0 != append_win(wmeta, w_shift))
 602                 {
 603                     return 1;
 604                 }
 605             }
 606         }
 607         else
 608         {
 609             for (i = 0; i < i_max; i++)
 610             {
 611                 if (   (dir == 'f' && w_shift == wins[i])
 612                     || (dir == 'b' && w_shift == wins[i+1]))
 613                 {
 614                     if (   0 != append_win(wmeta, wins[i+1])
 615                         || 0 != append_win(wmeta, wins[i]))
 616                     {
 617                         return 1;
 618                     }
 619                     i++;
 620                 }
 621                 else
 622                 {
 623                     if (0 != append_win(wmeta, wins[i]))
 624                     {
 625                         return 1;
 626                     }
 627                 }
 628             }
 629         }
 630         free(wins);
 631
 632         wmeta->active = w_shift;  /* Otherwise lastly appended win is active. */
 633     }
 634     return 0;
 635 }
 636
 637
 638
 639 extern void shift_active_win(struct WinMeta * wmeta, char dir)
 640 {
 641     if (   0 == wmeta->active
 642         || wmeta->chain_start == wmeta->chain_end
 643         || (dir != 'f' && dir != 'b'))
 644     {
 645         return;
 646     }
 647     if ('f' == dir)
 648     {
 649         shift_win_forward(wmeta);
 650     }
 651     else
 652     {
 653         shift_win_backward(wmeta);
 654     }
 655     update_wins(wmeta, wmeta->chain_start);
 656 }
 657
 658
 659
 660 extern void draw_all_wins(struct WinMeta * wmeta)
 661 {
 662     /* Empty everything before filling it a-new. */
 663     erase();
 664     wnoutrefresh(wmeta->screen);
 665     werase(wmeta->padframe.curses_win);
 666     if (wmeta->chain_start)
 667     {
 668
 669         /* Draw windows' contents first, then their borders. */
 670         draw_wins(wmeta->chain_start);
 671         draw_wins_borderlines(wmeta->chain_start, wmeta->active,
 672                               wmeta->padframe.curses_win);
 673         draw_wins_bordercorners(wmeta->chain_start, wmeta->padframe.curses_win);
 674
 675         /* Draw virtual screen scroll hints. */
 676         if (wmeta->pad_offset > 0)
 677         {
 678             draw_scroll_hint(&wmeta->padframe,
 679                              wmeta->pad_offset, wmeta->pad_offset + 1, '<');
 680         }
 681         if (wmeta->pad_offset + wmeta->padframe.size.x
 682             < getmaxx(wmeta->padframe.curses_win) - 1)
 683         {
 684             draw_scroll_hint(&wmeta->padframe,
 685                              wmeta->pad_offset + wmeta->padframe.size.x - 1,
 686                              getmaxx(wmeta->padframe.curses_win)
 687                              - (wmeta->pad_offset + wmeta->padframe.size.x),
 688                              '>');
 689         }
 690
 691         /* Write virtual screen segment to be shown on physical screen into */
 692         /* ncurses screen buffer. */
 693         pnoutrefresh(wmeta->padframe.curses_win, 0, wmeta->pad_offset, 0, 0,
 694                      wmeta->padframe.size.y, wmeta->padframe.size.x-1);
 695     }
 696
 697     /* Only at the end write accumulated changes to the physical screen. */
 698     doupdate();
 699 }
 700
 701
 702
 703 extern uint8_t draw_scroll_hint(struct Frame * frame, uint16_t pos,
 704                                 uint32_t dist, char dir)
 705 {
 706     /* Decide on alignment (vertical/horizontal?), thereby scroll hint text. */
 707     char * more = "more";
 708     char * unit_cols = "columns";
 709     char * unit_rows = "lines";
 710     uint16_t dsc_space = frame->size.x;
 711     char * unit = unit_rows;
 712     if ('<' == dir || '>' == dir)
 713     {
 714         dsc_space = frame->size.y;
 715         unit = unit_cols;
 716     }
 717     char * scrolldsc = malloc((4 * sizeof(char)) + strlen(more) + strlen(unit)
 718                               + 10);                /* 10 = uint32 max strlen */
 719     if (NULL == scrolldsc)
 720     {
 721         return 1;
 722     }
 723     sprintf(scrolldsc, " %d %s %s ", dist, more, unit);
 724
 725     /* Decide on offset of the description text inside the scroll hint line. */
 726     char offset = 1, q;
 727     if (dsc_space > strlen(scrolldsc) + 1)
 728     {
 729         offset = (dsc_space - strlen(scrolldsc)) / 2;
 730     }
 731
 732     /* Draw scroll hint line as dir symbols bracketing description text. */
 733     chtype symbol;
 734     for (q = 0; q < dsc_space; q++)
 735     {
 736         if (q >= offset && q < strlen(scrolldsc) + offset)
 737         {
 738             symbol = scrolldsc[q - offset] | A_REVERSE;
 739         }
 740         else
 741         {
 742             symbol = dir | A_REVERSE;
 743         }
 744         if ('<' == dir || '>' == dir)
 745         {
 746             mvwaddch(frame->curses_win, q, pos, symbol);
 747         }
 748         else
 749         {
 750             mvwaddch(frame->curses_win, pos, q, symbol);
 751         }
 752     }
 753
 754     free(scrolldsc);
 755     return 0;
 756 }