ryzom/client/src/interface_v3/action_handler_edit.cpp

   1 // Ryzom - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
   2 // Copyright (C) 2010-2018  Winch Gate Property Limited
   3 //
   4 // This source file has been modified by the following contributors:
   5 // Copyright (C) 2013  Laszlo KIS-ADAM (dfighter) <dfighter1985@gmail.com>
   6 // Copyright (C) 2020  Jan BOON (Kaetemi) <jan.boon@kaetemi.be>
   7 //
   8 // This program is free software: you can redistribute it and/or modify
   9 // it under the terms of the GNU Affero General Public License as
  10 // published by the Free Software Foundation, either version 3 of the
  11 // License, or (at your option) any later version.
  12 //
  13 // This program is distributed in the hope that it will be useful,
  14 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 // GNU Affero General Public License for more details.
  17 //
  18 // You should have received a copy of the GNU Affero General Public License
  19 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
  20
  21
  22
  23
  24 #include "stdpch.h"
  25
  26 using namespace std;
  27 using namespace NLMISC;
  28
  29 #include "nel/gui/action_handler.h"
  30 #include "nel/gui/group_editbox.h"
  31 #include "nel/misc/utf_string_view.h"
  32 #include "interface_manager.h"
  33 #include "../client_chat_manager.h"
  34 #include "people_interraction.h"
  35 #include "../r2/editor.h"
  36 /*#include "user_controls.h"
  37 #include "view.h"
  38 #include "misc.h"
  39 #include "input.h"*/
  40
  41 ////////////
  42 // EXTERN //
  43 ////////////
  44
  45 extern CClientChatManager               ChatMngr;
  46
  47
  48 ////////////
  49 // GLOBAL //
  50 ////////////
  51
  52 /**********************************************************************************************************
  53 *                                                                                                                                                                                                                 *
  54 *                                                                               edit            handlers  actions                                                                         *
  55 *                                                                                                                                                                                                                 *
  56 ***********************************************************************************************************/
  57
  58 // ***************************************************************************
  59
  60 // used for character classifiction (when the user press Ctrl-arrow)
  61 static inline uint getCharacterCategory(u32char c)
  62 {
  63         if (c == ' ') return 0;
  64         if (c > 127 || isalpha((char) c)) return 1; // alpha & other characters
  65         if (isdigit((char) c)) return 2;
  66         return 3; // other cases, including punctuation
  67 }
  68
  69 // ***************************************************************************
  70
  71 /** skip a block of character in a string, (same behaviour than when Ctrl-arrow is pressed)
  72   * It returns the new index
  73   */
  74 static uint skipUCCharsRight(uint startPos, const ::u32string &str)
  75 {
  76         uint pos = startPos;
  77         uint endIndex = (uint)str.length();
  78         uint ccat = getCharacterCategory(str[pos]);
  79         // skip characters of the same category
  80         while (pos != endIndex && getCharacterCategory(str[pos]) == ccat) ++pos;
  81         // skip spaces
  82         while (pos != endIndex && str[pos] == ' ') ++pos;
  83         return pos;
  84 }
  85
  86 // ***************************************************************************
  87
  88 /** skip a block of character in a string, (same behaviour than when Ctrl-arrow is pressed)
  89   * It returns the new index
  90   */
  91 static uint skipUCCharsLeft(uint startPos, const ::u32string &str)
  92 {
  93         uint pos = startPos;
  94         -- pos;
  95         while (pos != 0 && str[pos] == ' ') --pos;
  96         if (pos == 0) return pos;
  97         uint ccat = getCharacterCategory(str[pos]);
  98         // skip characters of the same category
  99         while (pos != 0 && getCharacterCategory(str[pos - 1]) == ccat) --pos;
 100         return pos;
 101 }
 102
 103 // ***************************************************************************
 104
 105 class CAHEdit : public IActionHandler
 106 {
 107 protected:
 108         // Current edit box. Filled by init.
 109         CGroupEditBox           *_GroupEdit;
 110         bool                            _LooseSelection;
 111
 112         // Init the action manager
 113         void init ()
 114         {
 115                 // Get the current edit box
 116                 _GroupEdit = NULL;
 117                 _LooseSelection = false;
 118
 119                 // Get the interface manager
 120                 CInterfaceManager *pIM = CInterfaceManager::getInstance();
 121                 if (pIM)
 122                 {
 123                         CCtrlBase *basectrl = CWidgetManager::getInstance()->getCaptureKeyboard();
 124                         if (basectrl)
 125                                 _GroupEdit = dynamic_cast<CGroupEditBox*>(basectrl);
 126                 }
 127
 128                 if (_GroupEdit)
 129                         _GroupEdit->stopParentBlink();
 130         }
 131
 132         // For action handler that modify selection
 133         void handleSelection ()
 134         {
 135                 if (_GroupEdit)
 136                 {
 137                         // If selection not active
 138                         if (CGroupEditBox::getCurrSelection() == NULL)
 139                         {
 140                                 // then start selection at curPos
 141                                 CGroupEditBox::setSelectCursorPos(_GroupEdit->getCursorPos());
 142                                 CGroupEditBox::setCurrSelection (_GroupEdit);
 143                         }
 144                 }
 145         }
 146
 147         // For action handler that unselect
 148         void handleUnselection()
 149         {
 150                 if (_GroupEdit)
 151                 {
 152                         // If selection active
 153                         CGroupEditBox *currSelection = dynamic_cast< CGroupEditBox* >( CGroupEditBox::getCurrSelection() );
 154                         if (currSelection != NULL)
 155                         {
 156                                 if (currSelection != _GroupEdit)
 157                                 {
 158                                         nlwarning("Selection can only be on focus");
 159                                 }
 160
 161                                 // disable selection
 162                                 CGroupEditBox::setCurrSelection(NULL);
 163                                 _LooseSelection = true;
 164                         }
 165                 }
 166         }
 167
 168         // Init part
 169         virtual void initPart ()
 170         {
 171                 init();
 172                 handleUnselection();
 173         }
 174
 175         // Action part
 176         virtual void actionPart () = 0;
 177
 178         // R2 editor part (no op by default)
 179         virtual void forwardToEditor() {}
 180
 181         // Tha action handler
 182         virtual void execute (CCtrlBase * /* pCaller */, const string &/* Params */)
 183         {
 184                 initPart ();
 185                 if (_GroupEdit)
 186                 {
 187                         actionPart ();
 188                 }
 189                 else
 190                 {
 191                         forwardToEditor();
 192                 }
 193         }
 194 };
 195
 196 // ***************************************************************************
 197
 198 class CAHEditPreviousChar : public CAHEdit
 199 {
 200         void actionPart ()
 201         {
 202                 if (_LooseSelection)
 203                 {
 204                         sint32  minPos= min(_GroupEdit->getCursorPos(), _GroupEdit->getSelectCursorPos());
 205                         sint32  maxPos= max(_GroupEdit->getCursorPos(), _GroupEdit->getSelectCursorPos());
 206
 207                         // Special Code if left or right: Set the cursor pos to bounds of selection.
 208                         if(minPos!=maxPos)
 209                         {
 210                                 _GroupEdit->setCursorPos(minPos);
 211                                 // don't call std Left
 212                                 return;
 213                         }
 214                 }
 215
 216                 if (_GroupEdit->getCursorPos() > 0)
 217                 {
 218                         _GroupEdit->setCursorPos(_GroupEdit->getCursorPos()-1);
 219                         _GroupEdit->setCursorAtPreviousLineEnd(false);
 220                 }
 221         }
 222 };
 223 REGISTER_ACTION_HANDLER (CAHEditPreviousChar, "edit_previous_char");
 224
 225 // ***************************************************************************
 226
 227 class CAHEditNextChar : public CAHEdit
 228 {
 229         void actionPart ()
 230         {
 231                 if (_LooseSelection)
 232                 {
 233                         sint32  minPos = min(_GroupEdit->getCursorPos(), _GroupEdit->getSelectCursorPos());
 234                         sint32  maxPos = max(_GroupEdit->getCursorPos(), _GroupEdit->getSelectCursorPos());
 235
 236                         if(minPos!=maxPos)
 237                         {
 238                                 _GroupEdit->setCursorPos(maxPos);
 239                                 // don't call std Right
 240                                 return;
 241                         }
 242                 }
 243
 244                 if (_GroupEdit->getCursorPos() < (sint32) _GroupEdit->getInputStringRef().length())
 245                 {
 246                         _GroupEdit->setCursorPos(_GroupEdit->getCursorPos()+1);
 247                         _GroupEdit->setCursorAtPreviousLineEnd(false);
 248                 }
 249         }
 250 };
 251 REGISTER_ACTION_HANDLER (CAHEditNextChar, "edit_next_char");
 252
 253 // ***************************************************************************
 254
 255 class CAHEditPreviousWord : public CAHEdit
 256 {
 257         void actionPart ()
 258         {
 259                 if (_GroupEdit->getCursorPos() > 0)
 260                 {
 261                         _GroupEdit->setCursorPos(skipUCCharsLeft(_GroupEdit->getCursorPos(), _GroupEdit->getInputStringRef()));
 262                         _GroupEdit->setCursorAtPreviousLineEnd(false);
 263                 }
 264         }
 265 };
 266 REGISTER_ACTION_HANDLER (CAHEditPreviousWord, "edit_previous_word");
 267
 268 // ***************************************************************************
 269
 270 class CAHEditNextWord : public CAHEdit
 271 {
 272         void actionPart ()
 273         {
 274                 if (_GroupEdit->getCursorPos() < (sint32) _GroupEdit->getInputStringRef().length())
 275                 {
 276                         _GroupEdit->setCursorPos(skipUCCharsRight(_GroupEdit->getCursorPos(), _GroupEdit->getInputStringRef()));
 277                         _GroupEdit->setCursorAtPreviousLineEnd(false);
 278                 }
 279         }
 280 };
 281 REGISTER_ACTION_HANDLER (CAHEditNextWord, "edit_next_word");
 282
 283 // ***************************************************************************
 284
 285 class CAHEditGotoLineBegin : public CAHEdit
 286 {
 287         void actionPart ()
 288         {
 289                 // go to the start of line
 290                 if (_GroupEdit->getViewText())
 291                 {
 292                         sint line = _GroupEdit->getViewText()->getLineFromIndex(_GroupEdit->getCursorPos() + (uint)_GroupEdit->getPromptRef().length());
 293                         if (line == -1) return;
 294                         sint newPos = std::max(_GroupEdit->getViewText()->getLineStartIndex(line), (sint) _GroupEdit->getPromptRef().length());
 295                         if (newPos == -1) return;
 296                         _GroupEdit->setCursorPos(newPos - (sint32)_GroupEdit->getPromptRef().length());
 297                         _GroupEdit->setCursorAtPreviousLineEnd(false);
 298                 }
 299         }
 300 };
 301 REGISTER_ACTION_HANDLER (CAHEditGotoLineBegin, "edit_goto_line_begin");
 302
 303 // ***************************************************************************
 304
 305 class CAHEditGotoLineEnd : public CAHEdit
 306 {
 307         void actionPart ()
 308         {
 309                 // go to the end of line
 310                 if (_GroupEdit->getViewText())
 311                 {
 312                         if (_GroupEdit->getViewText()->getMultiLine())
 313                         {
 314                                 sint line = _GroupEdit->getViewText()->getLineFromIndex(_GroupEdit->getCursorPos() + (uint)_GroupEdit->getPromptRef().length(), _GroupEdit->isCursorAtPreviousLineEnd());
 315                                 if (line == -1) return;
 316                                 sint newPos;
 317                                 bool endOfPreviousLine;
 318                                 _GroupEdit->getViewText()->getLineEndIndex(line, newPos, endOfPreviousLine);
 319                                 if (newPos != -1)
 320                                 {
 321                                         _GroupEdit->setCursorPos(newPos - (sint32)_GroupEdit->getPromptRef().length());
 322                                         _GroupEdit->setCursorAtPreviousLineEnd(endOfPreviousLine);
 323                                 }
 324                         }
 325                         else
 326                         {
 327                                 _GroupEdit->setCursorPos((sint32)_GroupEdit->getPromptRef().length() + (sint32)_GroupEdit->getInputString().length());
 328                         }
 329                 }
 330         }
 331 };
 332 REGISTER_ACTION_HANDLER (CAHEditGotoLineEnd, "edit_goto_line_end");
 333
 334 // ***************************************************************************
 335
 336 class CAHEditGotoBlockBegin : public CAHEdit
 337 {
 338         void actionPart ()
 339         {
 340                 _GroupEdit->setCursorPos(0);
 341                 _GroupEdit->setCursorAtPreviousLineEnd(false);
 342         }
 343 };
 344 REGISTER_ACTION_HANDLER (CAHEditGotoBlockBegin, "edit_goto_block_begin");
 345
 346 // ***************************************************************************
 347
 348 class CAHEditGotoBlockEnd : public CAHEdit
 349 {
 350         void actionPart ()
 351         {
 352                 _GroupEdit->setCursorPos((sint32)_GroupEdit->getInputStringRef().length());
 353                 _GroupEdit->setCursorAtPreviousLineEnd(false);
 354         }
 355 };
 356 REGISTER_ACTION_HANDLER (CAHEditGotoBlockEnd, "edit_goto_block_end");
 357
 358 // ***************************************************************************
 359
 360 class CAHEditPreviousLine : public CAHEdit
 361 {
 362         void actionPart ()
 363         {
 364                 if (_GroupEdit->getMaxHistoric() && (! _GroupEdit->getViewText()->getMultiLine()))
 365                 {
 366                         // Get the start of the string.
 367                         ::u32string     startStr= _GroupEdit->getInputStringRef().substr(0, _GroupEdit->getCursorPos());
 368
 369                         // Search all historic string that match startStr.
 370                         for(sint i=_GroupEdit->getCurrentHistoricIndex()+1;i<(sint)_GroupEdit->getNumHistoric();i++)
 371                         {
 372                                 if( _GroupEdit->getHistoric(i).compare(0, _GroupEdit->getCursorPos(), startStr)==0 )
 373                                 {
 374                                         _GroupEdit->setInputStringRef (_GroupEdit->getHistoric(i));
 375                                         _GroupEdit->setCurrentHistoricIndex(i);
 376                                         break;
 377                                 }
 378                         }
 379                 }
 380                 else if (_GroupEdit->getViewText()->getMultiLine())
 381                 {
 382                         uint cursorPosInText = _GroupEdit->getCursorPos() + (uint)_GroupEdit->getPromptRef().length();
 383                         if (
 384                                 (_GroupEdit->getCursorPos() == (sint32) _GroupEdit->getInputStringRef().length() && _GroupEdit->getViewText()->getNumLine() == 1) ||
 385                                 _GroupEdit->getViewText()->getLineFromIndex(cursorPosInText, _GroupEdit->isCursorAtPreviousLineEnd()) == 0
 386                                 ) // in the first line .. ?
 387                         {
 388                                 // .. so do nothing
 389                                 return;
 390                         }
 391                         float cx, cy;
 392                         float height;
 393                         _GroupEdit->getViewText()->getCharacterPositionFromIndex(cursorPosInText, _GroupEdit->isCursorAtPreviousLineEnd(), cx, cy, height);
 394                         cy += _GroupEdit->getViewText()->getLineHeight();
 395                         uint newCharIndex;
 396                         bool newLineEnd;
 397                         _GroupEdit->getViewText()->getCharacterIndexFromPosition(cx, cy, newCharIndex, newLineEnd);
 398                         if (newLineEnd)
 399                         {
 400                                 _GroupEdit->setCursorPos(newCharIndex - (sint32)_GroupEdit->getPromptRef().length());
 401                                 _GroupEdit->setCursorAtPreviousLineEnd(true);
 402                                 sint32 newPos = _GroupEdit->getCursorPos();
 403                                 clamp(newPos, (sint32) 0, (sint32) _GroupEdit->getInputStringRef().size());
 404                                 _GroupEdit->setCursorPos(newPos);
 405                                 return;
 406                         }
 407                         _GroupEdit->setCursorAtPreviousLineEnd(false);
 408                         // takes character whose X is closer to the current X
 409                         float cx0, cx1;
 410                         float cy0, cy1;
 411                         _GroupEdit->getViewText()->getCharacterPositionFromIndex(newCharIndex, _GroupEdit->isCursorAtPreviousLineEnd(), cx0, cy0, height);
 412                         _GroupEdit->getViewText()->getCharacterPositionFromIndex(newCharIndex + 1, _GroupEdit->isCursorAtPreviousLineEnd(), cx1, cy1, height);
 413                         if (abs(cx0 - cx) < abs(cx1 - cx) || cy0 != cy1)
 414                         {
 415                                 _GroupEdit->setCursorPos(newCharIndex);
 416                         }
 417                         else
 418                         {
 419                                 _GroupEdit->setCursorPos(newCharIndex + 1);
 420                         }
 421                         _GroupEdit->setCursorPos(_GroupEdit->getCursorPos()-(sint32)_GroupEdit->getPromptRef().length());
 422                         sint32 newpos = _GroupEdit->getCursorPos();
 423                         clamp(newpos, (sint32) 0, (sint32)_GroupEdit->getInputStringRef().size());
 424                         _GroupEdit->setCursorPos(newpos);
 425                 }
 426         }
 427 };
 428 REGISTER_ACTION_HANDLER (CAHEditPreviousLine, "edit_previous_line");
 429
 430 // ***************************************************************************
 431
 432 class CAHEditNextLine : public CAHEdit
 433 {
 434         void actionPart ()
 435         {
 436                 if( (! _GroupEdit->getViewText()->getMultiLine()) && _GroupEdit->getMaxHistoric() && _GroupEdit->getCurrentHistoricIndex()>0)
 437                 {
 438                         // Get the start of the string.
 439                         ::u32string     startStr= _GroupEdit->getInputStringRef().substr(0, _GroupEdit->getCursorPos());
 440
 441                         // Search all historic string that match startStr.
 442                         for(sint i=_GroupEdit->getCurrentHistoricIndex()-1;i>=0;i--)
 443                         {
 444                                 if( _GroupEdit->getHistoric(i).compare(0, _GroupEdit->getCursorPos(), startStr)==0 )
 445                                 {
 446                                         _GroupEdit->setInputStringRef (_GroupEdit->getHistoric(i));
 447                                         _GroupEdit->setCurrentHistoricIndex(i);
 448                                         break;
 449                                 }
 450                         }
 451                 }
 452                 else if (_GroupEdit->getViewText()->getMultiLine())
 453                 {
 454                         float cx, cy;
 455                         float height;
 456                         _GroupEdit->getViewText()->getCharacterPositionFromIndex(_GroupEdit->getCursorPos() + (sint)_GroupEdit->getPromptRef().length(), _GroupEdit->isCursorAtPreviousLineEnd(), cx, cy, height);
 457                         if (cy != 0)
 458                         {
 459                                 cy -= height;
 460                                 uint newCharIndex;
 461                                 bool newLineEnd;
 462                                 _GroupEdit->getViewText()->getCharacterIndexFromPosition(cx, cy, newCharIndex, newLineEnd);
 463                                 if (newLineEnd)
 464                                 {
 465                                         _GroupEdit->setCursorPos(newCharIndex - (sint32)_GroupEdit->getPromptRef().length());
 466                                         _GroupEdit->setCursorAtPreviousLineEnd(true);
 467                                         sint32 newPos = _GroupEdit->getCursorPos();
 468                                         clamp(newPos, (sint32) 0, (sint32) _GroupEdit->getInputStringRef().size());
 469                                         _GroupEdit->setCursorPos(newPos);
 470                                         return;
 471                                 }
 472                                 _GroupEdit->setCursorAtPreviousLineEnd(false);
 473                                 // takes character whose X is closer to the current X
 474                                 float cx0, cx1;
 475                                 float cy0, cy1;
 476                                 _GroupEdit->getViewText()->getCharacterPositionFromIndex(newCharIndex, _GroupEdit->isCursorAtPreviousLineEnd(), cx0, cy0, height);
 477                                 _GroupEdit->getViewText()->getCharacterPositionFromIndex(newCharIndex + 1, _GroupEdit->isCursorAtPreviousLineEnd(), cx1, cy1, height);
 478                                 if (abs(cx0 - cx) < abs(cx1 - cx) || cy0 != cy1)
 479                                 {
 480                                         _GroupEdit->setCursorPos(newCharIndex);
 481                                 }
 482                                 else
 483                                 {
 484                                         _GroupEdit->setCursorPos(min(sint32(newCharIndex + 1), sint32(_GroupEdit->getInputStringRef().length() + _GroupEdit->getPromptRef().length())));
 485                                 }
 486                                 _GroupEdit->setCursorPos(_GroupEdit->getCursorPos()-(sint32)_GroupEdit->getPromptRef().length());
 487                                 sint32 newPos = _GroupEdit->getCursorPos();
 488                                 clamp(newPos, (sint32) 0, (sint32) _GroupEdit->getInputStringRef().size());
 489                                 _GroupEdit->setCursorPos(newPos);
 490                         }
 491                 }
 492         }
 493 };
 494 REGISTER_ACTION_HANDLER (CAHEditNextLine, "edit_next_line");
 495
 496 // ***************************************************************************
 497
 498 class CAHEditDeleteChar : public CAHEdit
 499 {
 500 protected:
 501         void initPart ()
 502         {
 503                 init();
 504         }
 505         void actionPart ()
 506         {
 507                 // if selection is activated and not same cursors pos, then cut the selection
 508                 if(CGroupEditBox::getCurrSelection() != NULL && _GroupEdit->getCursorPos() != CGroupEditBox::getSelectCursorPos())
 509                 {
 510                         if (CGroupEditBox::getCurrSelection() != _GroupEdit)
 511                         {
 512                                 nlwarning("Selection can only be on focus");
 513                         }
 514                         _GroupEdit->cutSelection();
 515                         // Change Handler
 516                         if (!_GroupEdit->getAHOnChange().empty())
 517                         {
 518                                 CInterfaceManager *pIM = CInterfaceManager::getInstance();
 519                                 CAHManager::getInstance()->runActionHandler(_GroupEdit->getAHOnChange(), _GroupEdit, _GroupEdit->getParamsOnChange());
 520                         }
 521                 }
 522                 // else cut forwards
 523                 else if(_GroupEdit->getCursorPos() < (sint32) _GroupEdit->getInputStringRef().length())
 524                 {
 525                         ::u32string inputString = _GroupEdit->getInputStringRef();
 526                         ::u32string::iterator it = inputString.begin() + _GroupEdit->getCursorPos();
 527                         inputString.erase(it);
 528                         _GroupEdit->setInputStringRef (inputString);
 529                         if (!_GroupEdit->getAHOnChange().empty())
 530                         {
 531                                 CInterfaceManager *pIM = CInterfaceManager::getInstance();
 532                                 CAHManager::getInstance()->runActionHandler(_GroupEdit->getAHOnChange(), _GroupEdit, _GroupEdit->getParamsOnChange());
 533                         }
 534                 }
 535                 // must stop selection in all case
 536                 CGroupEditBox::setCurrSelection(NULL);
 537                 _GroupEdit->setCursorAtPreviousLineEnd(false);
 538         }
 539 };
 540 REGISTER_ACTION_HANDLER (CAHEditDeleteChar, "edit_delete_char");
 541
 542 // ***************************************************************************
 543
 544 class CAHEditSelectAll : public CAHEdit
 545 {
 546         void initPart ()
 547         {
 548                 init();
 549         }
 550         void actionPart ()
 551         {
 552                 _GroupEdit->setSelectionAll();
 553         }
 554 };
 555 REGISTER_ACTION_HANDLER (CAHEditSelectAll, "edit_select_all");
 556
 557 // ***************************************************************************
 558
 559 class CAHEditCopy : public CAHEdit
 560 {
 561         void initPart ()
 562         {
 563                 init();
 564         }
 565         void actionPart ()
 566         {
 567                 _GroupEdit->copy();
 568         }
 569         void forwardToEditor()
 570         {
 571                 R2::getEditor().copy();
 572         }
 573 };
 574 REGISTER_ACTION_HANDLER (CAHEditCopy, "edit_copy");
 575
 576 // ***************************************************************************
 577
 578 class CAHEditPaste : public CAHEdit
 579 {
 580         void initPart ()
 581         {
 582                 init();
 583         }
 584         void actionPart ()
 585         {
 586                 _GroupEdit->paste();
 587         }
 588         void forwardToEditor()
 589         {
 590                 R2::getEditor().paste();
 591         }
 592 };
 593 REGISTER_ACTION_HANDLER (CAHEditPaste, "edit_paste");
 594
 595 // ***************************************************************************
 596
 597 class CAHEditCut : public CAHEditDeleteChar
 598 {
 599         void initPart ()
 600         {
 601                 init();
 602         }
 603         void actionPart ()
 604         {
 605                 // if selection is activated and not same cursors pos, then cut the selection
 606                 if(CGroupEditBox::getCurrSelection() != NULL && _GroupEdit->getCursorPos() != CGroupEditBox::getSelectCursorPos())
 607                 {
 608                         // Copy selection
 609                         _GroupEdit->copy();
 610
 611                         // Cut selection
 612                         CAHEditDeleteChar::actionPart();
 613                 }
 614         }
 615 };
 616 REGISTER_ACTION_HANDLER (CAHEditCut, "edit_cut");
 617
 618 // ***************************************************************************
 619
 620 class CAHEditExpand : public CAHEdit
 621 {
 622         void initPart ()
 623         {
 624                 init();
 625         }
 626         void actionPart ()
 627         {
 628                 _GroupEdit->expand();
 629         }
 630 };
 631 REGISTER_ACTION_HANDLER (CAHEditExpand, "edit_expand");
 632
 633 // ***************************************************************************
 634 class CAHEditExpandOrCycleTell : public CAHEdit
 635 {
 636         void initPart ()
 637         {
 638                 init();
 639         }
 640         void actionPart ()
 641         {
 642                 // If the line starts with '/tell ', do not try to expand
 643                 if (!NLMISC::startsWith(_GroupEdit->getInputString(), "/tell "))
 644                 {
 645                         if (_GroupEdit->expand()) return;
 646                 }
 647                 CInterfaceManager *im = CInterfaceManager::getInstance();
 648                 if (!im->isInGame()) return;
 649                 // there was no / at the start of the line so try to cycle through the last people on which a tell was done
 650                 const string *lastTellPeople = ChatMngr.cycleLastTell();
 651                 if (!lastTellPeople) return;
 652                 // Get chat box from ist edit box
 653                 // If it isn't a user chat or the main chat, just display 'tell' with the name. Otherwise, change the target of the window
 654                 CChatWindow *cw = getChatWndMgr().getChatWindowFromCaller(_GroupEdit);
 655                 if (!cw) return;
 656                 CFilteredChat *fc = PeopleInterraction.getFilteredChatFromChatWindow(cw);
 657                 if (fc)
 658                 {
 659                         fc->Filter.setTargetPlayer(*lastTellPeople);
 660                 }
 661                 else
 662                 {
 663                         // it is not a filtered chat, display 'tell' (must be ingame)
 664                         _GroupEdit->setCommand("tell " + (*lastTellPeople) + ' ', false);
 665                 }
 666         }
 667 };
 668 REGISTER_ACTION_HANDLER (CAHEditExpandOrCycleTell, "edit_expand_or_cycle_tell");
 669
 670 // ***************************************************************************
 671
 672 class CAHEditBack: public CAHEdit
 673 {
 674         void initPart ()
 675         {
 676                 init();
 677         }
 678         void actionPart ()
 679         {
 680                 _GroupEdit->back();
 681         }
 682 };
 683 REGISTER_ACTION_HANDLER (CAHEditBack, "edit_back");
 684
 685 // ***************************************************************************
 686
 687 class CAHEditSelectPreviousChar : public CAHEditPreviousChar
 688 {
 689         void initPart ()
 690         {
 691                 init();
 692                 handleSelection();
 693         }
 694 };
 695 REGISTER_ACTION_HANDLER (CAHEditSelectPreviousChar, "edit_select_previous_char");
 696
 697 // ***************************************************************************
 698
 699 class CAHEditSelectNextChar : public CAHEditNextChar
 700 {
 701         void initPart ()
 702         {
 703                 init();
 704                 handleSelection();
 705         }
 706 };
 707 REGISTER_ACTION_HANDLER (CAHEditSelectNextChar, "edit_select_next_char");
 708
 709 // ***************************************************************************
 710
 711 class CAHEditSelectPreviousWord : public CAHEditPreviousWord
 712 {
 713         void initPart ()
 714         {
 715                 init();
 716                 handleSelection();
 717         }
 718 };
 719 REGISTER_ACTION_HANDLER (CAHEditSelectPreviousWord, "edit_select_previous_word");
 720
 721 // ***************************************************************************
 722
 723 class CAHEditSelectNextWord : public CAHEditNextWord
 724 {
 725         void initPart ()
 726         {
 727                 init();
 728                 handleSelection();
 729         }
 730 };
 731 REGISTER_ACTION_HANDLER (CAHEditSelectNextWord, "edit_select_next_word");
 732
 733 // ***************************************************************************
 734
 735 class CAHEditSelectToLineBegin : public CAHEditGotoLineBegin
 736 {
 737         void initPart ()
 738         {
 739                 init();
 740                 handleSelection();
 741         }
 742 };
 743 REGISTER_ACTION_HANDLER (CAHEditSelectToLineBegin, "edit_select_to_line_begin");
 744
 745 // ***************************************************************************
 746
 747 class CAHEditSelectToLineEnd : public CAHEditGotoLineEnd
 748 {
 749         void initPart ()
 750         {
 751                 init();
 752                 handleSelection();
 753         }
 754 };
 755 REGISTER_ACTION_HANDLER (CAHEditSelectToLineEnd, "edit_select_to_line_end");
 756
 757 // ***************************************************************************
 758
 759 class CAHEditSelectToBlockBegin : public CAHEditGotoBlockBegin
 760 {
 761         void initPart ()
 762         {
 763                 init();
 764                 handleSelection();
 765         }
 766 };
 767 REGISTER_ACTION_HANDLER (CAHEditSelectToBlockBegin, "edit_select_to_block_begin");
 768
 769 // ***************************************************************************
 770
 771 class CAHEditSelectToBlockEnd : public CAHEditGotoBlockEnd
 772 {
 773         void initPart ()
 774         {
 775                 init();
 776                 handleSelection();
 777         }
 778 };
 779 REGISTER_ACTION_HANDLER (CAHEditSelectToBlockEnd, "edit_select_to_block_end");
 780
 781 // ***************************************************************************