← Back to branch summary

~ubuntu-branches/ubuntu/hardy/codeblocks/hardy-backports

« back to all changes in this revision

Viewing changes to src/plugins/contrib/ThreadSearch/ThreadSearchLoggerTree.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Michael Casadevall
  • Date: 2008-07-17 04:39:23 UTC
  • Revision ID: james.westby@ubuntu.com-20080717043923-gmsy5cwkdjswghkm
Tags: upstream-8.02
Import upstream version 8.02

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/plugins/contrib/ThreadSearch/ThreadSearchLoggerTree.cpp
 
1
/***************************************************************
 
2
 * Name:      ThreadSearchLoggerTree
 
3
 * Purpose:   ThreadSearchLoggerTree implements the
 
4
 *            ThreadSearchLoggerBase interface with a wxTreeCtrl.
 
5
 * Author:    Jerome ANTOINE
 
6
 * Created:   2007-07-28
 
7
 * Copyright: Jerome ANTOINE
 
8
 * License:   GPL
 
9
 **************************************************************/
 
10
 
 
11
#include <sdk.h> // Code::Blocks SDK
 
12
#ifndef CB_PRECOMP
 
13
        // Required extra includes
 
14
#endif
 
15
 
 
16
#include "ThreadSearchLoggerTree.h"
 
17
#include "ThreadSearchEvent.h"
 
18
#include "ThreadSearchView.h"
 
19
 
 
20
ThreadSearchLoggerTree::ThreadSearchLoggerTree(ThreadSearchView& threadSearchView,
 
21
                                                                                           ThreadSearch& threadSearchPlugin,
 
22
                                                                                           InsertIndexManager::eFileSorting fileSorting,
 
23
                                                                                           wxPanel* pParent,
 
24
                                                                                           long id)
 
25
                                           : ThreadSearchLoggerBase(threadSearchView, threadSearchPlugin, fileSorting)
 
26
                                           , m_pTreeLog(NULL)
 
27
                                           , m_FirstItemProcessed(false)
 
28
{
 
29
    m_pTreeLog = new wxTreeCtrl(pParent, id, wxDefaultPosition, wxSize(1,1), wxTR_HAS_BUTTONS|wxTR_LINES_AT_ROOT|wxTR_FULL_ROW_HIGHLIGHT|wxTR_HIDE_ROOT|wxTR_DEFAULT_STYLE|wxSUNKEN_BORDER);
 
30
    m_pTreeLog->SetMinSize(wxSize(100, 100));
 
31
    m_pTreeLog->AddRoot(wxEmptyString);
 
32
 
 
33
        // Events are managed dynamically to be able to stop/start management when required.
 
34
        ConnectEvents(pParent);
 
35
}
 
36
 
 
37
 
 
38
ThreadSearchLoggerTree::~ThreadSearchLoggerTree()
 
39
{
 
40
        wxWindow* pParent = m_pTreeLog->GetParent();
 
41
        if ( pParent != NULL )
 
42
        {
 
43
                // Events are managed dynamically to be able to stop/start management when required.
 
44
                DisconnectEvents(pParent);
 
45
        }
 
46
        m_pTreeLog->Destroy();
 
47
        m_pTreeLog = NULL;
 
48
}
 
49
 
 
50
 
 
51
wxWindow* ThreadSearchLoggerTree::GetWindow()
 
52
{
 
53
        return m_pTreeLog;
 
54
}
 
55
 
 
56
 
 
57
void ThreadSearchLoggerTree::SetFocus()
 
58
{
 
59
        m_pTreeLog->SetFocus();
 
60
}
 
61
 
 
62
 
 
63
void ThreadSearchLoggerTree::ConnectEvents(wxEvtHandler* pEvtHandler)
 
64
{
 
65
        // Dynamic event connections.
 
66
        int id = m_pTreeLog->GetId();
 
67
        pEvtHandler->Connect(id, wxEVT_COMMAND_TREE_SEL_CHANGED,
 
68
                        (wxObjectEventFunction)(wxEventFunction)(wxCommandEventFunction)
 
69
                        &ThreadSearchLoggerTree::OnLoggerTreeClick, NULL, this);
 
70
 
 
71
        pEvtHandler->Connect(id, wxEVT_COMMAND_TREE_ITEM_ACTIVATED,
 
72
                        (wxObjectEventFunction)(wxEventFunction)(wxCommandEventFunction)
 
73
                        &ThreadSearchLoggerTree::OnLoggerTreeDoubleClick, NULL, this);
 
74
}
 
75
 
 
76
 
 
77
void ThreadSearchLoggerTree::DisconnectEvents(wxEvtHandler* pEvtHandler)
 
