GithubStar/notepad--
1
0
Fork 0
mirror of https://github.com/cxasm/notepad--.git synced 2026-10-18 23:00:46 +08:00
Code Issues Packages Projects Releases Wiki Activity
Files
notepad--v1.17
notepad--/findwin.cpp
T
爬山虎 ce21872bee 第一次提交开源。国内请访问gitee
2022-10-27 12:23:36 +08:00

2040 lines
49 KiB
C++
Executable File
Raw Permalink Blame History

#include "findwin.h"
#include "scintillaeditview.h"
#include "ccnotepad.h"
#include "progresswin.h"
#include "doctypelistview.h"
#include "filemanager.h"
#include <QMimeDatabase>
#include <QRadioButton>
#include <QMessageBox>
#include <QFileDialog>
#include <functional>
#include <QDebug>
FindWin::FindWin(QWidget *parent):QMainWindow(parent), m_editTabWidget(nullptr), m_isFindFirst(true), m_findHistory(nullptr), \
pEditTemp(nullptr), m_curEditWin(nullptr), m_isStatic(false)
{
ui.setupUi(this);
m_BackwardDir = false;
m_matchWhole = false;
m_matchCase = false;
m_matchWrap = true;
m_extend = false;
m_searchMode = 1;
connect(ui.findModeRegularBt, &QRadioButton::toggled, this, &FindWin::slot_findModeRegularBtChange);
connect(ui.replaceModeRegularBt, &QRadioButton::toggled, this, &FindWin::slot_replaceModeRegularBtChange);
connect(ui.dealFileType, &QCheckBox::stateChanged, this,&FindWin::slot_dealFileTypeChange);
connect(ui.clearBt, &QAbstractButton::clicked, this, &FindWin::sign_clearResult);
connect(ui.findClearBt, &QAbstractButton::clicked, this, &FindWin::sign_clearResult);
#if 0 //这样是无效的，记住一下，不删除，避免后面再做无用功
Qt::WindowFlags m_flags = windowFlags();
//这样使得窗口在上面，不至于总是到后面被挡住。
#if defined (Q_MAC_OS)
setWindowFlags(m_flags | Qt::WindowStaysOnTopHint);
#endif
#endif
raise();
setFocusPolicy(Qt::StrongFocus);
setFocus();
ui.findinfilesTab->setAttribute(Qt::WA_StyledBackground);
}
FindWin::~FindWin()
{
m_findHistory = nullptr;
if (pEditTemp != nullptr)
{
delete pEditTemp;
pEditTemp = nullptr;
}
}
void FindWin::slot_dealFileTypeChange(int state)
{
if (state == Qt::Checked)
{
ui.fileType->setEnabled(true);
}
else
{
ui.fileType->setEnabled(false);
}
}
//自动调整当前窗口的状态，如果发生了变化，则需要认定为是首次查找
QWidget* FindWin::autoAdjustCurrentEditWin()
{
QWidget* pw = m_editTabWidget->currentWidget();
if (m_curEditWin != pw)
{
m_curEditWin = pw;
m_isFindFirst = true;
}
return pw;
}
void FindWin::setCurrentTab(FindTabIndex index)
{
ui.findinfilesTab->setCurrentIndex(index);
if (FIND_TAB == index)
{
ui.findComboBox->setFocus();
}
else
{
ui.replaceTextBox->setFocus();
}
raise();
}
void FindWin::setTabWidget(QTabWidget *editTabWidget)
{
m_editTabWidget = editTabWidget;
}
void FindWin::setFindText(QString &text)
{
ui.findComboBox->setEditText(text);
ui.replaceTextBox->setEditText(text);
ui.markTextBox->setEditText(text);
ui.dirFindWhat->setEditText(text);
addFindHistory(text);
}
void FindWin::disableReplace()
{
ui.tab_replace->setEnabled(false);
}
void FindWin::setFindHistory(QList<QString>* findHistory)
{
m_findHistory = findHistory;
if ((m_findHistory != nullptr) && !m_findHistory->isEmpty())
{
ui.findComboBox->addItems(*m_findHistory);
ui.replaceTextBox->addItems(*m_findHistory);
ui.dirFindWhat->addItems(*m_findHistory);
ui.findComboBox->clearEditText();
ui.replaceTextBox->clearEditText();
}
}
//标记高亮所有word单词
void FindWin::markAllWord(QString & word)
{
ui.markTextBox->setCurrentText(word);
ui.findinfilesTab->setCurrentIndex(3);
//发现中文在全词匹配下面不能匹配到单词。最好是英文全词匹配，中文不需要
//但是好像没有一个现成的方法来判断word中的字符。暂时不做全词匹配
ui.markMatchWholeBox->setChecked(false);
ui.markMatchCaseBox->setChecked(true);
slot_markAll();
}
//删除行首尾的空白字符
void FindWin::removeLineHeadEndBlank(int mode)
{
QWidget* pw = autoAdjustCurrentEditWin();
ScintillaEditView* pEdit = dynamic_cast<ScintillaEditView*>(pw);
if (pEdit != nullptr)
{
if (pEdit->isReadOnly())
{
ui.statusbar->showMessage(tr("The ReadOnly document does not allow this operation."), 8000);
QApplication::beep();
return;
}
ui.findinfilesTab->setCurrentIndex(1);
if (mode == 1)
{
ui.replaceTextBox->setCurrentText("^\\s+");
}
else if (mode == 2)
{
ui.replaceTextBox->setCurrentText("\\s+$");
}
ui.replaceWithBox->setCurrentText("");
ui.replaceModeRegularBt->setChecked(true);
m_isStatic = true;
slot_replaceAll();
m_isStatic = false;
}
}
void FindWin::focusInEvent(QFocusEvent * ev)
{
QWidget::focusInEvent(ev);
setWindowOpacity(1.0);
}
void FindWin::focusOutEvent(QFocusEvent * ev)
{
QWidget::focusOutEvent(ev);
if (this->isActiveWindow())
{
//当前还是活动窗口，不设置透明
return;
}
else
{
setWindowOpacity(0.6);
//static int i = 0;
//qDebug() << ++i;
}
}
#if 0
bool FindWin::eventFilter(QObject* watched, QEvent *event)
{
if (event->type() == QEvent::FocusIn)
{
setWindowOpacity(1.0);
static int j = 0;
qDebug() << "get" << ++j;
}
else if (event->type() == QEvent::FocusOut)
{
setWindowOpacity(0.6);
static int i = 0;
qDebug() << "out" << ++i;
}
return QWidget::eventFilter(watched, event); // 最后将事件交给上层对话框
}
#endif
//从ui读取参数配置到成员变量
void FindWin::updateParameterFromUI()
{
bool extend = false;
if (ui.findinfilesTab->currentIndex() == 0)
{
int searchMode = 0;
if (ui.findModeNormalBt->isChecked())
{
searchMode = 1;
extend = false;
}
else if (ui.findModeRegularBt->isChecked())
{
searchMode = 2;
extend = false;
}
else if (ui.findModeExtendBt->isChecked())
{
searchMode = 1;
extend = true;
}
if (m_searchMode != searchMode)
{
m_searchMode = searchMode;
m_isFindFirst = true;
}
if (m_expr != ui.findComboBox->currentText())
{
m_expr = ui.findComboBox->currentText();
m_isFindFirst = true;
}
if (m_BackwardDir != ui.findBackwardBox->isChecked())
{
m_BackwardDir = ui.findBackwardBox->isChecked();
m_isFindFirst = true;
}
if (m_matchWhole != ui.findMatchWholeBox->isChecked())
{
m_matchWhole = ui.findMatchWholeBox->isChecked();
m_isFindFirst = true;
}
if (m_matchCase != ui.findMatchCaseBox->isChecked())
{
m_matchCase = ui.findMatchCaseBox->isChecked();
m_isFindFirst = true;
}
if (m_matchWrap != ui.findWrapBox->isChecked())
{
m_matchWrap = ui.findWrapBox->isChecked();
m_isFindFirst = true;
}
}
else if (ui.findinfilesTab->currentIndex() == 1)
{
int searchMode = 0;
if (ui.replaceModeNormalBox->isChecked())
{
searchMode = 1;
extend = false;
}
else if (ui.replaceModeRegularBt->isChecked())
{
searchMode = 2;
extend = false;
}
else if (ui.replaceModeExtendBox->isChecked())
{
searchMode = 1;
extend = true;
}
if (m_searchMode != searchMode)
{
m_searchMode = searchMode;
m_isFindFirst = true;
}
if (m_expr != ui.replaceTextBox->currentText())
{
m_expr = ui.replaceTextBox->currentText();
m_isFindFirst = true;
}
if (m_replaceWithText != ui.replaceWithBox->currentText())
{
m_replaceWithText = ui.replaceWithBox->currentText();
m_isFindFirst = true;
}
if (m_BackwardDir != ui.replaceBackwardBox->isChecked())
{
m_BackwardDir = ui.replaceBackwardBox->isChecked();
m_isFindFirst = true;
}
if (m_matchWhole != ui.replaceMatchWholeBox->isChecked())
{
m_matchWhole = ui.replaceMatchWholeBox->isChecked();
m_isFindFirst = true;
}
if (m_matchCase != ui.replaceMatchCaseBox->isChecked())
{
m_matchCase = ui.replaceMatchCaseBox->isChecked();
m_isFindFirst = true;
}
if (m_matchWrap != ui.replaceWrapBox->isChecked())
{
m_matchWrap = ui.replaceWrapBox->isChecked();
m_isFindFirst = true;
}
}
else if (ui.findinfilesTab->currentIndex() == 2)
{
int searchMode = 0;
if (ui.dirFindModeNormalBox->isChecked())
{
searchMode = 1;
extend = false;
}
else if (ui.dirFindModeRegularBt->isChecked())
{
searchMode = 2;
extend = false;
}
else if (ui.dirFindModeExtendBox->isChecked())
{
searchMode = 1;
extend = true;
}
if (m_searchMode != searchMode)
{
m_searchMode = searchMode;
m_isFindFirst = true;
}
if (m_expr != ui.dirFindWhat->currentText())
{
m_expr = ui.dirFindWhat->currentText();
m_isFindFirst = true;
}
if (m_replaceWithText != ui.dirReplaceWhat->currentText())
{
m_replaceWithText = ui.dirReplaceWhat->currentText();
m_isFindFirst = true;
}
m_BackwardDir = false;
if (m_matchWhole != ui.dirFindMatchWholeBox->isChecked())
{
m_matchWhole = ui.dirFindMatchWholeBox->isChecked();
m_isFindFirst = true;
}
if (m_matchCase != ui.dirFindMatchCaseBox->isChecked())
{
m_matchCase = ui.dirFindMatchCaseBox->isChecked();
m_isFindFirst = true;
}
m_matchWrap = true;
}
else if (ui.findinfilesTab->currentIndex() == 3)
{
int searchMode = 0;
if (ui.markModeNormalBox->isChecked())
{
searchMode = 1;
extend = false;
}
else if (ui.markModeRegularBt->isChecked())
{
searchMode = 2;
extend = false;
}
else if (ui.markModeExtendBox->isChecked())
{
searchMode = 1;
extend = true;
}
if (m_searchMode != searchMode)
{
m_searchMode = searchMode;
m_isFindFirst = true;
}
if (m_expr != ui.markTextBox->currentText())
{
m_expr = ui.markTextBox->currentText();
m_isFindFirst = true;
}
m_BackwardDir = false;
if (m_matchWhole != ui.markMatchWholeBox->isChecked())
{
m_matchWhole = ui.markMatchWholeBox->isChecked();
m_isFindFirst = true;
}
if (m_matchCase != ui.markMatchCaseBox->isChecked())
{
m_matchCase = ui.markMatchCaseBox->isChecked();
m_isFindFirst = true;
}
m_matchWrap = true;
}
m_re = ((m_searchMode == 2) ? true : false);
if (m_cs != m_matchCase)
{
m_cs = m_matchCase;
}
if (m_wo != m_matchWhole)
{
m_wo = m_matchWhole;
}
if (m_wrap != m_matchWrap)
{
m_wrap = m_matchWrap;
}
if (m_extend != extend)
{
m_extend = extend;
m_isFindFirst = true;
}
m_forward = !m_BackwardDir;
}
void FindWin::addFindHistory(QString &text)
{
if ((m_findHistory != nullptr) && (-1 == m_findHistory->indexOf(text)))
{
m_findHistory->push_front(text);
if (m_findHistory->size() >= 15)
{
m_findHistory->takeLast();
}
ui.findComboBox->insertItem(0, text);
ui.replaceTextBox->insertItem(0, text);
ui.dirFindWhat->insertItem(0,text);
ui.markTextBox->insertItem(0, text);
}
}
//检查是否是第一次查找，凡是参数变化了，则认定为是第一次查找。
//因为查找分firstFirst和firstNext，则是qscint特性决定的。所以正确识别第一次查找是必要的
bool FindWin::isFirstFind()
{
return m_isFindFirst;
}
//const QChar *constData() const
bool readBase(const QChar * str, int * value, int base, int size)
{
int i = 0, temp = 0;
*value = 0;
QChar max = QChar(QChar('0').digitValue() + base - 1);
QChar current;
while (i < size)
{
current = str[i];
if (current >= 'A')
{
current = current.digitValue() & 0xdf;
current = current.digitValue() - ('A' - '0' - 10);
}
else if (current > '9')
return false;
if (current >= '0' && current <= max)
{
temp *= base;
temp += (current.digitValue() - '0');
}
else
{
return false;
}
++i;
}
*value = temp;
return true;
}
int convertExtendedToString(QString& query, QString &result)
{ //query may equal to result, since it always gets smaller
int i = 0, j = 0;
int length = query.length();
int charLeft = length;
QChar current;
while (i < length)
{ //because the backslash escape quences always reduce the size of the generic_string, no overflow checks have to be made for target, assuming parameters are correct
current = query.at(i);
--charLeft;
if (current == '\\' && charLeft)
{ //possible escape sequence
++i;
--charLeft;
current = query.at(i);
switch (current.toLatin1())
{
case 'r':
result[j] = '\r';
break;
case 'n':
result[j] = '\n';
break;
case '0':
result[j] = '\0';
break;
case 't':
result[j] = '\t';
break;
case '\\':
result[j] = '\\';
break;
case 'b':
case 'd':
case 'o':
case 'x':
case 'u':
{
int size = 0, base = 0;
if (current == 'b')
{ //11111111
size = 8, base = 2;
}
else if (current == 'o')
{ //377
size = 3, base = 8;
}
else if (current == 'd')
{ //255
size = 3, base = 10;
}
else if (current == 'x')
{ //0xFF
size = 2, base = 16;
}
else if (current == 'u')
{ //0xCDCD
size = 4, base = 16;
}
if (charLeft >= size)
{
int res = 0;
if (readBase(query.constData() + (i + 1), &res, base, size))
{
result[j] = QChar(res);
i += size;
break;
}
}
//not enough chars to make parameter, use default method as fallback
}
default:
{ //unknown sequence, treat as regular text
result[j] = '\\';
++j;
result[j] = current;
break;
}
}
}
else
{
result[j] = query[i];
}
++i;
++j;
}
return j;
}
void FindWin::showCallTip(QsciScintilla* pEdit, int pos)
{
QString zeroString(tr("find-regex-zero-length-match"));
QByteArray bytes = zeroString.toUtf8();
bytes.append('\0');
/*int size = bytes.size();
char* newStr = new char[size + 1];
memcpy(newStr, bytes.data(), size);
newStr[bytes.size()] = '\0';*/
pEdit->SendScintilla(SCI_CALLTIPSHOW, pos, (void*)(bytes.data()));
/*delete[]newStr;*/
}
/*处理查找时零长的问题。一定要处理，否则会死循环，因为每次都在原地查找。
* 就是把下次查找的startpos往前一个，否则每次都从这个startpos找到自己
*/
void FindWin::dealWithZeroFound(QsciScintilla* pEdit)
{
FindState& state = pEdit->getLastFindState();
if (state.targstart == state.targend)
{
//强行加1，否则每次查找总是在同一个地方。
state.startpos++;
}
}
/*处理查找时零长的问题。一定要处理，否则会死循环，因为每次都在原地查找。
* 就是把下次查找的startpos往前一个，否则每次都从这个startpos找到自己
* 和dealWithZeroFound是一样的，就是要显示消息而已
*/
void FindWin::dealWithZeroFoundShowTip(QsciScintilla* pEdit, bool isShowTip)
{
if (!isShowTip)
{
return dealWithZeroFound(pEdit);
}
FindState& state = pEdit->getLastFindState();
ui.statusbar->showMessage(tr("target info linenum %1 pos is %2 - %3").arg(state.linenum + 1).arg(state.targstart).arg(state.targend), 8000);
if (state.targstart == state.targend)
{
//强行加1，否则每次查找总是在同一个地方。
//这里有个问题，如果是反向查找，则应该是pos减去1才对。
//不过只有在正则查找才会出现零长，而正则查找时我们不允许反向查找。反向是回调的。
state.startpos++;
showCallTip(pEdit, state.targstart);
}
}
//一旦修改条件发生变化，则认定为第一次查找
void FindWin::slot_findNext()
{
if (ui.findComboBox->currentText().isEmpty())
{
ui.statusbar->showMessage(tr("what find is null !"), 8000);
QApplication::beep();
return;
}
updateParameterFromUI();
QWidget* pw = autoAdjustCurrentEditWin();
QsciScintilla* pEdit = dynamic_cast<QsciScintilla*>(pw);
//第一次查找
if (isFirstFind())
{
if (pEdit != nullptr)
{
QString whatFind = ui.findComboBox->currentText();
addFindHistory(whatFind);
if (m_extend)
{
QString extendFind;
convertExtendedToString(whatFind, extendFind);
whatFind = extendFind;
}
if (!pEdit->findFirst(whatFind, m_re, m_cs, m_wo, m_wrap, m_forward,-1,-1,true,false,false))
{
ui.statusbar->showMessage(tr("cant't find text \'%1\'").arg(m_expr),8000);
QApplication::beep();
m_isFindFirst = true;
}
else
{
m_isFindFirst = false;
dealWithZeroFoundShowTip(pEdit);
}
}
}
else
{
//查找下一个
if (pEdit != nullptr)
{
if (!pEdit->findNext())
{
ui.statusbar->showMessage(tr("no more find text \'%1\'").arg(m_expr),8000);
QApplication::beep();
}
else
{
dealWithZeroFoundShowTip(pEdit);
}
}
}
}
void FindWin::slot_findCount()
{
}
//去掉行尾的\n\r符号
static QString trimmedEnd(QString lineText)
{
if (lineText.endsWith("\r\n"))
{
return lineText.mid(0, lineText.length()-2);
}
if (lineText.endsWith("\r"))
{
return lineText.mid(0, lineText.length()-1);
}
if (lineText.endsWith("\n"))
{
return lineText.mid(0, lineText.length()-1);
}
return lineText;
}
void FindWin::addCurFindRecord(ScintillaEditView* pEdit, FindRecords& recordRet,bool isMark)
{
FindRecord aRecord;
//看了源码，当前查找到的结果，是会被选中的。所以可通过选中范围，来记录当前被查找中的结果
//光标在选择词的尾部下一个位置
#if 0
aRecord.pos = pEdit->execute(SCI_GETSELECTIONSTART);
aRecord.end = pEdit->execute(SCI_GETSELECTIONEND);
#endif
//加速
FindState& state = pEdit->getLastFindState();
aRecord.pos = state.targstart;
aRecord.end = state.targend;
//mark模式不需要这么多信息，可直接返回
if (!isMark)
{
aRecord.lineNum = pEdit->execute(SCI_LINEFROMPOSITION, aRecord.pos);
aRecord.lineStartPos = pEdit->execute(SCI_POSITIONFROMLINE, aRecord.lineNum);
int lineLens = pEdit->execute(SCI_LINELENGTH, aRecord.lineNum);
if (lineLens <= 0)
{
return;
}
char* lineText = new char[lineLens + 1];
memset(lineText, 0, lineLens + 1);
//这里有个bug,是qscint的，查找最后一行，会漏掉最后一个字符
pEdit->execute(SCI_GETLINE, aRecord.lineNum, reinterpret_cast<sptr_t>(lineText));
//务必要去掉行位的换行，否则显示结果列表会显示换行
aRecord.lineContents = trimmedEnd(QString(lineText));
delete[]lineText;
}
recordRet.records.append(aRecord);
}
void FindWin::slot_findAllInCurDoc()
{
if (ui.findComboBox->currentText().isEmpty())
{
ui.statusbar->showMessage(tr("what find is null !"), 8000);
QApplication::beep();
return;
}
QWidget* pw = autoAdjustCurrentEditWin();
ScintillaEditView* pEdit = dynamic_cast<ScintillaEditView*>(pw);
if (pEdit != nullptr)
{
if (pEdit->isReadOnly())
{
ui.statusbar->showMessage(tr("The ReadOnly document does not allow this operation."), 8000);
QApplication::beep();
return;
}
FindRecords results;
results.pEdit = pEdit;
results.findFilePath = pw->property("filePath").toString();
updateParameterFromUI();
int srcPostion = pEdit->execute(SCI_GETCURRENTPOS);
int firstDisLineNum = pEdit->execute(SCI_GETFIRSTVISIBLELINE);
int replaceNums = 0;
//无条件进行第一次查找，从0行0列开始查找，而且不回环。如果没有找到，则替换完毕
QString whatFind = ui.findComboBox->currentText();
results.findText = whatFind;
//这里不能直接修改results.findText的值，该值在外部显示还需要。如果修改则会显示紊乱
if (m_extend)
{
QString extendFind;
convertExtendedToString(whatFind, extendFind);
whatFind = extendFind;
}
//这里的forward一定要是true。回环一定是false
if (!pEdit->findFirst(whatFind, m_re, m_cs, m_wo, false, true, 0, 0))
{
ui.statusbar->showMessage(tr("cant't find text \'%1\'").arg(m_expr), 8000);
QApplication::beep();
emit sign_findAllInCurDoc(&results);
m_isFindFirst = true;
return;
}
else
{
dealWithZeroFound(pEdit);
}
addCurFindRecord(pEdit, results);
++replaceNums;
//找到了,把结果收集起来
while (pEdit->findNext())
{
addCurFindRecord(pEdit, results);
++replaceNums;
dealWithZeroFound(pEdit);
}
pEdit->execute(SCI_GOTOPOS, srcPostion);
pEdit->execute(SCI_SETFIRSTVISIBLELINE, firstDisLineNum);
pEdit->execute(SCI_SETXOFFSET, 0);
//全部替换后，下次查找，必须算第一次查找
m_isFindFirst = true;
ui.statusbar->showMessage(tr("find finished, total %1 found!").arg(replaceNums), 10000);
emit sign_findAllInCurDoc(&results);
}
else
{
ui.statusbar->showMessage(tr("The mode of the current document does not allow this operation."), 8000);
QApplication::beep();
}
}
void FindWin::slot_findAllInOpenDoc()
{
if (ui.findComboBox->currentText().isEmpty())
{
ui.statusbar->showMessage(tr("what find is null !"), 8000);
QApplication::beep();
return;
}
QString whatFind = ui.findComboBox->currentText();
QString originWhatFine = whatFind;
if (m_extend)
{
QString extendFind;
convertExtendedToString(whatFind, extendFind);
whatFind = extendFind;
}
int replaceNums = 0;
QVector<FindRecords*>* allOpenFileRecord = new QVector<FindRecords*>();
for (int i = 0; i < m_editTabWidget->count(); ++i)
{
QWidget* pw = m_editTabWidget->widget(i);
ScintillaEditView* pEdit = dynamic_cast<ScintillaEditView*>(pw);
if (pEdit != nullptr)
{
if (pEdit->isReadOnly())
{
continue;
}
FindRecords* results = new FindRecords();
results->pEdit = pEdit;
results->findFilePath = pw->property("filePath").toString();
updateParameterFromUI();
//无条件进行第一次查找，从0行0列开始查找，而且不回环。如果没有找到，则替换完毕
//results->findText要是有原来的值，因为扩展模式下\r\n不会转义，直接输出会换行显示
results->findText = originWhatFine;
if (!pEdit->findFirst(whatFind, m_re, m_cs, m_wo, false, true, 0, 0))
{
delete results;
continue;
}
else
{
dealWithZeroFound(pEdit);
}
addCurFindRecord(pEdit, *results);
++replaceNums;
//找到了,把结果收集起来
while (pEdit->findNext())
{
addCurFindRecord(pEdit, *results);
++replaceNums;
dealWithZeroFound(pEdit);
}
allOpenFileRecord->append(results);
}
}
//全部替换后，下次查找，必须算第一次查找
m_isFindFirst = true;
ui.statusbar->showMessage(tr("find finished, total %1 found!").arg(replaceNums), 10000);
emit sign_findAllInOpenDoc(allOpenFileRecord, replaceNums, whatFind);
//释放元素
for (int i = 0; i < allOpenFileRecord->size(); ++i)
{
delete allOpenFileRecord->at(i);
}
delete allOpenFileRecord;
}
//返回是否查找得到内容
bool FindWin::replaceFindNext(QsciScintilla* pEdit, bool showZeroFindTip)
{
m_isFound = false;
//第一次查找
if (m_isFindFirst)
{
if (pEdit != nullptr)
{
QString whatFind = ui.replaceTextBox->currentText();
addFindHistory(whatFind);
if (m_extend)
{
QString extendFind;
convertExtendedToString(whatFind, extendFind);
whatFind = extendFind;
}
if (!pEdit->findFirst(whatFind, m_re, m_cs, m_wo, m_wrap, m_forward))
{
ui.statusbar->showMessage(tr("cant't find text \'%1\'").arg(m_expr), 8000);
QApplication::beep();
m_isFindFirst = true;
}
else
{
m_isFound = true;
m_isFindFirst = false;
dealWithZeroFoundShowTip(pEdit, showZeroFindTip);
}
}
}
else
{
//查找下一个
if (pEdit != nullptr)
{
if (!pEdit->findNext())
{
ui.statusbar->showMessage(tr("no more find text \'%1\'").arg(m_expr), 8000);
QApplication::beep();
}
else
{
m_isFound = true;
dealWithZeroFoundShowTip(pEdit, showZeroFindTip);
}
}
}
return m_isFound;
}
void FindWin::slot_replaceFindNext()
{
if (ui.replaceTextBox->currentText().isEmpty())
{
ui.statusbar->showMessage(tr("what find is null !"), 8000);
QApplication::beep();
return;
}
updateParameterFromUI();
QWidget* pw = autoAdjustCurrentEditWin();
QsciScintilla* pEdit = dynamic_cast<QsciScintilla*>(pw);
replaceFindNext(pEdit, true);
}
//返回值：是否还可以继续替换
bool FindWin::replace(ScintillaEditView* pEdit)
{
if (isFirstFind())
{
replaceFindNext(pEdit, false);
//如果没有找到，则不替换
if (!m_isFound)
{
return false;
}
}
QString findText = ui.replaceTextBox->currentText();
QString replaceText = ui.replaceWithBox->currentText();
if (m_extend)
{
QString extendFind;
convertExtendedToString(findText, extendFind);
findText = extendFind;
QString extendReplace;
convertExtendedToString(replaceText, extendReplace);
replaceText = extendReplace;
}
//当前有选中内容，而且与待替换内容一样，则直接替换
if (m_isFound && pEdit->hasSelectedText())
{
//如果选中内容，与待查找替换的内容一致，进行替换。前提是在normal模式下
if ((m_searchMode == 1) && (pEdit->selectedText().compare(findText, (m_cs ? Qt::CaseSensitive : Qt::CaseInsensitive)) == 0))
{
pEdit->replace(replaceText);
return replaceFindNext(pEdit,false);
}
else if (m_searchMode == 2)
{
//如果是正则表达式模式，则不能使用全部匹配才替换，要使用正则匹配，那样会比较麻烦
//只有上次查找成功，才替换？
if (m_isFound)
{
pEdit->replace(replaceText);
return replaceFindNext(pEdit,false);
}
else
{
ui.statusbar->showMessage(tr("no more replace text \'%1\'").arg(m_expr), 8000);
QApplication::beep();
return false;
}
}
else
{
ui.statusbar->showMessage(tr("no more replace text \'%1\'").arg(m_expr), 8000);
QApplication::beep();
return false;
}
}
else if (m_isFound && m_searchMode == 2)
{
//找到了内容，但是因为是0长，而无法选中。这种情况就是0长的情况。只在正则表达式情况出现
pEdit->replace(replaceText);
//每次替换后，因为是0长替换，再把下次查找位置加1，否则会一直在原地查找
dealWithZeroFound(pEdit);
return replaceFindNext(pEdit,false);
}
//当前没有查找到
return replaceFindNext(pEdit,false);
}
//把当前选中的内容，使用文本替换掉
void FindWin::slot_replace()
{
if (ui.replaceTextBox->currentText().isEmpty())
{
ui.statusbar->showMessage(tr("what find is null !"), 8000);
QApplication::beep();
return;
}
QWidget* pw = autoAdjustCurrentEditWin();
ScintillaEditView* pEdit = dynamic_cast<ScintillaEditView*>(pw);
if (pEdit != nullptr)
{
if (pEdit->isReadOnly())
{
ui.statusbar->showMessage(tr("The ReadOnly document does not allow replacement."), 8000);
QApplication::beep();
return;
}
//切换查询条件后，则是第一次查找。防止前后查找条件发生了变化，
//导致选中的内容不是需要替换的，所以检查是第一次查找，则查找一下
updateParameterFromUI();
replace(pEdit);
}
else
{
ui.statusbar->showMessage(tr("The mode of the current document does not allow replacement."), 8000);
QApplication::beep();
}
}
void FindWin::slot_findModeRegularBtChange(bool checked)
{
if (checked)
{
ui.findBackwardBox->setEnabled(false);
ui.findBackwardBox->setChecked(false);
ui.findMatchWholeBox->setEnabled(false);
ui.findMatchWholeBox->setChecked(false);
}
else
{
ui.findBackwardBox->setEnabled(true);
ui.findMatchWholeBox->setEnabled(true);
}
m_isFindFirst = true;
}
void FindWin::slot_replaceModeRegularBtChange(bool checked)
{
if (checked)
{
ui.replaceBackwardBox->setEnabled(false);
ui.replaceBackwardBox->setChecked(false);
ui.replaceMatchWholeBox->setEnabled(false);
ui.replaceMatchWholeBox->setChecked(false);
}
else
{
ui.replaceBackwardBox->setEnabled(true);
ui.replaceMatchWholeBox->setEnabled(true);
}
m_isFindFirst = true;
}
//替换当前文档里面的所有
void FindWin::slot_replaceAll()
{
if (ui.replaceTextBox->currentText().isEmpty())
{
ui.statusbar->showMessage(tr("what find is null !"), 8000);
return;
}
if (!m_isStatic && QMessageBox::Yes != QMessageBox::question(this, tr("Replace All current Doc"), tr("Are you sure replace all occurrences in current documents?")))
{
return;
}
QWidget* pw = autoAdjustCurrentEditWin();
ScintillaEditView* pEdit = dynamic_cast<ScintillaEditView*>(pw);
if (pEdit != nullptr)
{
if (pEdit->isReadOnly())
{
ui.statusbar->showMessage(tr("The ReadOnly document does not allow replacement."), 8000);
QApplication::beep();
return;
}
updateParameterFromUI();
int srcPostion = pEdit->execute(SCI_GETCURRENTPOS);
int firstDisLineNum = pEdit->execute(SCI_GETFIRSTVISIBLELINE);
int replaceNums = 0;
//无条件进行第一次查找，从0行0列开始查找，而且不回环。如果没有找到，则替换完毕
QString whatFind = ui.replaceTextBox->currentText();
QString replaceText = ui.replaceWithBox->currentText();
if (m_extend)
{
QString extendFind;
convertExtendedToString(whatFind, extendFind);
whatFind = extendFind;
QString extendReplace;
convertExtendedToString(replaceText, extendReplace);
replaceText = extendReplace;
}
#if 0
if (!pEdit->findFirst(whatFind, m_re, m_cs, m_wo, false, m_forward, 0, 0))
{
ui.statusbar->showMessage(tr("cant't find text \'%1\'").arg(m_expr), 8000);
QApplication::beep();
m_isFindFirst = true;
return;
}
else
{
m_isFound = true;
m_isFindFirst = false;
}
//一定不能回环查找
m_wrap = false;
while (replace(pEdit))
{
++replaceNums;
}
#endif
if (!pEdit->findFirst(whatFind, m_re, m_cs, m_wo, false, true,0,0))
{
ui.statusbar->showMessage(tr("cant't find text \'%1\'").arg(m_expr), 8000);
QApplication::beep();
m_isFindFirst = true;
return;
}
pEdit->execute(SCI_BEGINUNDOACTION);
pEdit->replace(replaceText);
dealWithZeroFound(pEdit);
++replaceNums;
//找到了，则自动进行全部替换
while(pEdit->findNext())
{
pEdit->replace(replaceText);
++replaceNums;
dealWithZeroFound(pEdit);
}
pEdit->execute(SCI_ENDUNDOACTION);
pEdit->execute(SCI_GOTOPOS, srcPostion);
pEdit->execute(SCI_SETFIRSTVISIBLELINE, firstDisLineNum);
pEdit->execute(SCI_SETXOFFSET, 0);
//全部替换后，下次查找，必须算第一次查找
m_isFindFirst = true;
ui.statusbar->showMessage(tr("replace finished, total %1 replaced!").arg(replaceNums), 10000);
}
else
{
ui.statusbar->showMessage(tr("The mode of the current document does not allow replacement."), 8000);
QApplication::beep();
}
}
void FindWin::slot_replaceAllInOpenDoc()
{
if (ui.replaceTextBox->currentText().isEmpty())
{
ui.statusbar->showMessage(tr("what find is null !"), 8000);
QApplication::beep();
return;
}
if (QMessageBox::Yes != QMessageBox::question(this, tr("Replace All Open Doc"), tr("Are you sure replace all occurrences in all open documents?")))
{
return;
}
updateParameterFromUI();
int replaceNums = 0;
QString whatFind = ui.replaceTextBox->currentText();
QString whatReplace = m_replaceWithText;
if (m_extend)
{
QString extendFind;
convertExtendedToString(whatFind, extendFind);
whatFind = extendFind;
QString extendReplace;
convertExtendedToString(whatReplace, extendReplace);
whatReplace = extendReplace;
}
for (int i = 0; i < m_editTabWidget->count(); ++i)
{
QWidget* pw = m_editTabWidget->widget(i);
ScintillaEditView* pEdit = dynamic_cast<ScintillaEditView*>(pw);
if (pEdit != nullptr)
{
//只读的文档不能替换
if (pEdit->isReadOnly())
{
continue;
}
#if 0
m_isFound = false;
//无条件进行第一次查找，从0行0列开始查找，而且不回环。如果没有找到，则替换完毕
if (!pEdit->findFirst(whatFind, m_re, m_cs, m_wo, false, m_forward, 0, 0))
{
continue;
}
else
{
m_isFound = true;
m_isFindFirst = false;
}
//一定不能回环查找
m_wrap = false;
while (replace(pEdit))
{
++replaceNums;
}
#endif
//无条件进行第一次查找，从0行0列开始查找，而且不回环。如果没有找到，则替换完毕
if (!pEdit->findFirst(whatFind, m_re, m_cs, m_wo, false, true, 0, 0))
{
continue;
}
pEdit->replace(whatReplace);
dealWithZeroFound(pEdit);
++replaceNums;
//找到了，则自动进行全部替换
while (pEdit->findNext())
{
pEdit->replace(whatReplace);
++replaceNums;
dealWithZeroFound(pEdit);
}
}
}
//全部替换后，下次查找，必须算第一次查找
m_isFindFirst = true;
ui.statusbar->showMessage(tr("Replace in Opened Files: %1 occurrences were replaced.").arg(replaceNums), 10000);
}
//标记高亮单词
void FindWin::slot_markAll()
{
if (ui.markTextBox->currentText().isEmpty())
{
ui.statusbar->showMessage(tr("what mark is null !"), 8000);
QApplication::beep();
return;
}
QWidget* pw = autoAdjustCurrentEditWin();
ScintillaEditView* pEdit = dynamic_cast<ScintillaEditView*>(pw);
if (pEdit != nullptr)
{
FindRecords *results = new FindRecords;
results->pEdit = pEdit;
results->findFilePath = pw->property("filePath").toString();
updateParameterFromUI();
int replaceNums = 0;
//无条件进行第一次查找，从0行0列开始查找，而且不回环。如果没有找到，则替换完毕
QString whatMark = ui.markTextBox->currentText();
results->findText = whatMark;
if (m_extend)
{
QString extendFind;
convertExtendedToString(whatMark, extendFind);
whatMark = extendFind;
}
int srcPostion = pEdit->execute(SCI_GETCURRENTPOS);
int firstDisLineNum = pEdit->execute(SCI_GETFIRSTVISIBLELINE);
if (!pEdit->findFirst(whatMark, m_re, m_cs, m_wo, false, true, 0, 0))
{
ui.statusbar->showMessage(tr("cant't find text \'%1\'").arg(m_expr), 8000);
QApplication::beep();
return;
}
else
{
//不支持零长的高亮。0长不高亮
FindState& state = pEdit->getLastFindState();
if (state.targstart == state.targend)
{
ui.statusbar->showMessage(tr("cant't mark text \'%1\'").arg(m_expr), 8000);
QApplication::beep();
return;
}
}
addCurFindRecord(pEdit, *results,true);
++replaceNums;
//找到了,把结果收集起来
while (pEdit->findNext())
{
addCurFindRecord(pEdit, *results, true);
++replaceNums;
}
//把结果高亮起来。
int foundTextLen = 0;
for (int i = 0, s = results->records.size(); i < s; ++i)
{
const FindRecord& rs = results->records.at(i);
foundTextLen = rs.end - rs.pos;
if (foundTextLen > 0)
{
pEdit->execute(SCI_SETINDICATORCURRENT, SCE_UNIVERSAL_FOUND_STYLE);
pEdit->execute(SCI_INDICATORFILLRANGE, rs.pos, foundTextLen);
}
}
if (!results->records.isEmpty())
{
pEdit->appendMarkRecord(results);
}
pEdit->execute(SCI_SETFIRSTVISIBLELINE, firstDisLineNum);
pEdit->execute(SCI_GOTOPOS, srcPostion);
pEdit->execute(SCI_SETXOFFSET, 0);
//全部替换后，下次查找，必须算第一次查找
m_isFindFirst = true;
ui.statusbar->showMessage(tr("mark finished, total %1 found!").arg(replaceNums), 10000);
}
else
{
ui.statusbar->showMessage(tr("The mode of the current document does not allow mark."), 8000);
QApplication::beep();
}
}
//取消高亮
void FindWin::slot_clearMark()
{
QWidget* pw = autoAdjustCurrentEditWin();
ScintillaEditView* pEdit = dynamic_cast<ScintillaEditView*>(pw);
if (pEdit != nullptr)
{
int docEnd = pEdit->length();
pEdit->execute(SCI_SETINDICATORCURRENT, SCE_UNIVERSAL_FOUND_STYLE);
pEdit->execute(SCI_INDICATORCLEARRANGE, 0, docEnd);
pEdit->releaseAllMark();
}
}
//选择查找目录
void FindWin::slot_dirSelectDest()
{
QString destDir = QFileDialog::getExistingDirectory(this, tr("Open Directory"), CCNotePad::s_lastOpenDirPath, QFileDialog::DontResolveSymlinks);
if (!destDir.isEmpty())
{
ui.destFindDir->setText(destDir);
}
}
//在walkDirfile中用作回调函数处理。命中则返回true
bool FindWin::findTextInFile(QString &filePath, int &findNums, QVector<FindRecords*>* allfileInDirRecord)
{
pEditTemp->clear();
if (0 != FileManager::getInstance().loadFileForSearch(pEditTemp, filePath))
{
return false;
}
FindRecords* results = new FindRecords();
//返回结果的edit无条件写无。注意不要忘记
results->pEdit = nullptr;
results->findFilePath = filePath;
//无条件进行第一次查找，从0行0列开始查找，而且不回环。如果没有找到，则替换完毕
results->findText = m_expr;
QString whatFind = m_expr;
if (m_extend)
{
QString extendFind;
convertExtendedToString(whatFind, extendFind);
whatFind = extendFind;
}
if (!pEditTemp->findFirst(whatFind, m_re, m_cs, m_wo, false, m_forward, 0, 0))
{
delete results;
return false;
}
else
{
dealWithZeroFound(pEditTemp);
}
addCurFindRecord(pEditTemp, *results);
++findNums;
//找到了,把结果收集起来
while (pEditTemp->findNext())
{
addCurFindRecord(pEditTemp, *results);
++findNums;
dealWithZeroFound(pEditTemp);
}
allfileInDirRecord->append(results);
return true;
}
//在walkDirfile中用作回调函数处理。命中则返回true 第三个参数不需要，为了复用walkdir，暂时保留和findTextInFile一致
bool FindWin::replaceTextInFile(QString &filePath, int &replaceNums, QVector<FindRecords*>*)
{
pEditTemp->clear();
if (0 != FileManager::getInstance().loadFileForSearch(pEditTemp, filePath))
{
return false;
}
QString find = m_expr;
QString replace = m_replaceWithText;
if (m_extend)
{
QString extendFind;
convertExtendedToString(find, extendFind);
find = extendFind;
QString extendReplace;
convertExtendedToString(replace, extendReplace);
replace = extendReplace;
}
if (!pEditTemp->findFirst(find, m_re, m_cs, m_wo, false, m_forward, 0, 0))
{
return false;
}
pEditTemp->replace(replace);
dealWithZeroFound(pEditTemp);
++replaceNums;
//找到了，则自动进行全部替换
while (pEditTemp->findNext())
{
pEditTemp->replace(replace);
++replaceNums;
dealWithZeroFound(pEditTemp);
}
//必须要保存一下
emit sign_replaceSaveFile(filePath, pEditTemp);
return true;
}
//非递归版本的递归文件，从CompareDirs中修改而来
//isSkipBinary:是否跳过二进制
//isSkipHide:是否处理隐藏文件
//skipMaxSize::处理文件的最大大小，超过则不处理。如果是0，则表示不跳过任何文件
//isfilterFileType:过滤类型，只处理这类类型文件 为true时 fileExtType 不能为空
//fileExtType的格式为：.cpp .h 类似，但是不需要前面的.，传递的时候不传递下来
int FindWin::walkDirfile(QString path, int &foundTimes, bool isSkipBinary, bool isSkipHide, int skipMaxSize, bool isfilterFileType, QStringList& fileExtType, bool isSkipChildDirs, std::function<bool(QString &, int &, QVector<FindRecords*>* allfileInDirRecord)> foundCallBack, bool isAskAbort)
{
QList<QString> dirsList;
QString oneDir(path);
dirsList.append(oneDir);
int fileNums = 0;
int hitFileNums = 0;
//再获取文件夹到列表
QDir::Filters dirfilter;
if (!isSkipHide)
{
dirfilter = QDir::Dirs | QDir::NoDotAndDotDot | QDir::Hidden | QDir::NoSymLinks;
}
else
{
dirfilter = QDir::Dirs | QDir::NoDotAndDotDot | QDir::NoSymLinks;
}
//过滤文件类型。true 合格，需要处理， false 不合格，跳过
auto fileTypeFilter = [&fileExtType](QFileInfo& fileInfo)->bool {
QString suffix = fileInfo.suffix();
if (!suffix.isEmpty())
{
return (-1 != fileExtType.indexOf(suffix));
}
//对于没有后缀的文件，一律跳过
return false;
};
//是否二进制文件
auto binaryFiltre = [](QFileInfo& fi)->bool {
#if 0
//如果不支持该文件ext，则以二进制形式打开
if (DocTypeListView::isSupportExt(fi.suffix()))
{
return false;
}
else
{
static QMimeDatabase db;
QMimeType mime = db.mimeTypeForFile(fi);
if (mime.name().startsWith("text")) {
return false;
}
}
return true;
#endif
return DocTypeListView::isHexExt(fi.suffix());
};
ProgressWin* loadFileProcessWin = new ProgressWin(this);
loadFileProcessWin->setWindowModality(Qt::WindowModal);
loadFileProcessWin->info(tr("load dir file in progress\n, please wait ..."));
loadFileProcessWin->show();
int dirNums = 0;
bool firstChildDirs = true;
int totalStep = 0;
bool canAbort = true;
bool canAbortSecond = true;
if (!isAskAbort)
{
canAbort = false;
canAbortSecond = false;
}
while (!dirsList.isEmpty())
{
QString curDir = dirsList.takeFirst();
if (!isSkipChildDirs)
{
/*添加path路径文件*/
QDir dir(curDir); //遍历各级子目录
QFileInfoList folder_list = dir.entryInfoList(dirfilter); //获取当前所有目录
for (int i = 0; i != folder_list.size(); ++i) //自动递归添加各目录到上一级目录
{
QString namepath = folder_list.at(i).absoluteFilePath(); //获取路径
QFileInfo folderinfo = folder_list.at(i);
if (folderinfo.baseName().isEmpty())
{
loadFileProcessWin->info(tr("skip dir %1").arg(namepath));
continue;
}
QString name = folderinfo.fileName(); //获取目录名
dirsList.push_front(namepath);
dirNums++;
loadFileProcessWin->info(tr("found %1 dir %2").arg(dirNums).arg(namepath));
QCoreApplication::processEvents(/*QEventLoop::ExcludeUserInputEvents*/);
}
if (firstChildDirs)
{
totalStep = dirNums;
loadFileProcessWin->setTotalSteps(dirNums);
firstChildDirs = false;
}
if (dirsList.size() < totalStep)
{
totalStep = dirsList.size();
loadFileProcessWin->moveStep();
}
}
QDir dir_file(curDir);
if (!isSkipHide)
{
dir_file.setFilter(QDir::Files | QDir::NoDotAndDotDot | QDir::Hidden | QDir::NoSymLinks);//获取当前所有文件
}
else
{
dir_file.setFilter(QDir::Files | QDir::NoDotAndDotDot | QDir::NoSymLinks);//获取当前所有文件
}
QFileInfoList list_file = dir_file.entryInfoList();
for (int i = 0; i < list_file.size(); ++i)
{ //将当前目录中所有文件添加到treewidget中
QFileInfo fileInfo = list_file.at(i);
QString namepath = list_file.at(i).absoluteFilePath(); //获取路径
//不支持所有文件，仅仅支持指定类型文件。没有通过
if (isfilterFileType && !fileTypeFilter(fileInfo))
{
loadFileProcessWin->info(tr("ext type skip file %1").arg(namepath));
continue;
}
//大小过滤
if ((skipMaxSize != 0) && fileInfo.size() > skipMaxSize)
{
continue;
}
//二进制过滤//对于二进制文件该如何处理，我觉得必须要过滤，暂时不处理
if (isSkipBinary &&binaryFiltre(fileInfo))
{
continue;
}
//回调处理该函数
if (foundCallBack(namepath, foundTimes, nullptr))
{
++hitFileNums;
}
if (i % 2 == 0)
{
if (loadFileProcessWin->isCancel())
{
loadFileProcessWin->info(tr("found in dir canceled ..."));
break;
}
QCoreApplication::processEvents();
}
if ((canAbort && (hitFileNums > 100 || foundTimes > 1000)) || (canAbortSecond && foundTimes > 8000))
{
int ret = QMessageBox::question(this, tr("Continue Find ?"), tr("The search results have been greater than %1 times in %2 files, and more may be slow. Continue to search?").arg(foundTimes).arg(hitFileNums), tr("Yes"), tr("Abort"));
if(ret == 1)
{
loadFileProcessWin->setCancel();
break;
}
else
{
if (canAbort && (hitFileNums > 100 || foundTimes > 1000))
{
canAbort = false;
}
if ((canAbortSecond && foundTimes > 8000))
{
canAbortSecond = false;
}
}
}
}
fileNums += list_file.size();
if (loadFileProcessWin->isCancel())
{
break;
}
}
if (loadFileProcessWin != nullptr)
{
delete loadFileProcessWin;
loadFileProcessWin = nullptr;
}
return fileNums;
}
//在目标文件夹中查找
void FindWin::slot_dirFindAll()
{
QString dirPath = ui.destFindDir->text().trimmed();
QString whatFind = ui.dirFindWhat->currentText();
if (dirPath.isEmpty())
{
ui.statusbar->showMessage(tr("please select find dest dir !"), 8000);
QApplication::beep();
return;
}
if(whatFind.isEmpty())
{
ui.statusbar->showMessage(tr("what find is null !"), 8000);
QApplication::beep();
return;
}
QDir dir(dirPath);
if (!dir.exists())
{
ui.statusbar->showMessage(tr("dest dir %1 not exist !").arg(dirPath), 8000);
QApplication::beep();
return;
}
bool isfilterFileType = ui.dealFileType->isChecked();
QStringList fileExtTypeList;
if (isfilterFileType)
{
QString fileExtType = ui.fileType->text().trimmed();
if (fileExtType.isEmpty() || (fileExtType == "*.*"))
{
isfilterFileType = false;
}
else
{
//格式是*.h:*.c:*.cpp类似的
QStringList typeList = fileExtType.split(":");
foreach (QString var, typeList)
{
if (var.size() >= 3)
{
//只取后面的h或或cpp后缀
fileExtTypeList.append(var.mid(2));
}
}
if (fileExtTypeList.isEmpty())
{
isfilterFileType = false;
}
}
}
bool isSkipBinary = ui.skipBinary->isChecked();
bool isSkipHide = ui.skipHideFile->isChecked();
int skipMaxSize = (ui.skipFileMaxSize->isChecked()) ? ui.maxFileSizeSpinBox->value()*1024*1024:0;
bool isSkipChildDir = ui.skipChildDirs->isChecked();
updateParameterFromUI();
if (pEditTemp == nullptr)
{
pEditTemp = new ScintillaEditView(nullptr);
}
int foundNums = 0;
QVector<FindRecords*>* allfileInDirRecord = new QVector<FindRecords*>();
std::function<bool(QString &, int &, QVector<FindRecords*>* allfileInDirRecord)> foundCallBack = std::bind(&FindWin::findTextInFile, this, std::placeholders::_1, std::placeholders::_2, allfileInDirRecord);
int filesNum = walkDirfile(dirPath, foundNums, isSkipBinary, isSkipHide, skipMaxSize, isfilterFileType, fileExtTypeList, isSkipChildDir, foundCallBack);
//全部替换后，下次查找，必须算第一次查找
m_isFindFirst = true;
ui.statusbar->showMessage(tr("find finished, total %1 found in %2 file!").arg(foundNums).arg(filesNum), 10000);
//复用了这个信号函数，没有新做消息，要注意
emit sign_findAllInOpenDoc(allfileInDirRecord, foundNums, whatFind);
addFindHistory(whatFind);
//释放元素
for (int i = 0; i < allfileInDirRecord->size(); ++i)
{
delete allfileInDirRecord->at(i);
}
delete allfileInDirRecord;
}
//目录中直接替换
void FindWin::slot_dirReplaceAll()
{
QString dirPath = ui.destFindDir->text();
QString whatFind = ui.dirFindWhat->currentText();
QString dirReplaceWhat = ui.dirReplaceWhat->currentText();
if (dirPath.isEmpty())
{
ui.statusbar->showMessage(tr("please select find dest dir !"), 8000);
QApplication::beep();
return;
}
if (whatFind.isEmpty())
{
ui.statusbar->showMessage(tr("what find is null !"), 8000);
QApplication::beep();
return;
}
if (QMessageBox::Yes != QMessageBox::question(this, tr("Replace All Dirs"), tr("Are you sure replace all \"%1\" to \"%2\" occurrences in selected dirs ?").arg(whatFind).arg(dirReplaceWhat)))
{
return;
}
bool isfilterFileType = ui.dealFileType->isChecked();
QStringList fileExtTypeList;
if (isfilterFileType)
{
QString fileExtType = ui.fileType->text().trimmed();
if (fileExtType.isEmpty() || (fileExtType == "*.*"))
{
isfilterFileType = false;
}
else
{
//格式是*.h:*.c:*.cpp类似的
QStringList typeList = fileExtType.split(":");
foreach(QString var, typeList)
{
if (var.size() >= 3)
{
//只取后面的h或或cpp后缀
fileExtTypeList.append(var.mid(2));
}
}
if (fileExtTypeList.isEmpty())
{
isfilterFileType = false;
}
}
}
bool isSkipBinary = ui.skipBinary->isChecked();
bool isSkipHide = ui.skipHideFile->isChecked();
int skipMaxSize = (ui.skipFileMaxSize->isChecked()) ? ui.maxFileSizeSpinBox->value() * 1024 * 1024 : 0;
bool isSkipChildDir = ui.skipChildDirs->isChecked();
updateParameterFromUI();
if (pEditTemp == nullptr)
{
pEditTemp = new ScintillaEditView(nullptr);
}
int replaceNums = 0;
std::function<bool(QString &, int &, QVector<FindRecords*>* allfileInDirRecord)> foundCallBack = std::bind(&FindWin::replaceTextInFile, this, std::placeholders::_1, std::placeholders::_2, nullptr);
int filesNum = walkDirfile(dirPath, replaceNums, isSkipBinary, isSkipHide, skipMaxSize, isfilterFileType, fileExtTypeList, isSkipChildDir, foundCallBack,false);
//全部替换后，下次查找，必须算第一次查找
m_isFindFirst = true;
ui.statusbar->showMessage(tr("replace finished, total %1 replace in %2 file!").arg(replaceNums).arg(filesNum), 10000);
}
Reference in New Issue View Git Blame Copy Permalink