void Styler_Syntax::ApplyDiff(const vector<cxLineChange>& linechanges) {
if (m_lines.GetLength() == 0) {
Invalidate();
return;
}
m_updateLineHeight = true;
#ifdef __WXDEBUG__
// Syntax after change is not valid during application of diff
m_verifyEnabled = false;
#endif
for (vector<cxLineChange>::const_iterator l = linechanges.begin(); l != linechanges.end(); ++l) {
// Adjust syntax end
if (m_syntax_end > l->start) {
if (m_syntax_end > l->end) m_syntax_end += l->diff;
else m_syntax_end = l->start;
}
else goto cleanup_and_return; // Change after search area, no need to re-search
const unsigned int old_line_end = l->end - l->diff;
const unsigned int new_length = l->end - l->start;
unsigned int change_end = l->end;
// Adjust matches
if (l->start != old_line_end) change_end = wxMax(AdjustForDeletion(l->start, old_line_end, m_topMatches, 0, l->start), change_end);;
if (new_length) change_end = wxMax(AdjustForInsertion(l->start, new_length, m_topMatches, 0, l->start), change_end);
// limit parsing upto next changed line
unsigned int limit;
vector<cxLineChange>::const_iterator nextchange = l+1;
if (nextchange != linechanges.end()) limit = nextchange->start;
else limit = m_lines.GetLineEndFromPos(change_end);
if (l->start < limit) DoSearch(l->start, l->end, limit);
}
cleanup_and_return:
m_updateLineHeight = false;
#ifdef __WXDEBUG__
m_verifyEnabled = true;
Verify();
#endif
}
void SoundCloudService::Search(const QString& text, bool now) {
pending_search_ = text;
// If there is no text (e.g. user cleared search box), we don't need to do a
// real query that will return nothing: we can clear the playlist now
if (text.isEmpty()) {
search_delay_->stop();
ClearSearchResults();
return;
}
if (now) {
search_delay_->stop();
DoSearch();
} else {
search_delay_->start();
}
}
bool cAmp::KeysEdit(bool shift, WPARAM k)
{
// Edit Tab Name
switch(k) { // strlen, left,right,ctrl, home,end ...
// <del
case VK_BACK: ied--; if (ied<0) ied=0; sed[ied]=0; fTi=0.5f; rt
case VK_ESCAPE: case VK_F2: case VK_F3: GuiOff(); rt // exit
case VK_RETURN: // accept
switch(ed) {
case ED_nTab:
{ pls->name = sed; GuiOff();
pls->Save(); SetSave(); } rt
case ED_nFind:
{ scpy(srch, sed); GuiOff(); DoSearch(); } rt
} rt
default: // add char
{ if (ied >= (ed==ED_nTab?NamePls:NameSrch)-1) rt
char c = 0;
// key char codes
if (k>='0' && k<='9'){ if (shift) c=chShNum[k-'0']; else c=k; } else
if (k>='A' && k<='Z'){ if (shift) c=k; else c=k-'A'+'a'; } else
switch (k)
{
case VK_SPACE: c=' '; break;
case VK_OEM_3: if (shift) c='~'; else c='`'; break;
case VK_OEM_MINUS: if (shift) c='_'; else c='-'; break;
case VK_OEM_PLUS: if (shift) c='+'; else c='='; break;
case VK_OEM_4: if (shift) c='{'; else c='['; break;
case VK_OEM_6: if (shift) c='}'; else c=']'; break;
case VK_OEM_7: c='\''; break;
case VK_OEM_PERIOD: c='.'; break;
case VK_OEM_COMMA: c=','; break;
}
if (c==0) rt // write char
sed[ied]= (char)c; ied++; sed[ied]=0; fTi=0.5f;
//... le ri del bck
} rt
} rf
}
void QuickFindBar::OnFindPreviousCaret(wxCommandEvent& e)
{
CHECK_FOCUS_WIN();
wxString selection(DoGetSelectedText());
if(selection.IsEmpty()) {
// select the word
long pos = m_sci->GetCurrentPos();
long start = m_sci->WordStartPosition(pos, true);
long end = m_sci->WordEndPosition(pos, true);
selection = m_sci->GetTextRange(start, end);
if(selection.IsEmpty() == false) m_sci->SetCurrentPos(start);
}
if(selection.IsEmpty()) return;
m_findWhat->ChangeValue(selection);
DoSearch(0);
}
/**
* Make some initial calculations and preparations
*/
IPath::SearchResult CPathEstimator::InitSearch(const MoveData& moveData, const CPathFinderDef& peDef) {
// is starting square inside goal area?
int xSquare = blockState[startBlocknr].sqrCenter[moveData.pathType].x;
int zSquare = blockState[startBlocknr].sqrCenter[moveData.pathType].y;
if (peDef.IsGoal(xSquare, zSquare))
return CantGetCloser;
// no, clean the system from last search
ResetSearch();
// mark and store the start-block
blockState[startBlocknr].options |= PATHOPT_OPEN;
blockState[startBlocknr].cost = 0;
dirtyBlocks.push_back(startBlocknr);
openBlockBufferIndex = 0;
// add the starting block to the open-blocks-queue
OpenBlock* ob = &openBlockBuffer[openBlockBufferIndex];
ob->cost = 0;
ob->currentCost = 0;
ob->block = startBlock;
ob->blocknr = startBlocknr;
openBlocks.push(ob);
// mark starting point as best found position
goalBlock = startBlock;
goalHeuristic = peDef.Heuristic(xSquare, zSquare);
// get the goal square offset
goalSqrOffset = peDef.GoalSquareOffset(BLOCK_SIZE);
// perform the search
SearchResult result = DoSearch(moveData, peDef);
// if no improvements are found, then return CantGetCloser instead
if (goalBlock.x == startBlock.x && goalBlock.y == startBlock.y)
return CantGetCloser;
else
return result;
}
/*
Setting up the starting point of the search.
*/
IPath::SearchResult CPathFinder::InitSearch(const MoveData& moveData, const CPathFinderDef& pfDef) {
//If exact path is reqired and the goal is blocked, then no search is needed.
if(exactPath && pfDef.GoalIsBlocked(moveData, (CMoveMath::BLOCK_STRUCTURE | CMoveMath::BLOCK_TERRAIN)))
return CantGetCloser;
//If the starting position is a goal position, then no search need to be performed.
if(pfDef.IsGoal(startxSqr, startzSqr))
return CantGetCloser;
//Clearing the system from last search.
ResetSearch();
//Marks and store the start-square.
squareState[startSquare].status = (PATHOPT_START | PATHOPT_OPEN);
squareState[startSquare].cost = 0;
dirtySquares.push_back(startSquare);
//Make the beginning the fest square found.
goalSquare = startSquare;
goalHeuristic = pfDef.Heuristic(startxSqr, startzSqr);
//Adding the start-square to the queue.
openSquareBufferPointer = &openSquareBuffer[0];
OpenSquare *os = openSquareBufferPointer; //Taking first OpenSquare in buffer.
os->currentCost = 0;
os->cost = 0;
os->square.x = startxSqr;
os->square.y = startzSqr;
os->sqr = startSquare;
openSquares.push(os);
//Performs the search.
SearchResult result = DoSearch(moveData, pfDef);
//If no improvement has been found then return CantGetCloser instead.
if(goalSquare == startSquare || goalSquare == 0) {
return CantGetCloser;
} else
return result;
}
SpotifyService::SpotifyService(InternetModel* parent)
: InternetService(kServiceName, parent, parent),
server_(NULL),
url_handler_(new SpotifyUrlHandler(this, this)),
blob_process_(NULL),
root_(NULL),
search_(NULL),
starred_(NULL),
inbox_(NULL),
login_task_id_(0),
pending_search_playlist_(NULL),
context_menu_(NULL),
search_delay_(new QTimer(this)),
login_state_(LoginState_OtherError) {
// Build the search path for the binary blob.
// Look for one distributed alongside clementine first, then check in the
// user's home directory for any that have been downloaded.
#ifdef Q_OS_MAC
system_blob_path_ = QCoreApplication::applicationDirPath() +
"/../PlugIns/clementine-spotifyblob";
#else
system_blob_path_ = QCoreApplication::applicationDirPath() +
"/clementine-spotifyblob" CMAKE_EXECUTABLE_SUFFIX;
#endif
local_blob_version_ = QString("version%1-%2bit").arg(SPOTIFY_BLOB_VERSION).arg(sizeof(void*) * 8);
local_blob_path_ = Utilities::GetConfigPath(Utilities::Path_LocalSpotifyBlob) +
"/" + local_blob_version_ + "/blob";
qLog(Debug) << "Spotify system blob path:" << system_blob_path_;
qLog(Debug) << "Spotify local blob path:" << local_blob_path_;
model()->player()->RegisterUrlHandler(url_handler_);
model()->player()->playlists()->RegisterSpecialPlaylistType(
new SpotifySearchPlaylistType(this));
search_delay_->setInterval(kSearchDelayMsec);
search_delay_->setSingleShot(true);
connect(search_delay_, SIGNAL(timeout()), SLOT(DoSearch()));
}
// Search for a string
void MainWindow::Search(bool ask)
{
long position;
if (ask || m_searchString.empty())
{
wxString s = wxGetTextFromUser( wxT("Enter search string"), wxT("Search"), m_searchString);
if (!s.empty())
{
s.MakeLower();
m_searchString = s;
search_ok = true;
}
else
{
search_ok = false;
}
}
else
{
same_search = true;
search_ok = true;
}
if (!m_searchString.empty() && search_ok)
{
position = DoSearch();
if (position > -1)
{
loaded_ok = LoadPoem(data_filename, position);
Resize();
}
else
{
last_poem_start = 0;
PoetryNotify(wxT("Search string not found."));
}
}
}
/*
Making some initial calculations and preparations.
*/
IPath::SearchResult CPathEstimator::InitSearch(const MoveData& moveData, const CPathFinderDef& peDef) {
//Starting square is inside goal area?
int xSquare = blockState[startBlocknr].sqrCenter[moveData.pathType].x;
int zSquare = blockState[startBlocknr].sqrCenter[moveData.pathType].y;
if(peDef.IsGoal(xSquare, zSquare))
return CantGetCloser;
//Cleaning the system from last search.
ResetSearch();
//Marks and store the start-block.
blockState[startBlocknr].options |= PATHOPT_OPEN;
blockState[startBlocknr].cost = 0;
dirtyBlocks.push_back(startBlocknr);
//Adding the starting block to the open-blocks-queue.
OpenBlock* ob = openBlockBufferPointer = openBlockBuffer;
ob->cost = 0;
ob->currentCost = 0;
ob->block = startBlock;
ob->blocknr = startBlocknr;
openBlocks.push(ob);
//Mark starting point as best found position.
goalBlock = startBlock;
goalHeuristic = peDef.Heuristic(xSquare, zSquare);
//Gets goal square offset.
goalSqrOffset = peDef.GoalSquareOffset(BLOCK_SIZE);
//Performs the search.
SearchResult result = DoSearch(moveData, peDef);
//If no improvements are found, then return CantGetCloser instead.
if(goalBlock.x == startBlock.x && goalBlock.y == startBlock.y)
return CantGetCloser;
else
return result;
}
SoundCloudService::SoundCloudService(Application* app, InternetModel* parent)
: InternetService(kServiceName, app, parent, parent),
root_(nullptr),
search_(nullptr),
user_tracks_(nullptr),
user_playlists_(nullptr),
user_activities_(nullptr),
network_(new NetworkAccessManager(this)),
context_menu_(nullptr),
search_box_(new SearchBoxWidget(this)),
search_delay_(new QTimer(this)),
next_pending_search_id_(0) {
search_delay_->setInterval(kSearchDelayMsec);
search_delay_->setSingleShot(true);
connect(search_delay_, SIGNAL(timeout()), SLOT(DoSearch()));
SoundCloudSearchProvider* search_provider =
new SoundCloudSearchProvider(app_, this);
search_provider->Init(this);
app_->global_search()->AddProvider(search_provider);
connect(search_box_, SIGNAL(TextChanged(QString)), SLOT(Search(QString)));
}
void SearchThread::SearchDir(const wxString& path, const SearchInfo& si, ProjectInfoHandler& infoHandler) {
MMapBuffer buf;
wxFileName filepath;
vector<FileMatch> matches;
wxArrayString dirs;
wxArrayString filenames;
infoHandler.GetDirAndFileLists(path, dirs, filenames);
for (size_t f = 0; f < filenames.size(); ++f) {
if (!m_isSearching) return;
m_outputCrit.Enter();
m_currentPath = path + filenames[f];
m_outputCrit.Leave();
filepath = m_currentPath;
// Map the file to memory
buf.Open(filepath);
if (!buf.IsMapped()) {
wxLogDebug(wxT(" Mapping failed!"));
continue;
}
// Search the file
DoSearch(buf, si, matches);
if (matches.empty()) continue;
// Show matches
WriteResult(buf, filepath, matches);
matches.clear();
}
for (size_t d = 0; d < dirs.size(); ++d) {
const wxString dirpath = path + dirs[d] + wxFILE_SEP_PATH;
SearchDir(dirpath, si, infoHandler);
}
}
void Styler_Syntax::Style(StyleRun& sr) {
if (!HaveActiveSyntax()) return;
unsigned int sr_end = sr.GetRunEnd();
// Check if we need to do a new search
if (sr_end > m_syntax_end) {
// Make sure the extended position is valid and extends
// from start-of-line to end-of-line
unsigned int sr_start;
cxLOCKDOC_READ(m_doc)
sr_start = doc.GetLineStart(m_syntax_end);
cxENDLOCK
// Extend stylerun to get better search results (round up to whole EXTSIZEs)
const unsigned int ext = ((sr_end / EXTSIZE) + 1) * EXTSIZE;
sr_end = ext < m_lines.GetLength() ? ext : m_lines.GetLength();
sr_end = m_lines.GetLineEndFromPos(sr_end);
DoSearch(sr_start, sr_end, sr_end);
}
// Apply base style
if (m_topStyle) {
const unsigned int start = sr.GetRunStart();
const unsigned int end = sr.GetRunEnd();
if (m_topStyle->foregroundcolor != wxNullColour) sr.SetForegroundColor(start, end, m_topStyle->foregroundcolor);
if (m_topStyle->backgroundcolor != wxNullColour) {
sr.SetBackgroundColor(start, end, m_topStyle->backgroundcolor);
sr.SetExtendBgColor(m_topStyle->backgroundcolor);
}
if (m_topStyle->fontflags != wxFONTFLAG_DEFAULT) sr.SetFontStyle(start, end, m_topStyle->fontflags);
}
// Style the run
DoStyle(sr, 0, m_topMatches.matches);
}
int StartSearch(
HWND hWnd,
WPARAM wParam,
LPARAM lParam)
{
FINDREPLACE FAR *lpfr;
lpfr = (FINDREPLACE FAR *) lParam;
/*==========================================*/
/* Terminate Find/Replace Dialog if needed. */
/*==========================================*/
if (lpfr->Flags & FR_DIALOGTERM)
{
HMENU hMenu = GetMenu(hMainFrame);
EnableMenuItem(hMenu,ID_BUFFER_FIND,MF_ENABLED);
EnableMenuItem(hMenu,ID_BUFFER_REPLACE,MF_ENABLED);
SearchActive = FALSE;
return 0;
}
/*===========================================*/
/* Perform the actual search and/or Replace. */
/*===========================================*/
ShowWindow (SearchDlg,SW_HIDE );
DoSearch(hWnd,
((lpfr->Flags & FR_REPLACE) || (lpfr->Flags & FR_REPLACEALL)),
(int) (lpfr->Flags & FR_REPLACEALL),
(int) (lpfr->Flags & FR_MATCHCASE) );
ShowWindow(SearchDlg,SW_SHOW);
SetFocus(hWnd);
return 0;
}
/*ARGSUSED*/
static void
SearchButton(Widget w, XtPointer closure, XtPointer call_data)
{
(void)DoSearch((struct SearchAndReplace *)closure);
}
void Styler_SearchHL::Style(StyleRun& sr) {
const unsigned int rstart = sr.GetRunStart();
const unsigned int rend = sr.GetRunEnd();
// Style the run with search ranges
for (vector<interval>::const_iterator r = m_searchRanges.begin(); r != m_searchRanges.end(); ++r) {
if (r->end > rstart && r->start < rend) {
unsigned int start = wxMax(rstart, r->start);
unsigned int end = wxMin(rend, r->end);
sr.SetBackgroundColor(start, end, m_rangeColor);
}
}
// No need for more styling if no search text
if (m_text.empty()) return;
// Extend stylerun start/end to get better search results (round up to whole EXTSIZEs)
unsigned int sr_start = rstart> 100 ? rstart - 100 : 0;
const unsigned int ext_end = ((rend/EXTSIZE) * EXTSIZE) + EXTSIZE;
unsigned int sr_end = ext_end < m_lines.GetLength() ? ext_end : m_lines.GetLength();
// Make sure the extended positions are valid
cxLOCKDOC_READ(m_doc)
sr_start = doc.GetValidCharPos(sr_start);
if (sr_end != m_lines.GetLength()) sr_end = doc.GetValidCharPos(sr_end);
cxENDLOCK
//wxLogDebug("Style %u %u", rstart, rend);
//wxLogDebug(" %u %u - %u %u", sr_start, sr_end, m_search_start, m_search_end);
// Check if we need to do a new search
if (sr_start < m_search_start || m_search_end < sr_end) {
// Check if there is overlap so we can just extend the search area
if (sr_end > m_search_start && sr_start < m_search_end) {
sr_start = wxMin(sr_start, m_search_start);
sr_end = wxMax(sr_end, m_search_end);
}
else {
// Else we have to move it
m_matches.clear();
m_search_start = 0;
m_search_end = 0;
}
// Do the search
if (sr_start < m_search_start) {
// Search from top
DoSearch(sr_start, sr_end);
}
else if (sr_end > m_search_end) {
// Search from bottom
DoSearch(sr_start, sr_end, true);
}
else wxASSERT(false);
m_search_start = sr_start;
m_search_end = sr_end;
}
// Style the run with matches
for (vector<interval>::iterator p = m_matches.begin(); p != m_matches.end(); ++p) {
if (p->start > rend) break;
// Check for overlap (or zero-length sel at start-of-line)
if ((p->end > rstart && p->start < rend) || (p->start == p->end && p->end == rstart)) {
unsigned int start = wxMax(rstart, p->start);
unsigned int end = wxMin(rend, p->end);
// Only draw it if it is in range
if (!m_searchRanges.empty()) {
bool inRange = false;
for (vector<interval>::const_iterator s = m_searchRanges.begin(); s != m_searchRanges.end(); ++s) {
if (start >= s->start && start < s->end) {
inRange = true;
break;
}
}
if (!inRange) continue;
}
ApplyStyle(sr, start, end);
}
}
}
void Styler_SearchHL::Delete(unsigned int start_pos, unsigned int end_pos) {
wxASSERT(0 <= start_pos && start_pos <= m_doc.GetLength());
if (m_text.empty()) return;
if (start_pos == end_pos) return;
wxASSERT(end_pos > start_pos);
// Check if we have deleted the entire document
if (m_doc.GetLength() == 0) {
Invalidate();
return;
}
// Adjust start & end
unsigned int length = end_pos - start_pos;
if (m_search_start >= start_pos) {
if (m_search_start > end_pos) m_search_start -= length;
else m_search_start = start_pos;
}
if (m_search_end > start_pos) {
if (m_search_end > end_pos) m_search_end -= length;
else m_search_end = start_pos;
}
else return; // Change after search area, no need to re-search
unsigned int search_start = m_search_start;
if (!m_matches.empty()) {
if (start_pos >= m_matches.back().end) {
// Do a new search from end of last match
DoSearch(search_start, m_search_end, true);
return;
}
// Find matches touched by deletion and remove those. Update all following
bool is_first = true;
vector<interval>::iterator p = m_matches.begin();
while (p != m_matches.end()) {
if (p->end > start_pos) {
// Remember first valid match before pos
if (is_first) {
if (p != m_matches.begin()) search_start = (p-1)->end;
is_first = false;
}
if (p->start < end_pos) {
// pos inside match. Delete and continue
p = m_matches.erase(p);
if (p != m_matches.end()) continue; // new iterator
else break;
}
else {
// Move match to correct position
p->start -= length;
p->end -= length;
}
}
++p;
}
}
// Do a new search starting from end of first match before pos
DoSearch(search_start, m_search_end, false);
}
/**
Search for a node by directory path
@param aPath the path as the key to search in the tree
@param aNodeFound in return, the node found
@param aDirPos the location of the directory
@return KErrNone if a node found
KErrNotFound if no node is found
*/
TInt CLeafDirTree::Search(const TDesC& aPath, CLeafDirTreeNode*& aNodeFound, TLeafDirData& aDirPos)
{
return (DoSearch(aPath, iRoot, aNodeFound, aDirPos));
}
void CContactPage::OnTimer(wxTimerEvent& e)
{
DoSearch();
}
void CContactPage::OnSearch(wxCommandEvent&)
{
DoSearch();
}
bool GreedyBestFirst::DoSearch(Tree::Node* currNode)
{
if (currNode == NULL)
currNode = m_searchTree->getHead();
m_path.push_back(currNode->vert);
currNode->path = m_path;
// Add to closed list
m_closedList.insert(make_pair(currNode->vert, currNode));
// Return true if dest has been reached
if (currNode->vert == m_end)
return true;
// fetch edges connected to current vertex
list<Graph::Edge*> conns = m_searchSpace->getConnectedEdges(currNode->vert);
// create a node for each connection if one of following is true:
// - The vertex has not been visited
for (list<Graph::Edge*>::iterator itr = conns.begin(); itr != conns.end(); ++itr)
{
// Compute cost of this path
int nextCost = currNode->cost + (*itr)->cost;
Graph::Vertex* endVert;
if ((*itr)->ends[0] == currNode->vert)
endVert = (*itr)->ends[1];
else
endVert = (*itr)->ends[0];
// Figure out which end is the start, add child accordingly if not already visited
if (!endVert->visited)
m_searchTree->addAsChild(nextCost, endVert, currNode, &m_path);
}
// fetch children of current node
list<Tree::Node*> currChildren = currNode->getChildren();
// if no children and not at dest, not on correct path
if (currChildren.empty())
{
return false;
}
// append to open list
m_openList.insert(m_openList.end(), currChildren.begin(), currChildren.end());
sort(m_openList.begin(), m_openList.end(), CompareFunc);
if( m_verbose )
displayOpenList();
// mark current vertex visited
currNode->vert->visited = true;
Tree::Node* nextNode;
// get first entry in open list and remove from open list
do
{
if (m_openList.empty())
return false;
nextNode = *m_openList.begin();
m_openList.pop_front();
}
while( nextNode->vert->visited );
// set path to next node's path
m_path = nextNode->path;
if (m_verbose)
{
displayPath(currNode);
cout << "Expanding node " << nextNode->vert->id << endl;
}
if (DoSearch(nextNode))
return true;
// default case, no path found
m_path.clear();
return false;
}
void QuickFindBar::OnReplace(wxCommandEvent& event)
{
wxUnusedVar(event);
if(!m_sci) return;
wxString findwhat = m_findWhat->GetValue();
if(findwhat.IsEmpty()) return;
wxString findWhatSciVersion = findwhat;
DoFixRegexParen(findWhatSciVersion);
// No selection?
if(m_sci->GetSelections() == 0) {
DoSearch(kSearchForward);
return;
}
// No selection?
if(m_sci->GetSelections() != 1) {
DoSearch(kSearchForward);
return;
}
// did we got a match?
if(m_sci->GetSelections() != 1) return;
int selStart, selEnd;
m_sci->GetSelection(&selStart, &selEnd);
if(selStart == selEnd) {
// not a real selection
DoSearch(kSearchForward);
return;
}
// Ensure that the selection matches our search pattern
size_t searchFlags = DoGetSearchFlags();
if(m_sci->FindText(selStart, selEnd, searchFlags & wxSTC_FIND_REGEXP ? findWhatSciVersion : findwhat,
searchFlags) == wxNOT_FOUND) {
// we got a selection, but it does not match our search
return;
}
wxString selectedText = m_sci->GetTextRange(selStart, selEnd);
#ifndef __WXMAC__
int re_flags = wxRE_ADVANCED;
#else
int re_flags = wxRE_DEFAULT;
#endif
wxString replaceWith = m_replaceWith->GetValue();
if(!replaceWith.IsEmpty()) {
clConfig::Get().AddQuickFindReplaceItem(replaceWith);
DoUpdateReplaceHistory();
}
size_t replacementLen = replaceWith.length();
if(searchFlags & wxSTC_FIND_REGEXP) {
// Regular expresson search
if(!(searchFlags & wxSTC_FIND_MATCHCASE)) {
re_flags |= wxRE_ICASE;
}
wxRegEx re(findwhat, re_flags);
if(re.IsValid() && re.Matches(selectedText)) {
re.Replace(&selectedText, replaceWith);
// Keep the replacement length
replacementLen = selectedText.length();
// update the view
m_sci->Replace(selStart, selEnd, selectedText);
} else {
return;
}
} else {
// Normal search and replace
m_sci->Replace(selStart, selEnd, replaceWith);
}
// Clear the selection
m_sci->ClearSelections();
m_sci->SetCurrentPos(selStart + replacementLen);
// Trigger another search
DoSearch(kSearchForward);
}
/**
* Search with several start positions
*/
IPath::SearchResult CPathFinder::GetPath(
const MoveData& moveData,
const std::vector<float3>& startPos,
const CPathFinderDef& pfDef,
IPath::Path& path,
int ownerId,
bool synced
) {
// Clear the given path.
path.path.clear();
path.squares.clear();
path.pathCost = PATHCOST_INFINITY;
// Store som basic data.
maxSquaresToBeSearched = MAX_SEARCHED_NODES_PF - 8U;
testMobile = false;
exactPath = true;
needPath = true;
// If exact path is reqired and the goal is blocked, then no search is needed.
if (exactPath && pfDef.GoalIsBlocked(moveData, (CMoveMath::BLOCK_STRUCTURE | CMoveMath::BLOCK_TERRAIN)))
return IPath::CantGetCloser;
// If the starting position is a goal position, then no search need to be performed.
if (pfDef.IsGoal(startxSqr, startzSqr))
return IPath::CantGetCloser;
// Clearing the system from last search.
ResetSearch();
openSquareBuffer.SetSize(0);
for (std::vector<float3>::const_iterator si = startPos.begin(); si != startPos.end(); ++si) {
start = *si;
startxSqr = (int(start.x) / SQUARE_SIZE) | 1;
startzSqr = (int(start.z) / SQUARE_SIZE) | 1;
startSquare = startxSqr + startzSqr * gs->mapx;
goalSquare = startSquare;
squareStates[startSquare].nodeMask = (PATHOPT_START | PATHOPT_OPEN);
squareStates[startSquare].fCost = 0.0f;
squareStates[startSquare].gCost = 0.0f;
dirtySquares.push_back(startSquare);
if (openSquareBuffer.GetSize() >= MAX_SEARCHED_NODES_PF) {
continue;
}
PathNode* os = openSquareBuffer.GetNode(openSquareBuffer.GetSize());
os->fCost = 0.0f;
os->gCost = 0.0f;
os->nodePos.x = startxSqr;
os->nodePos.y = startzSqr;
os->nodeNum = startSquare;
openSquareBuffer.SetSize(openSquareBuffer.GetSize() + 1);
openSquares.push(os);
}
// note: DoSearch, not InitSearch
IPath::SearchResult result = DoSearch(moveData, pfDef, ownerId, synced);
// Respond to the success of the search.
if (result == IPath::Ok) {
FinishSearch(moveData, path);
if (PATHDEBUG) {
LogObject() << "Path found.\n";
LogObject() << "Nodes tested: " << testedNodes << "\n";
LogObject() << "Open squares: " << openSquareBuffer.GetSize() << "\n";
LogObject() << "Path nodes: " << path.path.size() << "\n";
LogObject() << "Path cost: " << path.pathCost << "\n";
}
} else {
if (PATHDEBUG) {
LogObject() << "No path found!\n";
LogObject() << "Nodes tested: " << testedNodes << "\n";
LogObject() << "Open squares: " << openSquareBuffer.GetSize() << "\n";
}
}
return result;
}
void CContactPage::OnSearchCancel(wxCommandEvent&)
{
m_searchCtrl->Clear();
DoSearch();
}
int main ()
{
// threads should be initialized before memory allocations
char cTopOfMainStack;
sphThreadInit();
MemorizeStack ( &cTopOfMainStack );
CSphString sError;
CSphDictSettings tDictSettings;
ISphTokenizer * pTok = sphCreateUTF8Tokenizer();
CSphDict * pDict = sphCreateDictionaryCRC ( tDictSettings, pTok, sError, "rt1" );
CSphSource * pSrc = SpawnSource ( "SELECT id, channel_id, UNIX_TIMESTAMP(published) published, title, UNCOMPRESS(content) content FROM posting WHERE id<=10000 AND id%2=0", pTok, pDict );
ISphTokenizer * pTok2 = sphCreateUTF8Tokenizer();
CSphDict * pDict2 = sphCreateDictionaryCRC ( tDictSettings, pTok, sError, "rt2" );
CSphSource * pSrc2 = SpawnSource ( "SELECT id, channel_id, UNIX_TIMESTAMP(published) published, title, UNCOMPRESS(content) content FROM posting WHERE id<=10000 AND id%2=1", pTok2, pDict2 );
CSphSchema tSrcSchema;
if ( !pSrc->UpdateSchema ( &tSrcSchema, sError ) )
sphDie ( "update-schema failed: %s", sError.cstr() );
CSphSchema tSchema; // source schema must be all dynamic attrs; but index ones must be static
tSchema.m_dFields = tSrcSchema.m_dFields;
for ( int i=0; i<tSrcSchema.GetAttrsCount(); i++ )
tSchema.AddAttr ( tSrcSchema.GetAttr(i), false );
CSphConfigSection tRTConfig;
sphRTInit();
sphRTConfigure ( tRTConfig, true );
SmallStringHash_T< CSphIndex * > dTemp;
sphReplayBinlog ( dTemp, 0 );
ISphRtIndex * pIndex = sphCreateIndexRT ( tSchema, "testrt", 32*1024*1024, "data/dump", false );
pIndex->SetTokenizer ( pTok ); // index will own this pair from now on
pIndex->SetDictionary ( pDict );
if ( !pIndex->Prealloc ( false, false, sError ) )
sphDie ( "prealloc failed: %s", pIndex->GetLastError().cstr() );
g_pIndex = pIndex;
// initial indexing
int64_t tmStart = sphMicroTimer();
SphThread_t t1, t2;
sphThreadCreate ( &t1, IndexingThread, pSrc );
sphThreadCreate ( &t2, IndexingThread, pSrc2 );
sphThreadJoin ( &t1 );
sphThreadJoin ( &t2 );
#if 0
// update
tParams.m_sQuery = "SELECT id, channel_id, UNIX_TIMESTAMP(published) published, title, UNCOMPRESS(content) content FROM rt2 WHERE id<=10000";
SetupIndexing ( pSrc, tParams );
DoIndexing ( pSrc, pIndex );
#endif
// search
DoSearch ( pIndex );
// shutdown index (should cause dump)
int64_t tmShutdown = sphMicroTimer();
#if SPH_ALLOCS_PROFILER
printf ( "pre-shutdown allocs=%d, bytes="INT64_FMT"\n", sphAllocsCount(), sphAllocBytes() );
#endif
SafeDelete ( pIndex );
#if SPH_ALLOCS_PROFILER
printf ( "post-shutdown allocs=%d, bytes="INT64_FMT"\n", sphAllocsCount(), sphAllocBytes() );
#endif
int64_t tmEnd = sphMicroTimer();
printf ( "shutdown done in %d.%03d sec\n", (int)((tmEnd-tmShutdown)/1000000), (int)(((tmEnd-tmShutdown)%1000000)/1000) );
printf ( "total with shutdown %d.%03d sec, %.2f MB/sec\n",
(int)((tmEnd-tmStart)/1000000), (int)(((tmEnd-tmStart)%1000000)/1000),
g_fTotalMB*1000000.0f/(tmEnd-tmStart) );
#if SPH_DEBUG_LEAKS || SPH_ALLOCS_PROFILER
sphAllocsStats();
#endif
#if USE_WINDOWS
PROCESS_MEMORY_COUNTERS pmc;
HANDLE hProcess = OpenProcess ( PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, FALSE, GetCurrentProcessId() );
if ( hProcess && GetProcessMemoryInfo ( hProcess, &pmc, sizeof(pmc)) )
{
printf ( "--- peak-wss=%d, peak-pagefile=%d\n", (int)pmc.PeakWorkingSetSize, (int)pmc.PeakPagefileUsage );
}
#endif
SafeDelete ( pIndex );
sphRTDone ();
}
void FindInFilesDialog::OnFind(wxCommandEvent& event)
{
wxUnusedVar(event);
DoSearch();
}
void DoIndexing ( CSphSource * pSrc, ISphRtIndex * pIndex )
{
CSphString sError;
CSphVector<DWORD> dMvas;
int64_t tmStart = sphMicroTimer ();
int64_t tmAvgCommit = 0;
int64_t tmMaxCommit = 0;
int iCommits = 0;
for ( ;; )
{
if ( !pSrc->IterateDocument ( sError ) )
sphDie ( "iterate-document failed: %s", sError.cstr() );
ISphHits * pHitsNext = pSrc->IterateHits ( sError );
if ( !sError.IsEmpty() )
sphDie ( "iterate-hits failed: %s", sError.cstr() );
if ( pSrc->m_tDocInfo.m_iDocID )
pIndex->AddDocument ( pHitsNext, pSrc->m_tDocInfo, NULL, dMvas, sError );
if ( ( pSrc->GetStats().m_iTotalDocuments % COMMIT_STEP )==0 || !pSrc->m_tDocInfo.m_iDocID )
{
int64_t tmCommit = sphMicroTimer();
pIndex->Commit ();
tmCommit = sphMicroTimer()-tmCommit;
iCommits++;
tmAvgCommit += tmCommit;
tmMaxCommit = Max ( tmMaxCommit, tmCommit );
if ( !pSrc->m_tDocInfo.m_iDocID )
{
tmAvgCommit /= iCommits;
break;
}
}
if (!( pSrc->GetStats().m_iTotalDocuments % 100 ))
printf ( "%d docs\r", (int)pSrc->GetStats().m_iTotalDocuments );
static bool bOnce = true;
if ( iCommits*COMMIT_STEP>=5000 && bOnce )
{
printf ( "\n" );
DoSearch ( pIndex );
bOnce = false;
}
}
pSrc->Disconnect();
int64_t tmEnd = sphMicroTimer ();
float fTotalMB = (float)pSrc->GetStats().m_iTotalBytes/1000000.0f;
printf ( "commit-step %d, %d docs, %d bytes, %d.%03d sec, %.2f MB/sec\n",
COMMIT_STEP,
(int)pSrc->GetStats().m_iTotalDocuments,
(int)pSrc->GetStats().m_iTotalBytes,
(int)((tmEnd-tmStart)/1000000), (int)(((tmEnd-tmStart)%1000000)/1000),
fTotalMB*1000000.0f/(tmEnd-tmStart) );
printf ( "commit-docs %d, avg %d.%03d msec, max %d.%03d msec\n", COMMIT_STEP,
(int)(tmAvgCommit/1000), (int)(tmAvgCommit%1000),
(int)(tmMaxCommit/1000), (int)(tmMaxCommit%1000) );
g_fTotalMB += fTotalMB;
}
void Styler_Syntax::ParseAll() {
const unsigned int len = m_doc.GetLength();
if (m_syntax_end < len) {
DoSearch(m_syntax_end, len, len);
}
}
void CDlgManualTask::OnBnClickedBtnSearch()
{
// TODO: 在此添加控件通知处理程序代码
DoSearch();
}
void *SearchForAddressOfSpecialSymbol(const char *SymbolName) {
return DoSearch(SymbolName); // DynamicLibrary.inc
}
void CFindReplaceDlg::DoSearch(CEditorEvent* pEvent, int& Number)
{
int i, j;
if (m_Conditions.GetCheck() == BST_CHECKED)
{
for (j = 0; j < pEvent->m_Conditions.size(); j++)
{
CString Match = pEvent->m_Conditions[j]->m_Text;
Match.MakeLower();
// Matches?
if (Match.Find(m_Text) != -1)
{
CString ItemN;
ItemN.Format("%d", Number + 1);
int Item = m_List.InsertItem(m_List.GetItemCount(), ItemN);
CString Text = pEvent->m_Conditions[j]->m_Text;
Text = StripHTML(Text);
CString Add = "Condition: ";
Add += Text;
m_List.SetItemText(Item, 1, Add);
m_List.SetItemData(Item, (DWORD)pEvent);
}
}
}
if (m_Actions.GetCheck() == BST_CHECKED)
{
for (j = 0; j < pEvent->m_Actions.size(); j++)
{
CString Match = pEvent->m_Actions[j]->m_Text;
Match.MakeLower();
// Matches?
if (Match.Find(m_Text) != -1)
{
CString ItemN;
ItemN.Format("%d", Number + 1);
int Item = m_List.InsertItem(m_List.GetItemCount(), ItemN);
CString Text = pEvent->m_Actions[j]->m_Text;
Text = StripHTML(Text);
CString Add = "Action: ";
Add += Text;
m_List.SetItemText(Item, 1, Add);
m_List.SetItemData(Item, (DWORD)pEvent);
}
}
}
// Loop sub events
for (i = 0; i < pEvent->m_EventList.size(); i++)
{
CEditorEvent* pSubEvent = pEvent->m_EventList[i];
// Comments etc dont increment number
if (pSubEvent->m_type == 0 || pSubEvent->m_type == 4)
Number++;
DoSearch(pSubEvent, Number);
}
}