78
{
 
79
        // Dynamic event disconnections.
 
80
        int id = m_pTreeLog->GetId();
 
81
        pEvtHandler->Disconnect(id, wxEVT_COMMAND_TREE_SEL_CHANGED,
 
82
                        (wxObjectEventFunction)(wxEventFunction)(wxCommandEventFunction)
 
83
                        &ThreadSearchLoggerTree::OnLoggerTreeClick, NULL, this);
 
84
 
 
85
        pEvtHandler->Disconnect(id, wxEVT_COMMAND_TREE_ITEM_ACTIVATED,
 
86
                        (wxObjectEventFunction)(wxEventFunction)(wxCommandEventFunction)
 
87
                        &ThreadSearchLoggerTree::OnLoggerTreeDoubleClick, NULL, this);
 
88
}
 
89
 
 
90
 
 
91
void ThreadSearchLoggerTree::OnLoggerTreeClick(wxTreeEvent& event)
 
92
{
 
93
        // Manages list log left double click
 
94
    // Gets file path and line from list control
 
95
    wxString filepath(wxEmptyString);
 
96
    long line;
 
97
    if ( GetFileLineFromTreeEvent(event, filepath, line) == false )
 
98
    {
 
99
                cbMessageBox(wxT("Failed to retrieve file path and line number"), wxT("Error"), wxICON_ERROR);
 
100
        return;
 
101
    }
 
102
    m_ThreadSearchView.OnLoggerClick(filepath, line);
 
103
    event.Skip();
 
104
}
 
105
 
 
106
 
 
107
void ThreadSearchLoggerTree::OnLoggerTreeDoubleClick(wxTreeEvent& event)
 
108
{
 
109
        // Manages list log left double click
 
110
    // Gets file path and line from list control
 
111
    wxString filepath(wxEmptyString);
 
112
    long line;
 
113
    if ( GetFileLineFromTreeEvent(event, filepath, line) == false )
 
114
    {
 
115
                cbMessageBox(wxT("Failed to retrieve file path and line number"), wxT("Error"), wxICON_ERROR);
 
116
        return;
 
117
    }
 
118
    m_ThreadSearchView.OnLoggerDoubleClick(filepath, line);
 
119
 
 
120
    event.Skip();
 
121
}
 
122
 
 
123
 
 
124
bool ThreadSearchLoggerTree::GetFileLineFromTreeEvent(wxTreeEvent& event, wxString& filepath, long &line)
 
125
{
 
126
        wxTreeItemId lineItemId;
 
127
        wxTreeItemId fileItemId;
 
128
        wxTreeItemId rootItemId = m_pTreeLog->GetRootItem();
 
129
        wxTreeItemId eventItemId = event.GetItem();
 
130
        bool success(false);
 
131
 
 
132
        filepath = wxEmptyString;
 
133
        line = 0;
 
134
 
 
135
        do
 
136
        {
 
137
                // We test if we are on a file item or a line item.
 
138
                // As root is hidden, we have only file and line items on tree.
 
139
                if ( m_pTreeLog->GetItemParent(eventItemId) == rootItemId )
 
140
                {
 
141
                        fileItemId = eventItemId;
 
142
                        wxTreeItemIdValue cookie;
 
143
                        lineItemId = m_pTreeLog->GetFirstChild(eventItemId, cookie);
 
144
                        if ( lineItemId.IsOk() == false )
 
145
                                break;
 
146
                }
 
147
                else
 
148
                {
 
149
                        lineItemId = eventItemId;
 
150
                        fileItemId = m_pTreeLog->GetItemParent(lineItemId);
 
151
                }
 
152
 
 
153
                // We extract line and file path values
 
154
                // Look at ThreadSearchLoggerTree::OnThreadSearchEvent to have format
 
155
 
 
156
                // Line:
 
157
                const wxString& lineText = m_pTreeLog->GetItemText(lineItemId);
 
158
                int columnPos = lineText.Find(':');
 
159
                if ( columnPos == wxNOT_FOUND )
 
160
                        break;
 
161
 
 
162
                if ( lineText.Left(columnPos).ToLong(&line) == false )
 
163
                        break;
 
164
 
 
165
                // File:
 
166
                const wxString& fileText = m_pTreeLog->GetItemText(fileItemId);
 
167
                int fileLength = fileText.Find(wxT(" ("));
 
168
                if ( fileLength == wxNOT_FOUND )
 
169
                        break;
 
170
 
 
171
                int dirBegin   = fileLength + 2; // 2 for " ("
 
172
                int dirLength  = fileText.Length() - dirBegin - 1;
 
173
                if ( dirLength <= 0 )
 
174
                        break;
 
175
 
 
176
                wxFileName filename(fileText.Mid(dirBegin, dirLength), fileText.Left(fileLength));
 
177
                filepath = filename.GetFullPath();
 
178
 
 
179
                success = true;
 
180
        } while ( false );
 
181
 
 
182
        return success;
 
183
}
 
