m4n71k0r

Notepad++

Feb 27th, 2012
339
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. void Notepad_plus::command(int id)
  2. {
  3.     switch (id)
  4.     {
  5.         case IDM_FILE_NEW:
  6.         {
  7.             fileNew();
  8.         }
  9.         break;
  10.  
  11.         case IDM_FILE_OPEN:
  12.         {
  13.             fileOpen();
  14.         }
  15.         break;
  16.  
  17.         case IDM_FILE_RELOAD:
  18.             fileReload();
  19.             break;
  20.  
  21.         case IDM_FILE_CLOSE:
  22.             if (fileClose())
  23.                 checkDocState();
  24.             break;
  25.  
  26.         case IDM_FILE_DELETE:
  27.             if (fileDelete())
  28.                 checkDocState();
  29.             break;
  30.  
  31.         case IDM_FILE_RENAME:
  32.             fileRename();
  33.             break;
  34.  
  35.         case IDM_FILE_CLOSEALL:
  36.             fileCloseAll();
  37.             checkDocState();
  38.             break;
  39.  
  40.         case IDM_FILE_CLOSEALL_BUT_CURRENT :
  41.             fileCloseAllButCurrent();
  42.             checkDocState();
  43.             break;
  44.  
  45.         case IDM_FILE_SAVE :
  46.             fileSave();
  47.             break;
  48.  
  49.         case IDM_FILE_SAVEALL :
  50.             fileSaveAll();
  51.             break;
  52.  
  53.         case IDM_FILE_SAVEAS :
  54.             fileSaveAs();
  55.             break;
  56.  
  57.         case IDM_FILE_SAVECOPYAS :
  58.             fileSaveAs(BUFFER_INVALID, true);
  59.             break;
  60.  
  61.         case IDM_FILE_LOADSESSION:
  62.             fileLoadSession();
  63.             break;
  64.  
  65.         case IDM_FILE_SAVESESSION:
  66.             fileSaveSession();
  67.             break;
  68.  
  69.         case IDM_FILE_PRINTNOW :
  70.             filePrint(false);
  71.             break;
  72.  
  73.         case IDM_FILE_PRINT :
  74.             filePrint(true);
  75.             break;
  76.  
  77.         case IDM_FILE_EXIT:
  78.             ::SendMessage(_pPublicInterface->getHSelf(), WM_CLOSE, 0, 0);
  79.             break;
  80.  
  81.         case IDM_EDIT_UNDO:
  82.             _pEditView->execute(WM_UNDO);
  83.             checkClipboard();
  84.             checkUndoState();
  85.             break;
  86.  
  87.         case IDM_EDIT_REDO:
  88.             _pEditView->execute(SCI_REDO);
  89.             checkClipboard();
  90.             checkUndoState();
  91.             break;
  92.  
  93.         case IDM_EDIT_CUT:
  94.             _pEditView->execute(WM_CUT);
  95.             checkClipboard();
  96.             break;
  97.  
  98.         case IDM_EDIT_COPY:
  99.             _pEditView->execute(WM_COPY);
  100.             checkClipboard();
  101.             break;
  102.  
  103.         case IDM_EDIT_COPY_BINARY:
  104.         case IDM_EDIT_CUT_BINARY:
  105.         {
  106.             int textLen = _pEditView->execute(SCI_GETSELTEXT, 0, 0) - 1;
  107.             if (!textLen)
  108.                 return;
  109.  
  110.             char *pBinText = new char[textLen + 1];
  111.             _pEditView->getSelectedText(pBinText, textLen + 1);
  112.  
  113.             // Open the clipboard, and empty it.
  114.             if (!OpenClipboard(NULL))
  115.                 return;
  116.             EmptyClipboard();
  117.  
  118.             // Allocate a global memory object for the text.
  119.             HGLOBAL hglbCopy = GlobalAlloc(GMEM_MOVEABLE, (textLen + 1) * sizeof(unsigned char));
  120.             if (hglbCopy == NULL)
  121.             {
  122.                 CloseClipboard();
  123.                 return;
  124.             }
  125.  
  126.             // Lock the handle and copy the text to the buffer.
  127.             unsigned char *lpucharCopy = (unsigned char *)GlobalLock(hglbCopy);
  128.             memcpy(lpucharCopy, pBinText, textLen * sizeof(unsigned char));
  129.             lpucharCopy[textLen] = 0;    // null character
  130.            
  131.             GlobalUnlock(hglbCopy);
  132.      
  133.             // Place the handle on the clipboard.
  134.             SetClipboardData(CF_TEXT, hglbCopy);
  135.            
  136.  
  137.             // Allocate a global memory object for the text length.
  138.             HGLOBAL hglbLenCopy = GlobalAlloc(GMEM_MOVEABLE, sizeof(unsigned long));
  139.             if (hglbLenCopy == NULL)
  140.             {
  141.                 CloseClipboard();
  142.                 return;
  143.             }
  144.      
  145.             // Lock the handle and copy the text to the buffer.
  146.             unsigned long *lpLenCopy = (unsigned long *)GlobalLock(hglbLenCopy);
  147.             *lpLenCopy = textLen;
  148.            
  149.             GlobalUnlock(hglbLenCopy);
  150.      
  151.             // Place the handle on the clipboard.
  152.             UINT f = RegisterClipboardFormat(CF_NPPTEXTLEN);
  153.             SetClipboardData(f, hglbLenCopy);
  154.  
  155.             CloseClipboard();
  156.  
  157.             if (id == IDM_EDIT_CUT_BINARY)
  158.                 _pEditView->execute(SCI_REPLACESEL, 0, (LPARAM)"");
  159.         }
  160.         break;
  161.  
  162.         case IDM_EDIT_PASTE:
  163.         {
  164.             int eolMode = int(_pEditView->execute(SCI_GETEOLMODE));
  165.             _pEditView->execute(SCI_PASTE);
  166.             _pEditView->execute(SCI_CONVERTEOLS, eolMode);
  167.         }
  168.         break;
  169.  
  170.         case IDM_EDIT_PASTE_BINARY:
  171.         {          
  172.             if (!IsClipboardFormatAvailable(CF_TEXT))
  173.                 return;
  174.  
  175.             if (!OpenClipboard(NULL))
  176.                 return;
  177.      
  178.             HGLOBAL hglb = GetClipboardData(CF_TEXT);
  179.             if (hglb != NULL)
  180.             {
  181.                 char *lpchar = (char *)GlobalLock(hglb);
  182.                 if (lpchar != NULL)
  183.                 {
  184.                     UINT cf_nppTextLen = RegisterClipboardFormat(CF_NPPTEXTLEN);
  185.                     if (IsClipboardFormatAvailable(cf_nppTextLen))
  186.                     {
  187.                         HGLOBAL hglbLen = GetClipboardData(cf_nppTextLen);
  188.                         if (hglbLen != NULL)
  189.                         {
  190.                             unsigned long *lpLen = (unsigned long *)GlobalLock(hglbLen);
  191.                             if (lpLen != NULL)
  192.                             {
  193.                                 _pEditView->execute(SCI_REPLACESEL, 0, (LPARAM)"");
  194.                                 _pEditView->execute(SCI_ADDTEXT, *lpLen, (LPARAM)lpchar);
  195.  
  196.                                 GlobalUnlock(hglb);
  197.                             }
  198.                         }
  199.                     }
  200.                     else
  201.                     {
  202.  
  203.                         _pEditView->execute(SCI_REPLACESEL, 0, (LPARAM)lpchar);
  204.                     }
  205.                     GlobalUnlock(hglb);
  206.                 }
  207.             }
  208.             CloseClipboard();
  209.  
  210.         }
  211.         break;
  212.  
  213.         case IDM_EDIT_PASTE_AS_RTF:
  214.         case IDM_EDIT_PASTE_AS_HTML:
  215.         {
  216.             UINT f = RegisterClipboardFormat(id==IDM_EDIT_PASTE_AS_HTML?CF_HTML:CF_RTF);
  217.  
  218.             if (!IsClipboardFormatAvailable(f))
  219.                 return;
  220.                
  221.             if (!OpenClipboard(NULL))
  222.                 return;
  223.      
  224.             HGLOBAL hglb = GetClipboardData(f);
  225.             if (hglb != NULL)
  226.             {
  227.                 LPSTR lptstr = (LPSTR)GlobalLock(hglb);
  228.                 if (lptstr != NULL)
  229.                 {
  230.                     // Call the application-defined ReplaceSelection
  231.                     // function to insert the text and repaint the
  232.                     // window.
  233.                     _pEditView->execute(SCI_REPLACESEL, 0, (LPARAM)lptstr);
  234.  
  235.                     GlobalUnlock(hglb);
  236.                 }
  237.             }
  238.             CloseClipboard();
  239.         }
  240.         break;
  241.  
  242.         case IDM_EDIT_CHAR_PANEL:
  243.         {
  244.             launchAnsiCharPanel();
  245.         }
  246.         break;
  247.  
  248.         case IDM_EDIT_CLIPBOARDHISTORY_PANEL:
  249.         {
  250.             launchClipboardHistoryPanel();
  251.         }
  252.         break;
  253.  
  254.         case IDM_VIEW_FILESWITCHER_PANEL:
  255.         {
  256.             launchFileSwitcherPanel();
  257.         }
  258.         break;
  259.  
  260.         case IDM_VIEW_PROJECT_PANEL_1:
  261.         {
  262.             launchProjectPanel(id, &_pProjectPanel_1, 0);
  263.         }
  264.         break;
  265.         case IDM_VIEW_PROJECT_PANEL_2:
  266.         {
  267.             launchProjectPanel(id, &_pProjectPanel_2, 1);
  268.         }
  269.         break;
  270.         case IDM_VIEW_PROJECT_PANEL_3:
  271.         {
  272.             launchProjectPanel(id, &_pProjectPanel_3, 2);
  273.         }
  274.         break;
  275.  
  276.         case IDM_EDIT_DELETE:
  277.             _pEditView->execute(WM_CLEAR);
  278.             break;
  279.  
  280.         case IDM_MACRO_STARTRECORDINGMACRO:
  281.         case IDM_MACRO_STOPRECORDINGMACRO:
  282.         case IDC_EDIT_TOGGLEMACRORECORDING:
  283.         {
  284.             if (_recordingMacro)
  285.             {
  286.                 // STOP !!!
  287.                 _mainEditView.execute(SCI_STOPRECORD);
  288.                 _subEditView.execute(SCI_STOPRECORD);
  289.                
  290.                 _mainEditView.execute(SCI_SETCURSOR, (WPARAM)SC_CURSORNORMAL);
  291.                 _subEditView.execute(SCI_SETCURSOR, (WPARAM)SC_CURSORNORMAL);
  292.                
  293.                 _recordingMacro = false;
  294.                 _runMacroDlg.initMacroList();
  295.             }
  296.             else
  297.             {
  298.                 _mainEditView.execute(SCI_SETCURSOR, 9);
  299.                 _subEditView.execute(SCI_SETCURSOR, 9);
  300.                 _macro.clear();
  301.  
  302.                 // START !!!
  303.                 _mainEditView.execute(SCI_STARTRECORD);
  304.                 _subEditView.execute(SCI_STARTRECORD);
  305.                 _recordingMacro = true;
  306.             }
  307.             checkMacroState();
  308.             break;
  309.         }
  310.  
  311.         case IDM_MACRO_PLAYBACKRECORDEDMACRO:
  312.             if (!_recordingMacro) // if we're not currently recording, then playback the recorded keystrokes
  313.                 macroPlayback(_macro);
  314.             break;
  315.  
  316.         case IDM_MACRO_RUNMULTIMACRODLG :
  317.         {
  318.             if (!_recordingMacro) // if we're not currently recording, then playback the recorded keystrokes
  319.             {
  320.                 bool isFirstTime = !_runMacroDlg.isCreated();
  321.                 _runMacroDlg.doDialog(_nativeLangSpeaker.isRTL());
  322.                
  323.                 if (isFirstTime)
  324.                 {
  325.                     _nativeLangSpeaker.changeDlgLang(_runMacroDlg.getHSelf(), "MultiMacro");
  326.                 }
  327.                 break;
  328.                
  329.             }
  330.         }
  331.         break;
  332.  
  333.         case IDM_MACRO_SAVECURRENTMACRO :
  334.         {
  335.             if (addCurrentMacro())
  336.                 _runMacroDlg.initMacroList();
  337.             break;
  338.         }
  339.         case IDM_EDIT_FULLPATHTOCLIP :
  340.         case IDM_EDIT_CURRENTDIRTOCLIP :
  341.         case IDM_EDIT_FILENAMETOCLIP :
  342.         {
  343.             Buffer * buf = _pEditView->getCurrentBuffer();
  344.             if (id == IDM_EDIT_FULLPATHTOCLIP)
  345.             {
  346.                 str2Cliboard(buf->getFullPathName());
  347.             }
  348.             else if (id == IDM_EDIT_CURRENTDIRTOCLIP)
  349.             {
  350.                 generic_string dir(buf->getFullPathName());
  351.                 PathRemoveFileSpec(dir);
  352.                 str2Cliboard(dir.c_str());
  353.             }
  354.             else if (id == IDM_EDIT_FILENAMETOCLIP)
  355.             {
  356.                 str2Cliboard(buf->getFileName());
  357.             }
  358.         }
  359.         break;
  360.  
  361.         case IDM_SEARCH_FIND :
  362.         case IDM_SEARCH_REPLACE :
  363.         {
  364.             const int strSize = FINDREPLACE_MAXLENGTH;
  365.             TCHAR str[strSize];
  366.  
  367.             bool isFirstTime = !_findReplaceDlg.isCreated();
  368.  
  369.             _findReplaceDlg.doDialog((id == IDM_SEARCH_FIND)?FIND_DLG:REPLACE_DLG, _nativeLangSpeaker.isRTL());
  370.  
  371.             _pEditView->getGenericSelectedText(str, strSize);
  372.             _findReplaceDlg.setSearchText(str);
  373.             setFindReplaceFolderFilter(NULL, NULL);
  374.  
  375.             if (isFirstTime)
  376.                 _nativeLangSpeaker.changeFindReplaceDlgLang(_findReplaceDlg);
  377.             break;
  378.         }
  379.  
  380.         case IDM_SEARCH_FINDINFILES :
  381.         {
  382.             ::SendMessage(_pPublicInterface->getHSelf(), NPPM_LAUNCHFINDINFILESDLG, 0, 0);
  383.             break;
  384.         }
  385.         case IDM_SEARCH_FINDINCREMENT :
  386.         {
  387.             const int strSize = FINDREPLACE_MAXLENGTH;
  388.             TCHAR str[strSize];
  389.  
  390.             _pEditView->getGenericSelectedText(str, strSize, false);
  391.             if (0!=str[0])         // the selected text is not empty, then use it
  392.             _incrementFindDlg.setSearchText(str, _pEditView->getCurrentBuffer()->getUnicodeMode() != uni8Bit);
  393.  
  394.             _incrementFindDlg.display();
  395.         }
  396.         break;
  397.  
  398.         case IDM_SEARCH_FINDNEXT :
  399.         case IDM_SEARCH_FINDPREV :
  400.         {
  401.             if (!_findReplaceDlg.isCreated())
  402.                 return;
  403.  
  404.             FindOption op = _findReplaceDlg.getCurrentOptions();
  405.             op._whichDirection = (id == IDM_SEARCH_FINDNEXT?DIR_DOWN:DIR_UP);
  406.             generic_string s = _findReplaceDlg.getText2search();
  407.  
  408.             _findReplaceDlg.processFindNext(s.c_str(), &op);
  409.             break;
  410.         }
  411.         break;
  412.  
  413.         case IDM_SEARCH_SETANDFINDNEXT :
  414.         case IDM_SEARCH_SETANDFINDPREV :
  415.         {
  416.             bool isFirstTime = !_findReplaceDlg.isCreated();
  417.             if (isFirstTime)
  418.                 _findReplaceDlg.doDialog(FIND_DLG, _nativeLangSpeaker.isRTL(), false);
  419.  
  420.             const int strSize = FINDREPLACE_MAXLENGTH;
  421.             TCHAR str[strSize];
  422.             _pEditView->getGenericSelectedText(str, strSize);
  423.             _findReplaceDlg.setSearchText(str);
  424.             _findReplaceDlg._env->_str2Search = str;
  425.             setFindReplaceFolderFilter(NULL, NULL);
  426.             if (isFirstTime)
  427.                 _nativeLangSpeaker.changeFindReplaceDlgLang(_findReplaceDlg);
  428.  
  429.             FindOption op = _findReplaceDlg.getCurrentOptions();
  430.             op._whichDirection = (id == IDM_SEARCH_SETANDFINDNEXT?DIR_DOWN:DIR_UP);
  431.  
  432.             _findReplaceDlg.processFindNext(str, &op);
  433.             break;
  434.         }
  435.  
  436.         case IDM_SEARCH_GOTONEXTFOUND:
  437.         {
  438.             _findReplaceDlg.gotoNextFoundResult();
  439.             break;
  440.         }
  441.         case IDM_SEARCH_GOTOPREVFOUND:
  442.         {
  443.             _findReplaceDlg.gotoNextFoundResult(-1);
  444.             break;
  445.         }
  446.         case IDM_FOCUS_ON_FOUND_RESULTS:
  447.         {
  448.             if (GetFocus() == _findReplaceDlg.getHFindResults())
  449.                 // focus already on found results, switch to current edit view
  450.                 switchEditViewTo(currentView());
  451.             else
  452.                 _findReplaceDlg.focusOnFinder();
  453.             break;
  454.         }
  455.  
  456.         case IDM_SEARCH_VOLATILE_FINDNEXT :
  457.         case IDM_SEARCH_VOLATILE_FINDPREV :
  458.         {
  459.             TCHAR text2Find[MAX_PATH];
  460.             _pEditView->getGenericSelectedText(text2Find, MAX_PATH);
  461.  
  462.             FindOption op;
  463.             op._isWholeWord = false;
  464.             op._whichDirection = (id == IDM_SEARCH_VOLATILE_FINDNEXT?DIR_DOWN:DIR_UP);
  465.             _findReplaceDlg.processFindNext(text2Find, &op);
  466.             break;
  467.         }
  468.  
  469.         case IDM_SEARCH_MARKALLEXT1 :
  470.         case IDM_SEARCH_MARKALLEXT2 :
  471.         case IDM_SEARCH_MARKALLEXT3 :
  472.         case IDM_SEARCH_MARKALLEXT4 :
  473.         case IDM_SEARCH_MARKALLEXT5 :
  474.         {
  475.             int styleID;
  476.             if (id == IDM_SEARCH_MARKALLEXT1)
  477.                 styleID = SCE_UNIVERSAL_FOUND_STYLE_EXT1;
  478.             else if (id == IDM_SEARCH_MARKALLEXT2)
  479.                 styleID = SCE_UNIVERSAL_FOUND_STYLE_EXT2;
  480.             else if (id == IDM_SEARCH_MARKALLEXT3)
  481.                 styleID = SCE_UNIVERSAL_FOUND_STYLE_EXT3;
  482.             else if (id == IDM_SEARCH_MARKALLEXT4)
  483.                 styleID = SCE_UNIVERSAL_FOUND_STYLE_EXT4;
  484.             else // (id == IDM_SEARCH_MARKALLEXT5)
  485.                 styleID = SCE_UNIVERSAL_FOUND_STYLE_EXT5;
  486.  
  487.             const int strSize = FINDREPLACE_MAXLENGTH;
  488.             TCHAR text2Find[strSize];
  489.             _pEditView->getGenericSelectedText(text2Find, strSize, false);
  490.             if (text2Find[0] == '\0')
  491.             {
  492.                 _pEditView->getGenericWordOnCaretPos(text2Find, strSize);
  493.             }
  494.             _findReplaceDlg.markAll(text2Find, styleID);
  495.  
  496.             break;
  497.         }
  498.         case IDM_SEARCH_UNMARKALLEXT1 :
  499.         case IDM_SEARCH_UNMARKALLEXT2 :
  500.         case IDM_SEARCH_UNMARKALLEXT3 :
  501.         case IDM_SEARCH_UNMARKALLEXT4 :
  502.         case IDM_SEARCH_UNMARKALLEXT5 :
  503.         {
  504.             int styleID;
  505.             if (id == IDM_SEARCH_UNMARKALLEXT1)
  506.                 styleID = SCE_UNIVERSAL_FOUND_STYLE_EXT1;
  507.             else if (id == IDM_SEARCH_UNMARKALLEXT2)
  508.                 styleID = SCE_UNIVERSAL_FOUND_STYLE_EXT2;
  509.             else if (id == IDM_SEARCH_UNMARKALLEXT3)
  510.                 styleID = SCE_UNIVERSAL_FOUND_STYLE_EXT3;
  511.             else if (id == IDM_SEARCH_UNMARKALLEXT4)
  512.                 styleID = SCE_UNIVERSAL_FOUND_STYLE_EXT4;
  513.             else // (id == IDM_SEARCH_UNMARKALLEXT5)
  514.                 styleID = SCE_UNIVERSAL_FOUND_STYLE_EXT5;
  515.  
  516.             _pEditView->clearIndicator(styleID);
  517.             break;
  518.         }
  519.  
  520.         case IDM_SEARCH_GONEXTMARKER1 :
  521.         case IDM_SEARCH_GONEXTMARKER2 :
  522.         case IDM_SEARCH_GONEXTMARKER3 :
  523.         case IDM_SEARCH_GONEXTMARKER4 :
  524.         case IDM_SEARCH_GONEXTMARKER5 :
  525.         case IDM_SEARCH_GONEXTMARKER_DEF :
  526.         {
  527.             int styleID;
  528.             if (id == IDM_SEARCH_GONEXTMARKER1)
  529.                 styleID = SCE_UNIVERSAL_FOUND_STYLE_EXT1;
  530.             else if (id == IDM_SEARCH_GONEXTMARKER2)
  531.                 styleID = SCE_UNIVERSAL_FOUND_STYLE_EXT2;
  532.             else if (id == IDM_SEARCH_GONEXTMARKER3)
  533.                 styleID = SCE_UNIVERSAL_FOUND_STYLE_EXT3;
  534.             else if (id == IDM_SEARCH_GONEXTMARKER4)
  535.                 styleID = SCE_UNIVERSAL_FOUND_STYLE_EXT4;
  536.             else if (id == IDM_SEARCH_GONEXTMARKER5)
  537.                 styleID = SCE_UNIVERSAL_FOUND_STYLE_EXT5;
  538.             else // (id == IDM_SEARCH_GONEXTMARKER_DEF)
  539.                 styleID = SCE_UNIVERSAL_FOUND_STYLE;
  540.  
  541.             goToNextIndicator(styleID);
  542.  
  543.             break;
  544.         }
  545.        
  546.         case IDM_SEARCH_GOPREVMARKER1 :
  547.         case IDM_SEARCH_GOPREVMARKER2 :
  548.         case IDM_SEARCH_GOPREVMARKER3 :
  549.         case IDM_SEARCH_GOPREVMARKER4 :
  550.         case IDM_SEARCH_GOPREVMARKER5 :
  551.         case IDM_SEARCH_GOPREVMARKER_DEF :
  552.         {
  553.             int styleID;
  554.             if (id == IDM_SEARCH_GOPREVMARKER1)
  555.                 styleID = SCE_UNIVERSAL_FOUND_STYLE_EXT1;
  556.             else if (id == IDM_SEARCH_GOPREVMARKER2)
  557.                 styleID = SCE_UNIVERSAL_FOUND_STYLE_EXT2;
  558.             else if (id == IDM_SEARCH_GOPREVMARKER3)
  559.                 styleID = SCE_UNIVERSAL_FOUND_STYLE_EXT3;
  560.             else if (id == IDM_SEARCH_GOPREVMARKER4)
  561.                 styleID = SCE_UNIVERSAL_FOUND_STYLE_EXT4;
  562.             else if (id == IDM_SEARCH_GOPREVMARKER5)
  563.                 styleID = SCE_UNIVERSAL_FOUND_STYLE_EXT5;
  564.             else // (id == IDM_SEARCH_GOPREVMARKER_DEF)
  565.                 styleID = SCE_UNIVERSAL_FOUND_STYLE;
  566.  
  567.             goToPreviousIndicator(styleID);
  568.  
  569.             break;
  570.         }
  571.  
  572.         case IDM_SEARCH_CLEARALLMARKS :
  573.         {
  574.             _pEditView->clearIndicator(SCE_UNIVERSAL_FOUND_STYLE_EXT1);
  575.             _pEditView->clearIndicator(SCE_UNIVERSAL_FOUND_STYLE_EXT2);
  576.             _pEditView->clearIndicator(SCE_UNIVERSAL_FOUND_STYLE_EXT3);
  577.             _pEditView->clearIndicator(SCE_UNIVERSAL_FOUND_STYLE_EXT4);
  578.             _pEditView->clearIndicator(SCE_UNIVERSAL_FOUND_STYLE_EXT5);
  579.             break;
  580.         }
  581.  
  582.         case IDM_SEARCH_GOTOLINE :
  583.         {
  584.             bool isFirstTime = !_goToLineDlg.isCreated();
  585.             _goToLineDlg.doDialog(_nativeLangSpeaker.isRTL());
  586.             if (isFirstTime)
  587.                 _nativeLangSpeaker.changeDlgLang(_goToLineDlg.getHSelf(), "GoToLine");
  588.             break;
  589.         }
  590.  
  591.         case IDM_SEARCH_FINDCHARINRANGE :
  592.         {
  593.             bool isFirstTime = !_findCharsInRangeDlg.isCreated();
  594.             _findCharsInRangeDlg.doDialog(_nativeLangSpeaker.isRTL());
  595.             if (isFirstTime)
  596.                 _nativeLangSpeaker.changeDlgLang(_findCharsInRangeDlg.getHSelf(), "FindCharsInRange");
  597.             break;
  598.         }
  599.  
  600.         case IDM_EDIT_COLUMNMODETIP :
  601.         {
  602.             _nativeLangSpeaker.messageBox("ColumnModeTip",
  603.                     _pPublicInterface->getHSelf(),
  604.                     TEXT("Please use \"ALT+Mouse Selection\" or \"Alt+Shift+Arrow key\" to switch to column mode."),
  605.                     TEXT("Column Mode Tip"),
  606.                     MB_OK|MB_APPLMODAL);
  607.             break;
  608.         }
  609.  
  610.         case IDM_EDIT_COLUMNMODE :
  611.         {
  612.             bool isFirstTime = !_colEditorDlg.isCreated();
  613.             _colEditorDlg.doDialog(_nativeLangSpeaker.isRTL());
  614.             if (isFirstTime)
  615.                 _nativeLangSpeaker.changeDlgLang(_colEditorDlg.getHSelf(), "ColumnEditor");
  616.             break;
  617.         }
  618.  
  619.         case IDM_SEARCH_GOTOMATCHINGBRACE :
  620.         {
  621.             int braceAtCaret = -1;
  622.             int braceOpposite = -1;
  623.             findMatchingBracePos(braceAtCaret, braceOpposite);
  624.  
  625.             if (braceOpposite != -1)
  626.                 _pEditView->execute(SCI_GOTOPOS, braceOpposite);
  627.             break;
  628.         }
  629.  
  630.         case IDM_SEARCH_TOGGLE_BOOKMARK :
  631.             bookmarkToggle(-1);
  632.             break;
  633.  
  634.         case IDM_SEARCH_NEXT_BOOKMARK:
  635.             bookmarkNext(true);
  636.             break;
  637.  
  638.         case IDM_SEARCH_PREV_BOOKMARK:
  639.             bookmarkNext(false);
  640.             break;
  641.  
  642.         case IDM_SEARCH_CLEAR_BOOKMARKS:
  643.             bookmarkClearAll();
  644.             break;
  645.            
  646.         case IDM_VIEW_USER_DLG :
  647.         {
  648.             bool isUDDlgVisible = false;
  649.                
  650.             UserDefineDialog *udd = _pEditView->getUserDefineDlg();
  651.  
  652.             if (!udd->isCreated())
  653.             {
  654.                 _pEditView->doUserDefineDlg(true, _nativeLangSpeaker.isRTL());
  655.                 _nativeLangSpeaker.changeUserDefineLang(udd);
  656.                 if (_isUDDocked)
  657.                     ::SendMessage(udd->getHSelf(), WM_COMMAND, IDC_DOCK_BUTTON, 0);
  658.  
  659.             }
  660.             else
  661.             {
  662.                 isUDDlgVisible = udd->isVisible();
  663.                 bool isUDDlgDocked = udd->isDocked();
  664.  
  665.                 if ((isUDDlgDocked)&&(isUDDlgVisible))
  666.                 {
  667.                     ::ShowWindow(_pMainSplitter->getHSelf(), SW_HIDE);
  668.  
  669.                     if (bothActive())
  670.                         _pMainWindow = &_subSplitter;
  671.                     else
  672.                         _pMainWindow = _pDocTab;
  673.  
  674.                     ::SendMessage(_pPublicInterface->getHSelf(), WM_SIZE, 0, 0);
  675.                    
  676.                     udd->display(false);
  677.                     _mainWindowStatus &= ~WindowUserActive;
  678.                 }
  679.                 else if ((isUDDlgDocked)&&(!isUDDlgVisible))
  680.                 {
  681.                     if (!_pMainSplitter)
  682.                     {
  683.                         _pMainSplitter = new SplitterContainer;
  684.                         _pMainSplitter->init(_pPublicInterface->getHinst(), _pPublicInterface->getHSelf());
  685.  
  686.                         Window *pWindow;
  687.                         if (bothActive())
  688.                             pWindow = &_subSplitter;
  689.                         else
  690.                             pWindow = _pDocTab;
  691.  
  692.                         _pMainSplitter->create(pWindow, ScintillaEditView::getUserDefineDlg(), 8, RIGHT_FIX, 45);
  693.                     }
  694.  
  695.                     _pMainWindow = _pMainSplitter;
  696.  
  697.                     _pMainSplitter->setWin0((bothActive())?(Window *)&_subSplitter:(Window *)_pDocTab);
  698.  
  699.                     ::SendMessage(_pPublicInterface->getHSelf(), WM_SIZE, 0, 0);
  700.                     _pMainWindow->display();
  701.  
  702.                     _mainWindowStatus |= WindowUserActive;
  703.                 }
  704.                 else if ((!isUDDlgDocked)&&(isUDDlgVisible))
  705.                 {
  706.                     udd->display(false);
  707.                 }
  708.                 else //((!isUDDlgDocked)&&(!isUDDlgVisible))
  709.                     udd->display();
  710.             }
  711.             checkMenuItem(IDM_VIEW_USER_DLG, !isUDDlgVisible);
  712.             _toolBar.setCheck(IDM_VIEW_USER_DLG, !isUDDlgVisible);
  713.  
  714.             break;
  715.         }
  716.  
  717.         case IDM_EDIT_SELECTALL:
  718.             _pEditView->execute(SCI_SELECTALL);
  719.             checkClipboard();
  720.             break;
  721.  
  722.         case IDM_EDIT_INS_TAB:
  723.             _pEditView->execute(SCI_TAB);
  724.             break;
  725.  
  726.         case IDM_EDIT_RMV_TAB:
  727.             _pEditView->execute(SCI_BACKTAB);
  728.             break;
  729.  
  730.         case IDM_EDIT_DUP_LINE:
  731.             _pEditView->execute(SCI_LINEDUPLICATE);
  732.             break;
  733.  
  734.         case IDM_EDIT_SPLIT_LINES:
  735.             _pEditView->execute(SCI_TARGETFROMSELECTION);
  736.             _pEditView->execute(SCI_LINESSPLIT);
  737.             break;
  738.  
  739.         case IDM_EDIT_JOIN_LINES:
  740.             _pEditView->execute(SCI_TARGETFROMSELECTION);
  741.             _pEditView->execute(SCI_LINESJOIN);
  742.             break;
  743.  
  744.         case IDM_EDIT_LINE_UP:
  745.             _pEditView->currentLinesUp();
  746.             break;
  747.  
  748.         case IDM_EDIT_LINE_DOWN:
  749.             _pEditView->currentLinesDown();
  750.             break;
  751.  
  752.         case IDM_EDIT_UPPERCASE:
  753.             _pEditView->convertSelectedTextToUpperCase();
  754.             break;
  755.  
  756.         case IDM_EDIT_LOWERCASE:
  757.             _pEditView->convertSelectedTextToLowerCase();
  758.             break;
  759.  
  760.         case IDM_EDIT_BLOCK_COMMENT:
  761.             doBlockComment(cm_toggle);
  762.             break;
  763.  
  764.         case IDM_EDIT_BLOCK_COMMENT_SET:
  765.             doBlockComment(cm_comment);
  766.             break;
  767.  
  768.         case IDM_EDIT_BLOCK_UNCOMMENT:
  769.             doBlockComment(cm_uncomment);
  770.             break;
  771.  
  772.         case IDM_EDIT_STREAM_COMMENT:
  773.             doStreamComment();
  774.             break;
  775.  
  776.         case IDM_EDIT_TRIMTRAILING:
  777.             _pEditView->execute(SCI_BEGINUNDOACTION);
  778.             doTrim(lineTail);
  779.             _pEditView->execute(SCI_ENDUNDOACTION);
  780.             break;
  781.  
  782.         case IDM_EDIT_TRIMLINEHEAD:
  783.             _pEditView->execute(SCI_BEGINUNDOACTION);
  784.             doTrim(lineHeader);
  785.             _pEditView->execute(SCI_ENDUNDOACTION);
  786.             break;
  787.  
  788.         case IDM_EDIT_TRIM_BOTH:
  789.             _pEditView->execute(SCI_BEGINUNDOACTION);
  790.             doTrim(lineTail);
  791.             doTrim(lineHeader);
  792.             _pEditView->execute(SCI_ENDUNDOACTION);
  793.             break;
  794.  
  795.         case IDM_EDIT_EOL2WS:
  796.             _pEditView->execute(SCI_BEGINUNDOACTION);
  797.             _pEditView->execute(SCI_SETTARGETSTART, 0);
  798.             _pEditView->execute(SCI_SETTARGETEND, _pEditView->getCurrentDocLen());
  799.             _pEditView->execute(SCI_LINESJOIN);
  800.             _pEditView->execute(SCI_ENDUNDOACTION);
  801.             break;
  802.  
  803.         case IDM_EDIT_TRIMALL:
  804.             _pEditView->execute(SCI_BEGINUNDOACTION);
  805.             doTrim(lineTail);
  806.             doTrim(lineHeader);
  807.             _pEditView->execute(SCI_SETTARGETSTART, 0);
  808.             _pEditView->execute(SCI_SETTARGETEND, _pEditView->getCurrentDocLen());
  809.             _pEditView->execute(SCI_LINESJOIN);
  810.             _pEditView->execute(SCI_ENDUNDOACTION);
  811.             break;
  812.  
  813.         case IDM_EDIT_TAB2SW:
  814.             wsTabConvert(true);
  815.             break;
  816.  
  817.         case IDM_EDIT_SW2TAB:
  818.             wsTabConvert(false);
  819.             break;
  820.  
  821.         case IDM_EDIT_SETREADONLY:
  822.         {
  823.             Buffer * buf = _pEditView->getCurrentBuffer();
  824.             buf->setUserReadOnly(!buf->getUserReadOnly());
  825.         }
  826.         break;
  827.  
  828.         case IDM_EDIT_CLEARREADONLY:
  829.         {
  830.             Buffer * buf = _pEditView->getCurrentBuffer();
  831.            
  832.             DWORD dwFileAttribs = ::GetFileAttributes(buf->getFullPathName());
  833.             dwFileAttribs ^= FILE_ATTRIBUTE_READONLY;
  834.  
  835.             ::SetFileAttributes(buf->getFullPathName(), dwFileAttribs);
  836.             buf->setFileReadOnly(false);
  837.         }
  838.         break;
  839.  
  840.         case IDM_SEARCH_CUTMARKEDLINES :
  841.             cutMarkedLines();
  842.             break;
  843.  
  844.         case IDM_SEARCH_COPYMARKEDLINES :
  845.             copyMarkedLines();
  846.             break;
  847.  
  848.         case IDM_SEARCH_PASTEMARKEDLINES :
  849.             pasteToMarkedLines();
  850.             break;
  851.  
  852.         case IDM_SEARCH_DELETEMARKEDLINES :
  853.             deleteMarkedLines(true);
  854.             break;
  855.  
  856.         case IDM_SEARCH_DELETEUNMARKEDLINES :
  857.             deleteMarkedLines(false);
  858.             break;
  859.  
  860.         case IDM_SEARCH_INVERSEMARKS :
  861.             inverseMarks();
  862.             break;
  863.  
  864.         case IDM_VIEW_FULLSCREENTOGGLE :
  865.             fullScreenToggle();
  866.             break;
  867.  
  868.         case IDM_VIEW_ALWAYSONTOP:
  869.         {
  870.             int check = (::GetMenuState(_mainMenuHandle, id, MF_BYCOMMAND) == MF_CHECKED)?MF_UNCHECKED:MF_CHECKED;
  871.             ::CheckMenuItem(_mainMenuHandle, id, MF_BYCOMMAND | check);
  872.             SetWindowPos(_pPublicInterface->getHSelf(), check == MF_CHECKED?HWND_TOPMOST:HWND_NOTOPMOST, 0, 0, 0, 0, SWP_NOMOVE|SWP_NOSIZE);
  873.         }
  874.         break;
  875.  
  876.  
  877.         case IDM_VIEW_FOLD_CURRENT :
  878.         case IDM_VIEW_UNFOLD_CURRENT :
  879.             _pEditView->foldCurrentPos((id==IDM_VIEW_FOLD_CURRENT)?fold_collapse:fold_uncollapse);
  880.             break;
  881.  
  882.         case IDM_VIEW_TOGGLE_FOLDALL:
  883.         case IDM_VIEW_TOGGLE_UNFOLDALL:
  884.         {
  885.             _pEditView->foldAll((id==IDM_VIEW_TOGGLE_FOLDALL)?fold_collapse:fold_uncollapse);
  886.         }
  887.         break;
  888.  
  889.         case IDM_VIEW_FOLD_1:
  890.         case IDM_VIEW_FOLD_2:
  891.         case IDM_VIEW_FOLD_3:
  892.         case IDM_VIEW_FOLD_4:
  893.         case IDM_VIEW_FOLD_5:
  894.         case IDM_VIEW_FOLD_6:
  895.         case IDM_VIEW_FOLD_7:
  896.         case IDM_VIEW_FOLD_8:
  897.             _pEditView->collapse(id - IDM_VIEW_FOLD - 1, fold_collapse);
  898.             break;
  899.  
  900.         case IDM_VIEW_UNFOLD_1:
  901.         case IDM_VIEW_UNFOLD_2:
  902.         case IDM_VIEW_UNFOLD_3:
  903.         case IDM_VIEW_UNFOLD_4:
  904.         case IDM_VIEW_UNFOLD_5:
  905.         case IDM_VIEW_UNFOLD_6:
  906.         case IDM_VIEW_UNFOLD_7:
  907.         case IDM_VIEW_UNFOLD_8:
  908.             _pEditView->collapse(id - IDM_VIEW_UNFOLD - 1, fold_uncollapse);
  909.             break;
  910.  
  911.  
  912.         case IDM_VIEW_TOOLBAR_REDUCE:
  913.         {
  914.             toolBarStatusType state = _toolBar.getState();
  915.  
  916.             if (state != TB_SMALL)
  917.             {
  918.                 _toolBar.reduce();
  919.                 changeToolBarIcons();
  920.             }
  921.         }
  922.         break;
  923.  
  924.         case IDM_VIEW_TOOLBAR_ENLARGE:
  925.         {
  926.             toolBarStatusType state = _toolBar.getState();
  927.  
  928.             if (state != TB_LARGE)
  929.             {
  930.                 _toolBar.enlarge();
  931.                 changeToolBarIcons();
  932.             }
  933.         }
  934.         break;
  935.  
  936.         case IDM_VIEW_TOOLBAR_STANDARD:
  937.         {
  938.             toolBarStatusType state = _toolBar.getState();
  939.  
  940.             if (state != TB_STANDARD)
  941.             {
  942.                 _toolBar.setToUglyIcons();
  943.             }
  944.         }
  945.         break;
  946.  
  947.         case IDM_VIEW_REDUCETABBAR :
  948.         {
  949.             _toReduceTabBar = !_toReduceTabBar;
  950.  
  951.             //Resize the  icon
  952.             int iconSize = _toReduceTabBar?12:18;
  953.  
  954.             //Resize the tab height
  955.             int tabHeight = _toReduceTabBar?20:25;
  956.             TabCtrl_SetItemSize(_mainDocTab.getHSelf(), 45, tabHeight);
  957.             TabCtrl_SetItemSize(_subDocTab.getHSelf(), 45, tabHeight);
  958.             _docTabIconList.setIconSize(iconSize);
  959.  
  960.             //change the font
  961.             int stockedFont = _toReduceTabBar?DEFAULT_GUI_FONT:SYSTEM_FONT;
  962.             HFONT hf = (HFONT)::GetStockObject(stockedFont);
  963.  
  964.             if (hf)
  965.             {
  966.                 ::SendMessage(_mainDocTab.getHSelf(), WM_SETFONT, (WPARAM)hf, MAKELPARAM(TRUE, 0));
  967.                 ::SendMessage(_subDocTab.getHSelf(), WM_SETFONT, (WPARAM)hf, MAKELPARAM(TRUE, 0));
  968.             }
  969.  
  970.             ::SendMessage(_pPublicInterface->getHSelf(), WM_SIZE, 0, 0);
  971.             break;
  972.         }
  973.        
  974.         case IDM_VIEW_REFRESHTABAR :
  975.         {
  976.             ::SendMessage(_pPublicInterface->getHSelf(), WM_SIZE, 0, 0);
  977.             break;
  978.         }
  979.         case IDM_VIEW_LOCKTABBAR:
  980.         {
  981.             bool isDrag = TabBarPlus::doDragNDropOrNot();
  982.             TabBarPlus::doDragNDrop(!isDrag);
  983.             //checkMenuItem(IDM_VIEW_LOCKTABBAR, isDrag);
  984.             break;
  985.         }
  986.  
  987.  
  988.         case IDM_VIEW_DRAWTABBAR_INACIVETAB:
  989.         {
  990.             TabBarPlus::setDrawInactiveTab(!TabBarPlus::drawInactiveTab());
  991.             //TabBarPlus::setDrawInactiveTab(!TabBarPlus::drawInactiveTab(), _subDocTab.getHSelf());
  992.             break;
  993.         }
  994.         case IDM_VIEW_DRAWTABBAR_TOPBAR:
  995.         {
  996.             TabBarPlus::setDrawTopBar(!TabBarPlus::drawTopBar());
  997.             break;
  998.         }
  999.  
  1000.         case IDM_VIEW_DRAWTABBAR_CLOSEBOTTUN :
  1001.         {
  1002.             TabBarPlus::setDrawTabCloseButton(!TabBarPlus::drawTabCloseButton());
  1003.  
  1004.             // This part is just for updating (redraw) the tabs
  1005.             {
  1006.                 int tabHeight = TabBarPlus::drawTabCloseButton()?21:20;
  1007.                 TabCtrl_SetItemSize(_mainDocTab.getHSelf(), 45, tabHeight);
  1008.                 TabCtrl_SetItemSize(_subDocTab.getHSelf(), 45, tabHeight);
  1009.             }
  1010.             ::SendMessage(_pPublicInterface->getHSelf(), WM_SIZE, 0, 0);
  1011.             break;
  1012.         }
  1013.  
  1014.         case IDM_VIEW_DRAWTABBAR_DBCLK2CLOSE :
  1015.         {
  1016.             TabBarPlus::setDbClk2Close(!TabBarPlus::isDbClk2Close());
  1017.             break;
  1018.         }
  1019.        
  1020.         case IDM_VIEW_DRAWTABBAR_VERTICAL :
  1021.         {
  1022.             TabBarPlus::setVertical(!TabBarPlus::isVertical());
  1023.             ::SendMessage(_pPublicInterface->getHSelf(), WM_SIZE, 0, 0);
  1024.             break;
  1025.         }
  1026.        
  1027.         case IDM_VIEW_DRAWTABBAR_MULTILINE :
  1028.         {
  1029.             TabBarPlus::setMultiLine(!TabBarPlus::isMultiLine());
  1030.             ::SendMessage(_pPublicInterface->getHSelf(), WM_SIZE, 0, 0);       
  1031.             break;
  1032.         }
  1033.  
  1034.         case IDM_VIEW_POSTIT :
  1035.         {
  1036.             postItToggle();
  1037.         }
  1038.         break;
  1039.  
  1040.         case IDM_VIEW_TAB_SPACE:
  1041.         {
  1042.             bool isChecked = !(::GetMenuState(_mainMenuHandle, IDM_VIEW_TAB_SPACE, MF_BYCOMMAND) == MF_CHECKED);
  1043.             ::CheckMenuItem(_mainMenuHandle, IDM_VIEW_EOL, MF_BYCOMMAND | MF_UNCHECKED);
  1044.             ::CheckMenuItem(_mainMenuHandle, IDM_VIEW_ALL_CHARACTERS, MF_BYCOMMAND | MF_UNCHECKED);
  1045.             ::CheckMenuItem(_mainMenuHandle, IDM_VIEW_TAB_SPACE, MF_BYCOMMAND | (isChecked?MF_CHECKED:MF_UNCHECKED));
  1046.             _toolBar.setCheck(IDM_VIEW_ALL_CHARACTERS, false);
  1047.             _mainEditView.showEOL(false);
  1048.             _mainEditView.showWSAndTab(isChecked);
  1049.             _subEditView.showEOL(false);
  1050.             _subEditView.showWSAndTab(isChecked);
  1051.  
  1052.             ScintillaViewParams & svp1 = (ScintillaViewParams &)(NppParameters::getInstance())->getSVP();
  1053.             svp1._whiteSpaceShow = isChecked;
  1054.             svp1._eolShow = false;
  1055.             break;
  1056.         }
  1057.         case IDM_VIEW_EOL:
  1058.         {
  1059.             bool isChecked = !(::GetMenuState(_mainMenuHandle, IDM_VIEW_EOL, MF_BYCOMMAND) == MF_CHECKED);
  1060.             ::CheckMenuItem(_mainMenuHandle, IDM_VIEW_TAB_SPACE, MF_BYCOMMAND | MF_UNCHECKED);
  1061.             ::CheckMenuItem(_mainMenuHandle, IDM_VIEW_EOL, MF_BYCOMMAND | (isChecked?MF_CHECKED:MF_UNCHECKED));
  1062.             ::CheckMenuItem(_mainMenuHandle, IDM_VIEW_ALL_CHARACTERS, MF_BYCOMMAND | MF_UNCHECKED);
  1063.             _toolBar.setCheck(IDM_VIEW_ALL_CHARACTERS, false);
  1064.             _mainEditView.showEOL(isChecked);
  1065.             _subEditView.showEOL(isChecked);
  1066.             _mainEditView.showWSAndTab(false);
  1067.             _subEditView.showWSAndTab(false);
  1068.  
  1069.             ScintillaViewParams & svp1 = (ScintillaViewParams &)(NppParameters::getInstance())->getSVP();
  1070.             svp1._whiteSpaceShow = false;
  1071.             svp1._eolShow = isChecked;
  1072.             break;
  1073.         }
  1074.         case IDM_VIEW_ALL_CHARACTERS:
  1075.         {
  1076.             bool isChecked = !(::GetMenuState(_mainMenuHandle, id, MF_BYCOMMAND) == MF_CHECKED);
  1077.             ::CheckMenuItem(_mainMenuHandle, IDM_VIEW_EOL, MF_BYCOMMAND | MF_UNCHECKED);
  1078.             ::CheckMenuItem(_mainMenuHandle, IDM_VIEW_TAB_SPACE, MF_BYCOMMAND | MF_UNCHECKED);
  1079.             ::CheckMenuItem(_mainMenuHandle, IDM_VIEW_ALL_CHARACTERS, MF_BYCOMMAND | (isChecked?MF_CHECKED:MF_UNCHECKED));
  1080.             _mainEditView.showInvisibleChars(isChecked);
  1081.             _subEditView.showInvisibleChars(isChecked);
  1082.             _toolBar.setCheck(IDM_VIEW_ALL_CHARACTERS, isChecked);
  1083.  
  1084.             ScintillaViewParams & svp1 = (ScintillaViewParams &)(NppParameters::getInstance())->getSVP();
  1085.             svp1._whiteSpaceShow = isChecked;
  1086.             svp1._eolShow = isChecked;
  1087.             break;
  1088.         }
  1089.  
  1090.         case IDM_VIEW_INDENT_GUIDE:
  1091.         {
  1092.             _mainEditView.showIndentGuideLine(!_pEditView->isShownIndentGuide());
  1093.             _subEditView.showIndentGuideLine(!_pEditView->isShownIndentGuide());
  1094.             _toolBar.setCheck(IDM_VIEW_INDENT_GUIDE, _pEditView->isShownIndentGuide());
  1095.             checkMenuItem(IDM_VIEW_INDENT_GUIDE, _pEditView->isShownIndentGuide());
  1096.  
  1097.             ScintillaViewParams & svp1 = (ScintillaViewParams &)(NppParameters::getInstance())->getSVP();
  1098.             svp1._indentGuideLineShow = _pEditView->isShownIndentGuide();
  1099.             break;
  1100.         }
  1101.  
  1102.         case IDM_VIEW_WRAP:
  1103.         {
  1104.             bool isWraped = !_pEditView->isWrap();
  1105.             _mainEditView.wrap(isWraped);
  1106.             _subEditView.wrap(isWraped);
  1107.             _toolBar.setCheck(IDM_VIEW_WRAP, isWraped);
  1108.             checkMenuItem(IDM_VIEW_WRAP, isWraped);
  1109.  
  1110.             ScintillaViewParams & svp1 = (ScintillaViewParams &)(NppParameters::getInstance())
Advertisement
Add Comment
Please, Sign In to add comment