src/chat.cpp

   1 /*
   2 Minetest
   3 Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
   4
   5 This program is free software; you can redistribute it and/or modify
   6 it under the terms of the GNU Lesser General Public License as published by
   7 the Free Software Foundation; either version 2.1 of the License, or
   8 (at your option) any later version.
   9
  10 This program is distributed in the hope that it will be useful,
  11 but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 GNU Lesser General Public License for more details.
  14
  15 You should have received a copy of the GNU Lesser General Public License along
  16 with this program; if not, write to the Free Software Foundation, Inc.,
  17 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18 */
  19
  20 #include "chat.h"
  21 #include "debug.h"
  22 #include <cassert>
  23 #include <cctype>
  24 #include <sstream>
  25 #include "util/string.h"
  26 #include "util/numeric.h"
  27
  28 ChatBuffer::ChatBuffer(u32 scrollback):
  29         m_scrollback(scrollback),
  30         m_unformatted(),
  31         m_cols(0),
  32         m_rows(0),
  33         m_scroll(0),
  34         m_formatted(),
  35         m_empty_formatted_line()
  36 {
  37         if (m_scrollback == 0)
  38                 m_scrollback = 1;
  39         m_empty_formatted_line.first = true;
  40 }
  41
  42 ChatBuffer::~ChatBuffer()
  43 {
  44 }
  45
  46 void ChatBuffer::addLine(std::wstring name, std::wstring text)
  47 {
  48         ChatLine line(name, text);
  49         m_unformatted.push_back(line);
  50
  51         if (m_rows > 0)
  52         {
  53                 // m_formatted is valid and must be kept valid
  54                 bool scrolled_at_bottom = (m_scroll == getBottomScrollPos());
  55                 u32 num_added = formatChatLine(line, m_cols, m_formatted);
  56                 if (scrolled_at_bottom)
  57                         m_scroll += num_added;
  58         }
  59
  60         // Limit number of lines by m_scrollback
  61         if (m_unformatted.size() > m_scrollback)
  62         {
  63                 deleteOldest(m_unformatted.size() - m_scrollback);
  64         }
  65 }
  66
  67 void ChatBuffer::clear()
  68 {
  69         m_unformatted.clear();
  70         m_formatted.clear();
  71         m_scroll = 0;
  72 }
  73
  74 u32 ChatBuffer::getLineCount() const
  75 {
  76         return m_unformatted.size();
  77 }
  78
  79 u32 ChatBuffer::getScrollback() const
  80 {
  81         return m_scrollback;
  82 }
  83
  84 const ChatLine& ChatBuffer::getLine(u32 index) const
  85 {
  86         assert(index < getLineCount());
  87         return m_unformatted[index];
  88 }
  89
  90 void ChatBuffer::step(f32 dtime)
  91 {
  92         for (u32 i = 0; i < m_unformatted.size(); ++i)
  93         {
  94                 m_unformatted[i].age += dtime;
  95         }
  96 }
  97
  98 void ChatBuffer::deleteOldest(u32 count)
  99 {
 100         u32 del_unformatted = 0;
 101         u32 del_formatted = 0;
 102
 103         while (count > 0 && del_unformatted < m_unformatted.size())
 104         {
 105                 ++del_unformatted;
 106
 107                 // keep m_formatted in sync
 108                 if (del_formatted < m_formatted.size())
 109                 {
 110                         assert(m_formatted[del_formatted].first);
 111                         ++del_formatted;
 112                         while (del_formatted < m_formatted.size() &&
 113                                         !m_formatted[del_formatted].first)
 114                                 ++del_formatted;
 115                 }
 116
 117                 --count;
 118         }
 119
 120         m_unformatted.erase(m_unformatted.begin(), m_unformatted.begin() + del_unformatted);
 121         m_formatted.erase(m_formatted.begin(), m_formatted.begin() + del_formatted);
 122 }
 123
 124 void ChatBuffer::deleteByAge(f32 maxAge)
 125 {
 126         u32 count = 0;
 127         while (count < m_unformatted.size() && m_unformatted[count].age > maxAge)
 128                 ++count;
 129         deleteOldest(count);
 130 }
 131
 132 u32 ChatBuffer::getColumns() const
 133 {
 134         return m_cols;
 135 }
 136
 137 u32 ChatBuffer::getRows() const
 138 {
 139         return m_rows;
 140 }
 141
 142 void ChatBuffer::reformat(u32 cols, u32 rows)
 143 {
 144         if (cols == 0 || rows == 0)
 145         {
 146                 // Clear formatted buffer
 147                 m_cols = 0;
 148                 m_rows = 0;
 149                 m_scroll = 0;
 150                 m_formatted.clear();
 151         }
 152         else if (cols != m_cols || rows != m_rows)
 153         {
 154                 // TODO: Avoid reformatting ALL lines (even inivisble ones)
 155                 // each time the console size changes.
 156
 157                 // Find out the scroll position in *unformatted* lines
 158                 u32 restore_scroll_unformatted = 0;
 159                 u32 restore_scroll_formatted = 0;
 160                 bool at_bottom = (m_scroll == getBottomScrollPos());
 161                 if (!at_bottom)
 162                 {
 163                         for (s32 i = 0; i < m_scroll; ++i)
 164                         {
 165                                 if (m_formatted[i].first)
 166                                         ++restore_scroll_unformatted;
 167                         }
 168                 }
 169
 170                 // If number of columns change, reformat everything
 171                 if (cols != m_cols)
 172                 {
 173                         m_formatted.clear();
 174                         for (u32 i = 0; i < m_unformatted.size(); ++i)
 175                         {
 176                                 if (i == restore_scroll_unformatted)
 177                                         restore_scroll_formatted = m_formatted.size();
 178                                 formatChatLine(m_unformatted[i], cols, m_formatted);
 179                         }
 180                 }
 181
 182                 // Update the console size
 183                 m_cols = cols;
 184                 m_rows = rows;
 185
 186                 // Restore the scroll position
 187                 if (at_bottom)
 188                 {
 189                         scrollBottom();
 190                 }
 191                 else
 192                 {
 193                         scrollAbsolute(restore_scroll_formatted);
 194                 }
 195         }
 196 }
 197
 198 const ChatFormattedLine& ChatBuffer::getFormattedLine(u32 row) const
 199 {
 200         s32 index = m_scroll + (s32) row;
 201         if (index >= 0 && index < (s32) m_formatted.size())
 202                 return m_formatted[index];
 203         else
 204                 return m_empty_formatted_line;
 205 }
 206
 207 void ChatBuffer::scroll(s32 rows)
 208 {
 209         scrollAbsolute(m_scroll + rows);
 210 }
 211
 212 void ChatBuffer::scrollAbsolute(s32 scroll)
 213 {
 214         s32 top = getTopScrollPos();
 215         s32 bottom = getBottomScrollPos();
 216
 217         m_scroll = scroll;
 218         if (m_scroll < top)
 219                 m_scroll = top;
 220         if (m_scroll > bottom)
 221                 m_scroll = bottom;
 222 }
 223
 224 void ChatBuffer::scrollBottom()
 225 {
 226         m_scroll = getBottomScrollPos();
 227 }
 228
 229 void ChatBuffer::scrollTop()
 230 {
 231         m_scroll = getTopScrollPos();
 232 }
 233
 234 u32 ChatBuffer::formatChatLine(const ChatLine& line, u32 cols,
 235                 std::vector<ChatFormattedLine>& destination) const
 236 {
 237         u32 num_added = 0;
 238         std::vector<ChatFormattedFragment> next_frags;
 239         ChatFormattedLine next_line;
 240         ChatFormattedFragment temp_frag;
 241         u32 out_column = 0;
 242         u32 in_pos = 0;
 243         u32 hanging_indentation = 0;
 244
 245         // Format the sender name and produce fragments
 246         if (!line.name.empty())
 247         {
 248                 temp_frag.text = L"<";
 249                 temp_frag.column = 0;
 250                 //temp_frag.bold = 0;
 251                 next_frags.push_back(temp_frag);
 252                 temp_frag.text = line.name;
 253                 temp_frag.column = 0;
 254                 //temp_frag.bold = 1;
 255                 next_frags.push_back(temp_frag);
 256                 temp_frag.text = L"> ";
 257                 temp_frag.column = 0;
 258                 //temp_frag.bold = 0;
 259                 next_frags.push_back(temp_frag);
 260         }
 261
 262         // Choose an indentation level
 263         if (line.name.empty())
 264         {
 265                 // Server messages
 266                 hanging_indentation = 0;
 267         }
 268         else if (line.name.size() + 3 <= cols/2)
 269         {
 270                 // Names shorter than about half the console width
 271                 hanging_indentation = line.name.size() + 3;
 272         }
 273         else
 274         {
 275                 // Very long names
 276                 hanging_indentation = 2;
 277         }
 278
 279         next_line.first = true;
 280         bool text_processing = false;
 281
 282         // Produce fragments and layout them into lines
 283         while (!next_frags.empty() || in_pos < line.text.size())
 284         {
 285                 // Layout fragments into lines
 286                 while (!next_frags.empty())
 287                 {
 288                         ChatFormattedFragment& frag = next_frags[0];
 289                         if (frag.text.size() <= cols - out_column)
 290                         {
 291                                 // Fragment fits into current line
 292                                 frag.column = out_column;
 293                                 next_line.fragments.push_back(frag);
 294                                 out_column += frag.text.size();
 295                                 next_frags.erase(next_frags.begin());
 296                         }
 297                         else
 298                         {
 299                                 // Fragment does not fit into current line
 300                                 // So split it up
 301                                 temp_frag.text = frag.text.substr(0, cols - out_column);
 302                                 temp_frag.column = out_column;
 303                                 //temp_frag.bold = frag.bold;
 304                                 next_line.fragments.push_back(temp_frag);
 305                                 frag.text = frag.text.substr(cols - out_column);
 306                                 out_column = cols;
 307                         }
 308                         if (out_column == cols || text_processing)
 309                         {
 310                                 // End the current line
 311                                 destination.push_back(next_line);
 312                                 num_added++;
 313                                 next_line.fragments.clear();
 314                                 next_line.first = false;
 315
 316                                 out_column = text_processing ? hanging_indentation : 0;
 317                         }
 318                 }
 319
 320                 // Produce fragment
 321                 if (in_pos < line.text.size())
 322                 {
 323                         u32 remaining_in_input = line.text.size() - in_pos;
 324                         u32 remaining_in_output = cols - out_column;
 325
 326                         // Determine a fragment length <= the minimum of
 327                         // remaining_in_{in,out}put. Try to end the fragment
 328                         // on a word boundary.
 329                         u32 frag_length = 1, space_pos = 0;
 330                         while (frag_length < remaining_in_input &&
 331                                         frag_length < remaining_in_output)
 332                         {
 333                                 if (isspace(line.text[in_pos + frag_length]))
 334                                         space_pos = frag_length;
 335                                 ++frag_length;
 336                         }
 337                         if (space_pos != 0 && frag_length < remaining_in_input)
 338                                 frag_length = space_pos + 1;
 339
 340                         temp_frag.text = line.text.substr(in_pos, frag_length);
 341                         temp_frag.column = 0;
 342                         //temp_frag.bold = 0;
 343                         next_frags.push_back(temp_frag);
 344                         in_pos += frag_length;
 345                         text_processing = true;
 346                 }
 347         }
 348
 349         // End the last line
 350         if (num_added == 0 || !next_line.fragments.empty())
 351         {
 352                 destination.push_back(next_line);
 353                 num_added++;
 354         }
 355
 356         return num_added;
 357 }
 358
 359 s32 ChatBuffer::getTopScrollPos() const
 360 {
 361         s32 formatted_count = (s32) m_formatted.size();
 362         s32 rows = (s32) m_rows;
 363         if (rows == 0)
 364                 return 0;
 365         else if (formatted_count <= rows)
 366                 return formatted_count - rows;
 367         else
 368                 return 0;
 369 }
 370
 371 s32 ChatBuffer::getBottomScrollPos() const
 372 {
 373         s32 formatted_count = (s32) m_formatted.size();
 374         s32 rows = (s32) m_rows;
 375         if (rows == 0)
 376                 return 0;
 377         else
 378                 return formatted_count - rows;
 379 }
 380
 381
 382
 383 ChatPrompt::ChatPrompt(std::wstring prompt, u32 history_limit):
 384         m_prompt(prompt),
 385         m_line(L""),
 386         m_history(),
 387         m_history_index(0),
 388         m_history_limit(history_limit),
 389         m_cols(0),
 390         m_view(0),
 391         m_cursor(0),
 392         m_nick_completion_start(0),
 393         m_nick_completion_end(0)
 394 {
 395 }
 396
 397 ChatPrompt::~ChatPrompt()
 398 {
 399 }
 400
 401 void ChatPrompt::input(wchar_t ch)
 402 {
 403         m_line.insert(m_cursor, 1, ch);
 404         m_cursor++;
 405         clampView();
 406         m_nick_completion_start = 0;
 407         m_nick_completion_end = 0;
 408 }
 409
 410 std::wstring ChatPrompt::submit()
 411 {
 412         std::wstring line = m_line;
 413         m_line.clear();
 414         if (!line.empty())
 415                 m_history.push_back(line);
 416         if (m_history.size() > m_history_limit)
 417                 m_history.erase(m_history.begin());
 418         m_history_index = m_history.size();
 419         m_view = 0;
 420         m_cursor = 0;
 421         m_nick_completion_start = 0;
 422         m_nick_completion_end = 0;
 423         return line;
 424 }
 425
 426 void ChatPrompt::clear()
 427 {
 428         m_line.clear();
 429         m_view = 0;
 430         m_cursor = 0;
 431         m_nick_completion_start = 0;
 432         m_nick_completion_end = 0;
 433 }
 434
 435 void ChatPrompt::replace(std::wstring line)
 436 {
 437         m_line =  line;
 438         m_view = m_cursor = line.size();
 439         clampView();
 440         m_nick_completion_start = 0;
 441         m_nick_completion_end = 0;
 442 }
 443
 444 void ChatPrompt::historyPrev()
 445 {
 446         if (m_history_index != 0)
 447         {
 448                 --m_history_index;
 449                 replace(m_history[m_history_index]);
 450         }
 451 }
 452
 453 void ChatPrompt::historyNext()
 454 {
 455         if (m_history_index + 1 >= m_history.size())
 456         {
 457                 m_history_index = m_history.size();
 458                 replace(L"");
 459         }
 460         else
 461         {
 462                 ++m_history_index;
 463                 replace(m_history[m_history_index]);
 464         }
 465 }
 466
 467 void ChatPrompt::nickCompletion(const std::list<std::wstring>& names, bool backwards)
 468 {
 469         // Two cases:
 470         // (a) m_nick_completion_start == m_nick_completion_end == 0
 471         //     Then no previous nick completion is active.
 472         //     Get the word around the cursor and replace with any nick
 473         //     that has that word as a prefix.
 474         // (b) else, continue a previous nick completion.
 475         //     m_nick_completion_start..m_nick_completion_end are the
 476         //     interval where the originally used prefix was. Cycle
 477         //     through the list of completions of that prefix.
 478         u32 prefix_start = m_nick_completion_start;
 479         u32 prefix_end = m_nick_completion_end;
 480         bool initial = (prefix_end == 0);
 481         if (initial)
 482         {
 483                 // no previous nick completion is active
 484                 prefix_start = prefix_end = m_cursor;
 485                 while (prefix_start > 0 && !isspace(m_line[prefix_start-1]))
 486                         --prefix_start;
 487                 while (prefix_end < m_line.size() && !isspace(m_line[prefix_end]))
 488                         ++prefix_end;
 489                 if (prefix_start == prefix_end)
 490                         return;
 491         }
 492         std::wstring prefix = m_line.substr(prefix_start, prefix_end - prefix_start);
 493
 494         // find all names that start with the selected prefix
 495         std::vector<std::wstring> completions;
 496         for (std::list<std::wstring>::const_iterator
 497                         i = names.begin();
 498                         i != names.end(); ++i)
 499         {
 500                 if (str_starts_with(*i, prefix, true))
 501                 {
 502                         std::wstring completion = *i;
 503                         if (prefix_start == 0)
 504                                 completion += L":";
 505                         completions.push_back(completion);
 506                 }
 507         }
 508         if (completions.empty())
 509                 return;
 510
 511         // find a replacement string and the word that will be replaced
 512         u32 word_end = prefix_end;
 513         u32 replacement_index = 0;
 514         if (!initial)
 515         {
 516                 while (word_end < m_line.size() && !isspace(m_line[word_end]))
 517                         ++word_end;
 518                 std::wstring word = m_line.substr(prefix_start, word_end - prefix_start);
 519
 520                 // cycle through completions
 521                 for (u32 i = 0; i < completions.size(); ++i)
 522                 {
 523                         if (str_equal(word, completions[i], true))
 524                         {
 525                                 if (backwards)
 526                                         replacement_index = i + completions.size() - 1;
 527                                 else
 528                                         replacement_index = i + 1;
 529                                 replacement_index %= completions.size();
 530                                 break;
 531                         }
 532                 }
 533         }
 534         std::wstring replacement = completions[replacement_index] + L" ";
 535         if (word_end < m_line.size() && isspace(word_end))
 536                 ++word_end;
 537
 538         // replace existing word with replacement word,
 539         // place the cursor at the end and record the completion prefix
 540         m_line.replace(prefix_start, word_end - prefix_start, replacement);
 541         m_cursor = prefix_start + replacement.size();
 542         clampView();
 543         m_nick_completion_start = prefix_start;
 544         m_nick_completion_end = prefix_end;
 545 }
 546
 547 void ChatPrompt::reformat(u32 cols)
 548 {
 549         if (cols <= m_prompt.size())
 550         {
 551                 m_cols = 0;
 552                 m_view = m_cursor;
 553         }
 554         else
 555         {
 556                 s32 length = m_line.size();
 557                 bool was_at_end = (m_view + m_cols >= length + 1);
 558                 m_cols = cols - m_prompt.size();
 559                 if (was_at_end)
 560                         m_view = length;
 561                 clampView();
 562         }
 563 }
 564
 565 std::wstring ChatPrompt::getVisiblePortion() const
 566 {
 567         return m_prompt + m_line.substr(m_view, m_cols);
 568 }
 569
 570 s32 ChatPrompt::getVisibleCursorPosition() const
 571 {
 572         return m_cursor - m_view + m_prompt.size();
 573 }
 574
 575 void ChatPrompt::cursorOperation(CursorOp op, CursorOpDir dir, CursorOpScope scope)
 576 {
 577         s32 old_cursor = m_cursor;
 578         s32 new_cursor = m_cursor;
 579
 580         s32 length = m_line.size();
 581         s32 increment = (dir == CURSOROP_DIR_RIGHT) ? 1 : -1;
 582
 583         if (scope == CURSOROP_SCOPE_CHARACTER)
 584         {
 585                 new_cursor += increment;
 586         }
 587         else if (scope == CURSOROP_SCOPE_WORD)
 588         {
 589                 if (increment > 0)
 590                 {
 591                         // skip one word to the right
 592                         while (new_cursor < length && isspace(m_line[new_cursor]))
 593                                 new_cursor++;
 594                         while (new_cursor < length && !isspace(m_line[new_cursor]))
 595                                 new_cursor++;
 596                         while (new_cursor < length && isspace(m_line[new_cursor]))
 597                                 new_cursor++;
 598                 }
 599                 else
 600                 {
 601                         // skip one word to the left
 602                         while (new_cursor >= 1 && isspace(m_line[new_cursor - 1]))
 603                                 new_cursor--;
 604                         while (new_cursor >= 1 && !isspace(m_line[new_cursor - 1]))
 605                                 new_cursor--;
 606                 }
 607         }
 608         else if (scope == CURSOROP_SCOPE_LINE)
 609         {
 610                 new_cursor += increment * length;
 611         }
 612
 613         new_cursor = MYMAX(MYMIN(new_cursor, length), 0);
 614
 615         if (op == CURSOROP_MOVE)
 616         {
 617                 m_cursor = new_cursor;
 618         }
 619         else if (op == CURSOROP_DELETE)
 620         {
 621                 if (new_cursor < old_cursor)
 622                 {
 623                         m_line.erase(new_cursor, old_cursor - new_cursor);
 624                         m_cursor = new_cursor;
 625                 }
 626                 else if (new_cursor > old_cursor)
 627                 {
 628                         m_line.erase(old_cursor, new_cursor - old_cursor);
 629                         m_cursor = old_cursor;
 630                 }
 631         }
 632
 633         clampView();
 634
 635         m_nick_completion_start = 0;
 636         m_nick_completion_end = 0;
 637 }
 638
 639 void ChatPrompt::clampView()
 640 {
 641         s32 length = m_line.size();
 642         if (length + 1 <= m_cols)
 643         {
 644                 m_view = 0;
 645         }
 646         else
 647         {
 648                 m_view = MYMIN(m_view, length + 1 - m_cols);
 649                 m_view = MYMIN(m_view, m_cursor);
 650                 m_view = MYMAX(m_view, m_cursor - m_cols + 1);
 651                 m_view = MYMAX(m_view, 0);
 652         }
 653 }
 654
 655
 656
 657 ChatBackend::ChatBackend():
 658         m_console_buffer(500),
 659         m_recent_buffer(6),
 660         m_prompt(L"]", 500)
 661 {
 662 }
 663
 664 ChatBackend::~ChatBackend()
 665 {
 666 }
 667
 668 void ChatBackend::addMessage(std::wstring name, std::wstring text)
 669 {
 670         // Note: A message may consist of multiple lines, for example the MOTD.
 671         WStrfnd fnd(text);
 672         while (!fnd.atend())
 673         {
 674                 std::wstring line = fnd.next(L"\n");
 675                 m_console_buffer.addLine(name, line);
 676                 m_recent_buffer.addLine(name, line);
 677         }
 678 }
 679
 680 void ChatBackend::addUnparsedMessage(std::wstring message)
 681 {
 682         // TODO: Remove the need to parse chat messages client-side, by sending
 683         // separate name and text fields in TOCLIENT_CHAT_MESSAGE.
 684
 685         if (message.size() >= 2 && message[0] == L'<')
 686         {
 687                 std::size_t closing = message.find_first_of(L'>', 1);
 688                 if (closing != std::wstring::npos &&
 689                                 closing + 2 <= message.size() &&
 690                                 message[closing+1] == L' ')
 691                 {
 692                         std::wstring name = message.substr(1, closing - 1);
 693                         std::wstring text = message.substr(closing + 2);
 694                         addMessage(name, text);
 695                         return;
 696                 }
 697         }
 698
 699         // Unable to parse, probably a server message.
 700         addMessage(L"", message);
 701 }
 702
 703 ChatBuffer& ChatBackend::getConsoleBuffer()
 704 {
 705         return m_console_buffer;
 706 }
 707
 708 ChatBuffer& ChatBackend::getRecentBuffer()
 709 {
 710         return m_recent_buffer;
 711 }
 712
 713 std::wstring ChatBackend::getRecentChat()
 714 {
 715         std::wostringstream stream;
 716         for (u32 i = 0; i < m_recent_buffer.getLineCount(); ++i)
 717         {
 718                 const ChatLine& line = m_recent_buffer.getLine(i);
 719                 if (i != 0)
 720                         stream << L"\n";
 721                 if (!line.name.empty())
 722                         stream << L"<" << line.name << L"> ";
 723                 stream << line.text;
 724         }
 725         return stream.str();
 726 }
 727
 728 ChatPrompt& ChatBackend::getPrompt()
 729 {
 730         return m_prompt;
 731 }
 732
 733 void ChatBackend::reformat(u32 cols, u32 rows)
 734 {
 735         m_console_buffer.reformat(cols, rows);
 736
 737         // no need to reformat m_recent_buffer, its formatted lines
 738         // are not used
 739
 740         m_prompt.reformat(cols);
 741 }
 742
 743 void ChatBackend::clearRecentChat()
 744 {
 745         m_recent_buffer.clear();
 746 }
 747
 748 void ChatBackend::step(float dtime)
 749 {
 750         m_recent_buffer.step(dtime);
 751         m_recent_buffer.deleteByAge(60.0);
 752
 753         // no need to age messages in anything but m_recent_buffer
 754 }
 755
 756 void ChatBackend::scroll(s32 rows)
 757 {
 758         m_console_buffer.scroll(rows);
 759 }
 760
 761 void ChatBackend::scrollPageDown()
 762 {
 763         m_console_buffer.scroll(m_console_buffer.getRows());
 764 }
 765
 766 void ChatBackend::scrollPageUp()
 767 {
 768         m_console_buffer.scroll(-m_console_buffer.getRows());
 769 }