184
 
 
185
 
 
186
void ThreadSearchLoggerTree::OnThreadSearchEvent(const ThreadSearchEvent& event)
 
187
{
 
188
        // A search event has been sent by the worker thread.
 
189
        // Tree log upddate
 
190
        const wxArrayString& words  = event.GetLineTextArray();
 
191
        const wxFileName&    filename(event.GetString());
 
192
        bool                 setFocus(false);
 
193
        wxTreeItemId         rootItemId(m_pTreeLog->GetRootItem());
 
194
        wxTreeItemId         fileItemId;
 
195
        long                 index    = m_IndexManager.GetInsertionIndex(filename.GetFullPath());
 
196
        long                 nb_items = m_pTreeLog->GetChildrenCount(rootItemId, false);
 
197
 
 
198
        wxASSERT(index != wxNOT_FOUND);
 
199
        wxASSERT((words.GetCount() % 2) == 0);
 
200
 
 
201
        // Use of Freeze Thaw to enhance speed and limit blink effect
 
202
        m_pTreeLog->Freeze();
 
203
        wxTreeItemId lineItemId;
 
204
 
 
205
        if ( index == nb_items )
 
206
        {
 
207
                fileItemId = m_pTreeLog->AppendItem(rootItemId,
 
208
                                                                                                         wxString::Format(wxT("%s (%s)"),
 
209
                                                                                                                                          filename.GetFullName().c_str(),
 
210
                                                                                                                                          filename.GetPath().c_str()));
 
211
        }
 
212
        else
 
213
        {
 
214
                fileItemId = m_pTreeLog->InsertItem(rootItemId, index,
 
215
                                                                                        wxString::Format(wxT("%s (%s)"),
 
216
                                                                                                                         filename.GetFullName().c_str(),
 
217
                                                                                                                         filename.GetPath().c_str()));
 
218
        }
 
219
 
 
220
        for (size_t i = 0; i < words.GetCount(); i += 2)
 
221
        {
 
222
                lineItemId = m_pTreeLog->AppendItem(fileItemId, wxString::Format(wxT("%s: %s"),
 
223
                                                                                                                                                 words[i].c_str(),     // Line index starting from 1
 
224
                                                                                                                                                 words[i+1].c_str())); // File line matching search expression
 
225
 
 
226
                // We update preview log for first list item
 
227
                if ( (m_FirstItemProcessed == false)                        &&
 
228
                         (m_pTreeLog->GetChildrenCount(fileItemId, false) == 1) &&
 
229
                         (m_pTreeLog->GetChildrenCount(rootItemId, false) == 1) )
 
230
                {
 
231
                        // Expand first file item
 
232
                        m_pTreeLog->Expand(fileItemId);
 
233
 
 
234
                        // Select first item (generates selection event to update ThreadSearchView code preview)
 
235
                        m_pTreeLog->SelectItem(lineItemId);
 
236
 
 
237
                        // to avoid lots of preview that freezes app
 
238
                        m_FirstItemProcessed = true;
 
239
 
 
240
                        // It is useful to give focus to tree to navigate in results
 
241
                        // just after running a search
 
242
                        setFocus = true;
 
243
                }
 
244
        }
 
245
        m_pTreeLog->Thaw();
 
246
 
 
247
        if ( setFocus == true )
 
248
        {
 
249
                // On Linux, executing SetFocus just after SelectItem
 
250
                // does not work. Probbly because of Thaw...
 
251
                m_pTreeLog->SetFocus();
 
252
        }
 
253
}
 
254
 
 
255
 
 
256
void ThreadSearchLoggerTree::Clear()
 
257
{
 
258
        // As wxTreeCtrl::DeleteChildren sends lots of selected events
 
259
        // and because we don't want any wxTreeCtrl event to be processed
 
260
        // during delete, we disable events management during tree cleaning
 
261
        // (DisconnectEvents then ConnectEvents).
 
262
        wxWindow* pParent = m_pTreeLog->GetParent();
 
263
        if ( pParent == NULL ) return;
 
264
 
 
265
        DisconnectEvents(pParent);
 
266
 
 
267
    m_pTreeLog->DeleteChildren(m_pTreeLog->GetRootItem());
 
268
    m_FirstItemProcessed = false;
 
269
 
 
270
    m_IndexManager.Reset();
 
271
 
 
272
    ConnectEvents(pParent);
 
273
}