← Back to branch summary

~efargaspro/+junk/codeblocks-16.01-release

« back to all changes in this revision

Viewing changes to src/plugins/contrib/FortranProject/workspacebrowserbuilder.cpp

  • Committer: damienlmoore at gmail
  • Date: 2016-02-02 02:43:22 UTC
  • Revision ID: damienlmoore@gmail.com-20160202024322-yql5qmtbwdyamdwd
Code::Blocks 16.01

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/plugins/contrib/FortranProject/workspacebrowserbuilder.cpp
 
1
/*
 
2
 * This file is licensed under the GNU General Public License, version 3
 
3
 * http://www.gnu.org/licenses/gpl-3.0.html
 
4
 *
 
5
 */
 
6
 
 
7
#include <sdk.h>
 
8
#include "workspacebrowserbuilder.h"
 
9
#include <globals.h>
 
10
#include <manager.h>
 
11
#include <projectmanager.h>
 
12
#include <cbproject.h>
 
13
 
 
14
#include <wx/settings.h>
 
15
#include <wx/utils.h>
 
16
#include <wx/string.h>
 
17
#include <string>
 
18
 
 
19
namespace compatibility { typedef TernaryCondTypedef<wxMinimumVersion<2,5>::eval, wxTreeItemIdValue, long int>::eval tree_cookie_t; };
 
20
 
 
21
WorkspaceBrowserBuilder::WorkspaceBrowserBuilder(ParserF* parser, wxTreeCtrl* treeTop, wxTreeCtrl* treeBottom)
 
22
    : m_pActiveProject(0),
 
23
    m_Options()
 
24
{
 
25
    m_AtWork = false;
 
26
    m_pImlist = new wxImageList(16, 16);
 
27
    wxBitmap bmp;
 
28
    wxString prefix2;
 
29
    prefix2 = ConfigManager::GetDataFolder() + _T("/images/fortranproject/");
 
30
 
 
31
    bmp = cbLoadBitmap(prefix2 + _T("ctor_public.png"), wxBITMAP_TYPE_PNG);
 
32
    m_pImlist->Add(bmp);
 
33
    m_ImgNr["use"] = 0;
 
34
    bmp = cbLoadBitmap(prefix2 + _T("class_public.png"), wxBITMAP_TYPE_PNG);
 
35
    m_pImlist->Add(bmp);
 
36
    m_ImgNr["module"] = 1;
 
37
    bmp = cbLoadBitmap(prefix2 + _T("method_public.png"), wxBITMAP_TYPE_PNG);
 
38
    m_pImlist->Add(bmp);
 
39
    m_ImgNr["subroutine"] = 2;
 
40
    bmp = cbLoadBitmap(prefix2 + _T("method_protected.png"), wxBITMAP_TYPE_PNG);
 
41
    m_pImlist->Add(bmp);
 
42
    m_ImgNr["function"] = 3;
 
43
    bmp = cbLoadBitmap(prefix2 + _T("method_private.png"), wxBITMAP_TYPE_PNG);
 
44
    m_pImlist->Add(bmp);
 
45
    m_ImgNr["program"] = 4;
 
46
    bmp = cbLoadBitmap(prefix2 + _T("typedef.png"), wxBITMAP_TYPE_PNG);
 
47
    m_pImlist->Add(bmp);
 
48
    m_ImgNr["type"] = 5;
 
49
    bmp = cbLoadBitmap(prefix2 + _T("interface.png"), wxBITMAP_TYPE_PNG);
 
50
    m_pImlist->Add(bmp);
 
51
    m_ImgNr["interface"] = 6;
 
52
    bmp = cbLoadBitmap(prefix2 + _T("funcs_folder.png"), wxBITMAP_TYPE_PNG);
 
53
    m_pImlist->Add(bmp);
 
54
    m_ImgNr["function_folder"] = 7;
 
55
    bmp = cbLoadBitmap(prefix2 + _T("others_folder.png"), wxBITMAP_TYPE_PNG);
 
56
    m_pImlist->Add(bmp);
 
57
    m_ImgNr["others_folder"] = 8;
 
58
    bmp = cbLoadBitmap(prefix2 + _T("symbols_folder.png"), wxBITMAP_TYPE_PNG);
 
59
    m_pImlist->Add(bmp);
 
60
    m_ImgNr["symbols_folder"] = 9;
 
61
    bmp = cbLoadBitmap(prefix2 + _T("preproc.png"), wxBITMAP_TYPE_PNG);
 
62
    m_pImlist->Add(bmp);
 
63
    m_ImgNr["preproc"] = 10;
 
64
    bmp = cbLoadBitmap(prefix2 + _T("var_public.png"), wxBITMAP_TYPE_PNG);
 
65
    m_pImlist->Add(bmp);
 
66
    m_ImgNr["variable"] = 11;
 
67
    bmp = cbLoadBitmap(prefix2 + _T("interface_function.png"), wxBITMAP_TYPE_PNG);
 
68
    m_pImlist->Add(bmp);
 
69
    m_ImgNr["interface_function"] = 12;
 
70
    bmp = cbLoadBitmap(prefix2 + _T("interface_subroutine.png"), wxBITMAP_TYPE_PNG);
 
71
    m_pImlist->Add(bmp);
 
72
    m_ImgNr["interface_subroutine"] = 13;
 
73
    bmp = cbLoadBitmap(prefix2 + _T("procedure.png"), wxBITMAP_TYPE_PNG);
 
74
    m_pImlist->Add(bmp);
 
75
    m_ImgNr["procedure"] = 14;
 
76
 
 
77
    bmp = cbLoadBitmap(prefix2 + _T("subroutine_private.png"), wxBITMAP_TYPE_PNG);
 
78
    m_pImlist->Add(bmp);
 
79
    m_ImgNr["subroutine_private"] = 15;
 
80
    bmp = cbLoadBitmap(prefix2 + _T("function_private.png"), wxBITMAP_TYPE_PNG);
 
81
    m_pImlist->Add(bmp);
 
82
    m_ImgNr["function_private"] = 16;
 
83
    bmp = cbLoadBitmap(prefix2 + _T("var_private.png"), wxBITMAP_TYPE_PNG);
 
84
    m_pImlist->Add(bmp);
 
85
    m_ImgNr["variable_private"] = 17;
 
86
    bmp = cbLoadBitmap(prefix2 + _T("var_protected.png"), wxBITMAP_TYPE_PNG);
 
87
    m_pImlist->Add(bmp);
 
88
    m_ImgNr["variable_protected"] = 18;
 
89
    bmp = cbLoadBitmap(prefix2 + _T("typedef_private.png"), wxBITMAP_TYPE_PNG);
 
90
    m_pImlist->Add(bmp);
 
91
    m_ImgNr["type_private"] = 19;
 
92
    bmp = cbLoadBitmap(prefix2 + _T("interface_private.png"), wxBITMAP_TYPE_PNG);
 
93
    m_pImlist->Add(bmp);
 
94
    m_ImgNr["interface_private"] = 20;
 
95
    bmp = cbLoadBitmap(prefix2 + _T("access_list_private.png"), wxBITMAP_TYPE_PNG);
 
96
    m_pImlist->Add(bmp);
 
97
    m_ImgNr["access_list_private"] = 21;
 
98
    bmp = cbLoadBitmap(prefix2 + _T("access_list_public.png"), wxBITMAP_TYPE_PNG);
 
99
    m_pImlist->Add(bmp);
 
100
    m_ImgNr["access_list_public"] = 22;
 
101
    bmp = cbLoadBitmap(prefix2 + _T("access_list_protected.png"), wxBITMAP_TYPE_PNG);
 
102
    m_pImlist->Add(bmp);
 
103
    m_ImgNr["access_list_protected"] = 23;
 
104
    bmp = cbLoadBitmap(prefix2 + _T("procedure_private.png"), wxBITMAP_TYPE_PNG);
 
105
    m_pImlist->Add(bmp);
 
106
    m_ImgNr["procedure_private"] = 24;
 
107
    bmp = cbLoadBitmap(prefix2 + _T("interface_function_private.png"), wxBITMAP_TYPE_PNG);
 
108
    m_pImlist->Add(bmp);
 
109
    m_ImgNr["interface_function_private"] = 25;
 
110
    bmp = cbLoadBitmap(prefix2 + _T("interface_subroutine_private.png"), wxBITMAP_TYPE_PNG);
 
111
    m_pImlist->Add(bmp);
 
112
    m_ImgNr["interface_subroutine_private"] = 26;
 
113
    bmp = cbLoadBitmap(prefix2 + _T("class.png"), wxBITMAP_TYPE_PNG);
 
114
    m_pImlist->Add(bmp);
 
115
    m_ImgNr["submodule"] = 27;
 
116
    bmp = cbLoadBitmap(prefix2 + _T("interface_subroutine_gen_private.png"), wxBITMAP_TYPE_PNG);
 
117
    m_pImlist->Add(bmp);
 
118
    m_ImgNr["interface_sub_gen_private"] = 28;
 
119
    bmp = cbLoadBitmap(prefix2 + _T("interface_subroutine_gen.png"), wxBITMAP_TYPE_PNG);
 
120
    m_pImlist->Add(bmp);
 
121
    m_ImgNr["interface_sub_gen"] = 29;
 
122
    bmp = cbLoadBitmap(prefix2 + _T("interface_function_gen_private.png"), wxBITMAP_TYPE_PNG);
 
123
    m_pImlist->Add(bmp);
 
124
    m_ImgNr["interface_fun_gen_private"] = 30;
 
125
    bmp = cbLoadBitmap(prefix2 + _T("interface_function_gen.png"), wxBITMAP_TYPE_PNG);
 
126
    m_pImlist->Add(bmp);
 
127
    m_ImgNr["interface_fun_gen"] = 31;
 
128
    bmp = cbLoadBitmap(prefix2 + _T("typedef_abstract.png"), wxBITMAP_TYPE_PNG);
 
129
    m_pImlist->Add(bmp);
 
130
    m_ImgNr["type_abstract"] = 32;
 
131
    bmp = cbLoadBitmap(prefix2 + _T("typedef_abstract_private.png"), wxBITMAP_TYPE_PNG);
 
132
    m_pImlist->Add(bmp);
 
133
    m_ImgNr["type_abstract_private"] = 33;
 
134
    bmp = cbLoadBitmap(prefix2 + _T("dtor_public.png"), wxBITMAP_TYPE_PNG);
 
135
    m_pImlist->Add(bmp);
 
136
    m_ImgNr["procedure_final"] = 34;
 
137
 
 
138
    m_ImgNr["none"] = -1;
 
139
 
 
140
    m_pParser = parser;
 
141
    m_pTreeTop = treeTop;
 
142
    m_pTreeBottom = treeBottom;
 
143
    m_pTreeTop->SetImageList(m_pImlist);
 
144
    m_pTreeBottom->SetImageList(m_pImlist);
 
145
}
 
146
 
 
147
WorkspaceBrowserBuilder::~WorkspaceBrowserBuilder()
 
148
{
 
149
    //dtor
 
150
    delete m_pImlist;
 
151
}
 
152
 
 
153
void WorkspaceBrowserBuilder::Init(const wxString& active_filename,
 
154
                                    cbProject* active_project,
 
155
                                    const BrowserOptions& options)
 
156
{
 
157
    m_ActiveFilename = active_filename;
 
158
    m_pActiveProject = active_project;
 
159
    m_Options = options;
 
160
 
 
161
    BuildTree();
 
162
}
 
163
 
 
164
void WorkspaceBrowserBuilder::BuildTree()
 
165
{
 
166
    if (Manager::IsAppShuttingDown())
 
167
        return;
 
168
 
 
169
    m_AtWork = true;
 
170
 
 
171
    wxTreeItemId root = m_pTreeTop->GetRootItem();
 
172
    if (!root.IsOk())
 
173
    {
 
174
        root = m_pTreeTop->AddRoot(_("Symbols"), m_ImgNr["symbols_folder"], m_ImgNr["symbols_folder"], new TreeDataF(sfRoot));
 
175
        m_pTreeTop->SetItemHasChildren(root);
 
176
    }
 
177
 
 
178
    wxString oldSelText;
 
179
    wxString oldParentText;
 
180
    bool oldParent_isRoot = false;
 
181
    wxTreeItemId oldSel = m_pTreeTop->GetSelection();
 
182
    if (oldSel.IsOk())
 
183
    {
 
184
        oldSelText = m_pTreeTop->GetItemText(oldSel);
 
185
        wxTreeItemId oldParent = m_pTreeTop->GetItemParent(oldSel);
 
186
        oldParent_isRoot = (root == oldParent);
 
187
        if (oldParent.IsOk())
 
188
        {
 
189
            oldParentText = m_pTreeTop->GetItemText(oldParent);
 
190
        }
 
191
    }
 
192
 
 
193
    m_pTreeTop->Hide();
 
194
    m_pTreeTop->Freeze();
 
195
    wxArrayString expandedBottomNodes;
 
196
    if (m_Options.visibleBottomTree)
 
197
    {
 
198
        MakeExpandedNodesArray(expandedBottomNodes);
 
199
        m_pTreeBottom->Hide();
 
200
        m_pTreeBottom->Freeze();
 
201
    }
 
202
 
 
203
    m_pTreeTop->DeleteChildren(root);
 
204
 
 
205
    wxTreeItemId root_bot = m_pTreeBottom->GetRootItem();
 
206
    if (root_bot.IsOk())
 
207
        m_pTreeBottom->DeleteChildren(root_bot);
 
208
 
 
209
    if (!Manager::IsAppShuttingDown())
 
210
    {
 
211
        ExpandTop();
 
212
        m_pTreeTop->Expand(root);
 
213
        if (!m_Options.visibleBottomTree)
 
214
        {
 
215
            size_t i=0;
 
216
            while ( i < m_ExpandedNodes.GetCount() )
 
217
            {
 
218
                wxTreeItemId item = FindItemByName(m_pTreeTop, m_ExpandedNodes[i]);
 
219
                if (item.IsOk())
 
220
                {
 
221
                    m_pTreeTop->Expand(item);
 
222
                    i++;
 
223
                }
 
224
                else
 
225
                {
 
226
                    m_ExpandedNodes.RemoveAt(i);
 
227
                }
 
228
            }
 
229
        }
 
230
        else
 
231
            m_ExpandedNodes.Clear();
 
232
    }
 
233
 
 
234
    if (m_Options.visibleBottomTree)
 
235
    {
 
236
        m_pTreeBottom->Thaw();
 
237
        m_pTreeBottom->Show();
 
238
    }
 
239
 
 
240
    m_pTreeTop->Thaw();
 
241
    m_pTreeTop->Show();
 
242
 
 
243
    m_AtWork = false;
 
244
 
 
245
    if (!oldSelText.IsEmpty())
 
246
    {
 
247
        if ( !oldParent_isRoot )
 
248
        {
 
249
            wxTreeItemId item = FindItemByName(m_pTreeTop, oldParentText, oldSelText); // refresh selection
 
250
            if (item.IsOk())
 
251
                m_pTreeTop->SelectItem(item);
 
252
        }
 
253
        else
 
254
        {
 
255
            wxTreeItemId item = FindItemByName(m_pTreeTop, oldSelText); // refresh selection
 
256
            if (item.IsOk())
 
257
            {
 
258
                m_pTreeTop->SelectItem(item);
 
259
                ExpandBottomNodes(expandedBottomNodes);
 
260
            }
 
261
        }
 
262
    }
 
263
}
 
264
 
 
265
void WorkspaceBrowserBuilder::DeleteTopRootChildren()
 
266
{
 
267
    if (Manager::IsAppShuttingDown())
 
268
        return;
 
269
 
 
270
    wxTreeItemId root = m_pTreeTop->GetRootItem();
 
271
    if (root.IsOk())
 
272
    {
 
273
        m_pTreeTop->DeleteChildren(root);
 
274
    }
 
275
}
 
276
 
 
277
void WorkspaceBrowserBuilder::MakeExpandedNodesArray(wxArrayString &expandedBottomNodes)
 
278
{
 
279
    if (!m_Options.visibleBottomTree)
 
280
        return;
 
281
 
 
282
    wxTreeItemIdValue cookie;
 
283
    wxTreeItemId root = m_pTreeBottom->GetRootItem();
 
284
    if (!root.IsOk())
 
285
        return;
 
286
    wxTreeItemId item = m_pTreeBottom->GetFirstChild(root, cookie);
 
287
    while (item.IsOk())
 
288
    {
 
289
        if (m_pTreeBottom->IsExpanded(item))
 
290
        {
 
291
            wxTreeItemIdValue cookie2;
 
292
            wxTreeItemId item2 = m_pTreeBottom->GetFirstChild(item, cookie2);
 
293
            while (item2.IsOk())
 
294
            {
 
295
                if (m_pTreeBottom->IsExpanded(item2))
 
296
                {
 
297
                    expandedBottomNodes.Add(m_pTreeBottom->GetItemText(item));
 
298
                    expandedBottomNodes.Add(m_pTreeBottom->GetItemText(item2));
 
299
                }
 
300
                item2 = m_pTreeBottom->GetNextChild(item, cookie2);
 
301
            }
 
302
        }
 
303
        item = m_pTreeBottom->GetNextChild(root, cookie);
 
304
    }
 
305
}
 
306
 
 
307
void WorkspaceBrowserBuilder::ExpandBottomNodes(wxArrayString &expandedBottomNodes)
 
308
{
 
309
    if (!m_Options.visibleBottomTree)
 
310
        return;
 
311
 
 
312
    for (size_t i=1; i<expandedBottomNodes.Count(); i+=2)
 
313
    {
 
314
        wxTreeItemId item = FindItemByName(m_pTreeBottom, expandedBottomNodes.Item(i-1), expandedBottomNodes.Item(i));
 
315
        if (item.IsOk())
 
316
            m_pTreeBottom->Expand(item);
 
317
    }
 
318
}
 
319
 
 
320
bool WorkspaceBrowserBuilder::HasChildren(TokenF* tokenParent, int tokenKindMask)
 
321
{
 
322
    bool has = false;
 
323
    for (size_t j=0; j < tokenParent->m_Children.GetCount(); ++j)
 
324
    {
 
325
        TokenF* tok1 = tokenParent->m_Children.Item(j);
 
326
        if (tok1->m_TokenKind & tokenKindMask)
 
327
        {
 
328
            has = true;
 
329
            break;
 
330
        }
 
331
    }
 
332
    return has;
 
333
}
 
334
 
 
335
bool WorkspaceBrowserBuilder::HasGlobalFunctionsOthers(int tokenKindMask)
 
336
{
 
337
    bool has = false;
 
338
    if (Manager::IsAppShuttingDown())
 
339
        return has;
 
340
 
 
341
    switch (m_Options.displayFilter)
 
342
    {
 
343
        case bdfFile:
 
344
        {
 
345
            if (!m_ActiveFilename.IsEmpty())
 
346
                has = FileHasTokens(UnixFilename(m_ActiveFilename), tokenKindMask);
 
347
            break;
 
348
        }
 
349
        case bdfProject:
 
350
        {
 
351
            for (FilesList::iterator it = m_pActiveProject->GetFilesList().begin(); it != m_pActiveProject->GetFilesList().end(); ++it)
 
352
            {
 
353
                ProjectFile* pf = *it;
 
354
                if (FileHasTokens(UnixFilename(pf->file.GetFullPath()), tokenKindMask))
 
355
                {
 
356
                    has = true;
 
357
                    break;
 
358
                }
 
359
            }
 
360
            break;
 
361
        }
 
362
        case bdfWorkspace:
 
363
        {
 
364
 
 
365
            TokensArrayF* pTokens = m_pParser->GetTokens();
 
366
            for (size_t i=0; i< pTokens->GetCount(); ++i)
 
367
            {
 
368
                TokenF* token = pTokens->Item(i);
 
369
                if (token->m_TokenKind == tkFile)
 
370
                {
 
371
                    for (size_t j=0; j < token->m_Children.GetCount(); ++j)
 
372
                    {
 
373
                        TokenF* tok1 = token->m_Children.Item(j);
 
374
                        if (tok1->m_TokenKind & tokenKindMask)
 
375
                        {
 
376
                            has = true;
 
377
                            break;
 
378
                        }
 
379
                    }
 
380
                    if (has)
 
381
                        break;
 
382
                }
 
383
            }
 
384
            break;
 
385
        }
 
386
    }
 
387
    return has;
 
388
}
 
389
 
 
390
bool WorkspaceBrowserBuilder::FileHasTokens(const wxString& fileName, int tokenKindMask)
 
391
{
 
392
    TokensArrayF* pTokens = m_pParser->GetTokens();
 
393
    bool has = false;
 
394
 
 
395
    for (size_t i=0; i< pTokens->GetCount(); ++i)
 
396
    {
 
397
        TokenF* token = pTokens->Item(i);
 
398
 
 
399
        if (token->m_TokenKind == tkFile && token->m_Filename.IsSameAs(fileName))
 
400
        {
 
401
            for (size_t j=0; j < token->m_Children.GetCount(); ++j)
 
402
            {
 
403
                TokenF* tok1 = token->m_Children.Item(j);
 
404
                if (tok1->m_TokenKind & tokenKindMask)
 
405
                {
 
406
                    has = true;
 
407
                    break;
 
408
                }
 
409
            }
 
410
            break;
 
411
        }
 
412
    }
 
413
    return has;
 
414
}
 
415
 
 
416
void WorkspaceBrowserBuilder::AddTreeChildren(wxTreeCtrl* tree, wxTreeItemId parent, int tokenKindMask)
 
417
{
 
418
    if (Manager::IsAppShuttingDown())
 
419
        return;
 
420
 
 
421
    switch (m_Options.displayFilter)
 
422
    {
 
423
        case bdfFile:
 
424
        {
 
425
            if (!m_ActiveFilename.IsEmpty() &&
 
426
                (!m_Options.showIncludeSeparately ||
 
427
                 (m_Options.showIncludeSeparately && !m_pParser->IsIncludeFile(m_ActiveFilename))))
 
428
            {
 
429
                AddFileNodes(tree, parent, UnixFilename(m_ActiveFilename), tokenKindMask);
 
430
            }
 
431
            break;
 
432
        }
 
433
        case bdfProject:
 
434
        {
 
435
            for (FilesList::iterator it = m_pActiveProject->GetFilesList().begin(); it != m_pActiveProject->GetFilesList().end(); ++it)
 
436
            {
 
437
                ProjectFile* pf = *it;
 
438
                if (!m_Options.showIncludeSeparately ||
 
439
                    (m_Options.showIncludeSeparately && !m_pParser->IsIncludeFile(pf->file.GetFullPath())))
 
440
                    AddFileNodes(tree, parent, UnixFilename(pf->file.GetFullPath()), tokenKindMask);
 
441
            }
 
442
            break;
 
443
        }
 
444
        case bdfWorkspace:
 
445
        {
 
446
            TokensArrayF* pTokens = m_pParser->GetTokens();
 
447
            for (size_t i=0; i< pTokens->GetCount(); ++i)
 
448
            {
 
449
                TokenF* token = pTokens->Item(i);
 
450
                if (token->m_TokenKind == tkFile &&
 
451
                    (!m_Options.showIncludeSeparately ||
 
452
                     (m_Options.showIncludeSeparately && !m_pParser->IsIncludeFile(token->m_Filename))))
 
453
                {
 
454
                    AddChildrenNodes(tree, parent, token, tokenKindMask);
 
455
                }
 
456
            }
 
457
            break;
 
458
        }
 
459
    }
 
460
}
 
461
 
 
462
bool WorkspaceBrowserBuilder::AddFileNodes(wxTreeCtrl* tree, wxTreeItemId parent, wxString file, int tokenKindMask)
 
463
{
 
464
    TokensArrayF* pTokens = m_pParser->GetTokens();
 
465
 
 
466
    for (size_t i=0; i< pTokens->GetCount(); ++i)
 
467
    {
 
468
        TokenF* token = pTokens->Item(i);
 
469
 
 
470
        if (token->m_TokenKind == tkFile && token->m_Filename.IsSameAs(file))
 
471
        {
 
472
            return AddChildrenNodes(tree, parent, token, tokenKindMask);
 
473
        }
 
474
    }
 
475
    return false;
 
476
}
 
477
 
 
478
bool WorkspaceBrowserBuilder::AddChildrenNodes(wxTreeCtrl* tree, wxTreeItemId parent, TokenF* parToken, int tokenKindMask)
 
479
{
 
480
    int count = 0;
 
481
    bool sorted = m_Options.sortAlphabetically;
 
482
    TokensArrayF* pTokens = &parToken->m_Children;
 
483
 
 
484
    if (parToken->m_TokenKind == tkType)
 
485
    {
 
486
        count += AddTypeChildren(tree, parent, pTokens);
 
487
        return count != 0;
 
488
    }
 
489
 
 
490
    int childKM = tkFunction | tkProgram | tkSubroutine | tkPreprocessor | tkInterface | tkInterfaceExplicit | tkBlockData |
 
491
                    tkType | tkVariable | tkProcedure | tkAccessList;
 
492
    int interfaceMask = tkInterface | tkInterfaceExplicit;
 
493
    int funChildKM = childKM ^ tkVariable;
 
494
 
 
495
    if (!m_Options.showLocalVariables && (parToken->m_TokenKind == tkSubroutine || parToken->m_TokenKind == tkFunction || parToken->m_TokenKind == tkProgram))
 
496
    {
 
497
        childKM = childKM ^ tkVariable;
 
498
        if (tokenKindMask & tkVariable)
 
499
            tokenKindMask = tokenKindMask ^ tkVariable;
 
500
    }
 
501
 
 
502
    for (size_t i=0; i< pTokens->GetCount(); ++i)
 
503
    {
 
504
        TokenF* token = pTokens->Item(i);
 
505
        if (token->m_TokenKind & tokenKindMask)
 
506
        {
 
507
            if (token->m_TokenKind & interfaceMask)
 
508
            {
 
509
                count += AddInterfaceNode(tree, parent, token);
 
510
            }
 
511
            else
 
512
            {
 
513
                wxString nameDisp = token->m_DisplayName;
 
514
                if (token->m_TokenKind == tkVariable)
 
515
                    nameDisp << _T(" : ") << token->m_PartFirst;
 
516
                wxTreeItemId idni = AddNodeIfNotThere(tree, parent, nameDisp, GetTokenKindImageIdx(token), new TreeDataF(sfToken, token), sorted);
 
517
                count++;
 
518
                if (tree == m_pTreeTop && !m_Options.visibleBottomTree)
 
519
                {
 
520
                    if (!m_Options.showLocalVariables && (token->m_TokenKind == tkSubroutine || token->m_TokenKind == tkFunction))
 
521
                    {
 
522
                        if (HasChildren(token, funChildKM))
 
523
                            tree->SetItemHasChildren(idni);
 
524
                    }
 
525
                    else
 
526
                    {
 
527
                        if (HasChildren(token, childKM))
 
528
                            tree->SetItemHasChildren(idni);
 
529
                    }
 
530
                }
 
531
                else if(tree == m_pTreeBottom && HasChildren(token, childKM))
 
532
                {
 
533
                    AddChildrenNodes(tree, idni, token, childKM);
 
534
                }
 
535
            }
 
536
        }
 
537
    }
 
538
    return count != 0;
 
539
}
 
540
 
 
541
int WorkspaceBrowserBuilder::AddInterfaceNode(wxTreeCtrl* tree, wxTreeItemId parent, TokenF* parToken)
 
542
{
 
543
    int count = 0;
 
544
    bool sorted = m_Options.sortAlphabetically;
 
545
 
 
546
    if (!parToken->m_Name.IsEmpty())
 
547
    {
 
548
        wxString name;
 
549
        if (parToken->m_DisplayName.StartsWith(_T("%%")))
 
550
        {
 
551
            name = parToken->m_DisplayName.Mid(2);
 
552
        }
 
553
        else
 
554
        {
 
555
            name = parToken->m_DisplayName;
 
556
        }
 
557
        AddNodeIfNotThere(tree, parent, name, GetTokenKindImageIdx(parToken), new TreeDataF(sfToken, parToken), sorted);
 
558
        count++;
 
559
    }
 
560
    else
 
561
    {
 
562
        TokensArrayF* pTokens = &parToken->m_Children;
 
563
        if (pTokens)
 
564
        {
 
565
            int childKM = tkFunction | tkSubroutine;
 
566
            int imageIdx;
 
567
            for (size_t i=0; i< pTokens->GetCount(); ++i)
 
568
            {
 
569
                TokenF* token = pTokens->Item(i);
 
570
                if (token->m_TokenKind & childKM)
 
571
                {
 
572
                    if (token->m_TokenKind == tkFunction)
 
573
                    {
 
574
                        if (token->m_TokenAccess == taPublic)
 
575
                            imageIdx = m_ImgNr["interface_function"];
 
576
                        else
 
577
                            imageIdx = m_ImgNr["interface_function_private"];
 
578
                    }
 
579
                    else
 
580
                    {
 
581
                        if (token->m_TokenAccess == taPublic)
 
582
                            imageIdx = m_ImgNr["interface_subroutine"];
 
583
                        else
 
584
                            imageIdx = m_ImgNr["interface_subroutine_private"];
 
585
                    }
 
586
                    AddNodeIfNotThere(tree, parent, token->m_DisplayName, imageIdx, new TreeDataF(sfToken, token), sorted);
 
587
                    count++;
 
588
                }
 
589
            }
 
590
        }
 
591
    }
 
592
    return count;
 
593
}
 
594
 
 
595
int WorkspaceBrowserBuilder::AddTypeChildren(wxTreeCtrl* tree, wxTreeItemId parent, TokensArrayF* pTokens)
 
596
{
 
597
    int count = 0;
 
598
    bool sorted = m_Options.sortAlphabetically;
 
599
    TokensArrayF varTokens;
 
600
    TokensArrayF otherTokens;
 
601
 
 
602
    for (size_t i=0; i<pTokens->GetCount(); ++i)
 
603
    {
 
604
        TokenF* token = pTokens->Item(i);
 
605
        if (token->m_TokenKind == tkVariable)
 
606
        {
 
607
            if (sorted)
 
608
            {
 
609
                size_t j;
 
610
                for (j=0; j<varTokens.GetCount(); j++)
 
611
                {
 
612
                    if (token->m_DisplayName.CmpNoCase(varTokens.Item(j)->m_DisplayName) < 0)
 
613
                        break;
 
614
                }
 
615
                varTokens.Insert(token, j);
 
616
            }
 
617
            else
 
618
            {
 
619
                varTokens.Add(token);
 
620
            }
 
621
        }
 
622
        else
 
623
        {
 
624
            if (sorted)
 
625
            {
 
626
                wxString name;
 
627
                if (token->m_DisplayName.StartsWith(_T("%%")))
 
628
                    name = token->m_DisplayName.Mid(2);
 
629
                else
 
630
                    name = token->m_DisplayName;
 
631
                size_t j;
 
632
                for (j=0; j<otherTokens.GetCount(); j++)
 
633
                {
 
634
                    if (name.CmpNoCase(otherTokens.Item(j)->m_DisplayName) < 0)
 
635
                        break;
 
636
                }
 
637
                otherTokens.Insert(token, j);
 
638
            }
 
639
            else
 
640
            {
 
641
                otherTokens.Add(token);
 
642
            }
 
643
        }
 
644
    }
 
645
 
 
646
    for (size_t i=0; i<varTokens.GetCount(); ++i)
 
647
    {
 
648
        wxString nameDisp;
 
649
        nameDisp << varTokens.Item(i)->m_DisplayName << _T(" : ") << varTokens.Item(i)->m_PartFirst;
 
650
        AddNodeIfNotThere(tree, parent, nameDisp,
 
651
                          GetTokenKindImageIdx(varTokens.Item(i)), new TreeDataF(sfToken, varTokens.Item(i)), false);
 
652
        count++;
 
653
    }
 
654
 
 
655
    for (size_t i=0; i<otherTokens.GetCount(); ++i)
 
656
    {
 
657
        wxString name;
 
658
        if (otherTokens.Item(i)->m_DisplayName.StartsWith(_T("%%")))
 
659
            name = otherTokens.Item(i)->m_DisplayName.Mid(2);
 
660
        else
 
661
            name = otherTokens.Item(i)->m_DisplayName;
 
662
        AddNodeIfNotThere(tree, parent, name,
 
663
                          GetTokenKindImageIdx(otherTokens.Item(i)), new TreeDataF(sfToken, otherTokens.Item(i)), false);
 
664
        count++;
 
665
    }
 
666
 
 
667
    return count;
 
668
}
 
669
 
 
670
bool WorkspaceBrowserBuilder::SelectNode(wxTreeItemId node)
 
671
{
 
672
    // m_pTreeTop node was selected
 
673
    if (Manager::IsAppShuttingDown() || (!(node.IsOk())) || m_AtWork)
 
674
        return false;
 
675
 
 
676
    m_pTreeBottom->Freeze();
 
677
    wxTreeItemId root = m_pTreeBottom->GetRootItem();
 
678
    if (!root)
 
679
        root = m_pTreeBottom->AddRoot(_T("Members"));
 
680
    else
 
681
        m_pTreeBottom->DeleteChildren(root);
 
682
    TreeDataF* data = (TreeDataF*)m_pTreeTop->GetItemData(node);
 
683
    if (data)
 
684
    {
 
685
        switch (data->m_SpecialFolder)
 
686
        {
 
687
            case sfGFuncs:
 
688
            {
 
689
                AddTreeChildren(m_pTreeBottom, root, tkFunction | tkProgram | tkSubroutine);
 
690
                break;
 
691
            }
 
692
            case sfOthers:
 
693
            {
 
694
                AddTreeChildren(m_pTreeBottom, root, tkPreprocessor | tkInterface | tkBlockData);
 
695
                if (m_Options.showIncludeSeparately)
 
696
                    AddIncludeFiles(m_pTreeBottom, root);
 
697
                break;
 
698
            }
 
699
            case sfToken:
 
700
            {
 
701
                                wxTreeItemId rootFuncs = m_pTreeBottom->AppendItem(root, _("Procedures"), m_ImgNr["function_folder"]);
 
702
                                wxTreeItemId rootOthers = m_pTreeBottom->AppendItem(root, _("Others"), m_ImgNr["others_folder"]);
 
703
 
 
704
                TokenF* pToken = data->m_pToken;
 
705
                AddChildrenNodes(m_pTreeBottom, rootFuncs, pToken, tkFunction | tkSubroutine | tkProcedure);
 
706
                AddChildrenNodes(m_pTreeBottom, rootOthers, pToken, tkType | tkInterface | tkInterfaceExplicit | tkAccessList | tkVariable);
 
707
 
 
708
                m_pTreeBottom->Expand(rootFuncs);
 
709
                m_pTreeBottom->Expand(rootOthers);
 
710
                //ExpandAll();
 
711
 
 
712
                break;
 
713
            }
 
714
            default: break;
 
715
        }
 
716
    }
 
717
    m_pTreeBottom->Thaw();
 
718
    return true;
 
719
}
 
720
 
 
721
wxTreeItemId WorkspaceBrowserBuilder::AddNodeIfNotThere(wxTreeCtrl* tree, wxTreeItemId parent, const wxString& name, int imgIndex, TreeDataF* data, bool sorted)
 
722
{
 
723
    SpecialFolder new_type = data->m_SpecialFolder;
 
724
 
 
725
    compatibility::tree_cookie_t cookie = 0;
 
726
 
 
727
    wxTreeItemId insert_after; // node to insert after; we 'll be looping all children so we might as well sort at the same time
 
728
    wxTreeItemId existing = tree->GetFirstChild(parent, cookie);
 
729
    while (existing.IsOk())
 
730
    {
 
731
        wxString itemText = tree->GetItemText(existing);
 
732
        if (itemText.IsSameAs(name))
 
733
        {
 
734
            if (tree->GetItemImage(existing) == imgIndex)
 
735
            {
 
736
                tree->SetItemImage(existing, imgIndex, wxTreeItemIcon_Normal);
 
737
                tree->SetItemImage(existing, imgIndex, wxTreeItemIcon_Selected);
 
738
                delete tree->GetItemData(existing); // make Valgrind happy
 
739
                tree->SetItemData(existing, data);
 
740
 
 
741
                return existing;
 
742
            }
 
743
        }
 
744
 
 
745
        if (sorted)
 
746
        {
 
747
            TreeDataF* existing_data = (TreeDataF*)tree->GetItemData(existing);
 
748
            if (existing_data)
 
749
            {
 
750
                SpecialFolder existing_type = existing_data->m_SpecialFolder;
 
751
 
 
752
                // first go special folders
 
753
                if ((existing_type & (sfGFuncs | sfOthers)) &&
 
754
                    !(new_type & (sfGFuncs | sfOthers)))
 
755
                {
 
756
                    insert_after = existing;
 
757
                }
 
758
                // then everything else, alphabetically
 
759
                else if (name.CmpNoCase(itemText) >= 0)
 
760
                {
 
761
                    insert_after = existing;
 
762
                }
 
763
                else // name.CmpNoCase(itemText) < 0
 
764
                {
 
765
                    break;
 
766
                }
 
767
            }
 
768
        }
 
769
        existing = tree->GetNextChild(parent, cookie);
 
770
    }
 
771
 
 
772
    if (sorted)
 
773
        existing = tree->InsertItem(parent, insert_after, name, imgIndex, imgIndex, data);
 
774
    else
 
775
        existing = tree->AppendItem(parent, name, imgIndex, imgIndex, data);
 
776
    return existing;
 
777
}
 
778
 
 
779
void WorkspaceBrowserBuilder::CreateSpecialFolders()
 
780
{
 
781
    wxTreeItemId parent = m_pTreeTop->GetRootItem();
 
782
    wxTreeItemId gfuncs = AddNodeIfNotThere(m_pTreeTop, parent, _("Global procedures"), m_ImgNr["function_folder"], new TreeDataF(sfGFuncs, 0));
 
783
    wxTreeItemId others = AddNodeIfNotThere(m_pTreeTop, parent, _("Others"), m_ImgNr["others_folder"], new TreeDataF(sfOthers, 0));
 
784
 
 
785
    if (!m_Options.visibleBottomTree)
 
786
    {
 
787
        if (HasGlobalFunctionsOthers(tkFunction | tkProgram | tkSubroutine))
 
788
            m_pTreeTop->SetItemHasChildren(gfuncs);
 
789
        if (HasGlobalFunctionsOthers(tkPreprocessor | tkInterface | tkBlockData) ||
 
790
            (m_Options.showIncludeSeparately && m_pParser->HasIncludeFiles()))
 
791
            m_pTreeTop->SetItemHasChildren(others);
 
792
    }
 
793
}
 
794
 
 
795
void WorkspaceBrowserBuilder::ExpandTop()
 
796
{
 
797
    if (Manager::IsAppShuttingDown())
 
798
        return;
 
799
 
 
800
    CreateSpecialFolders();
 
801
    wxTreeItemId root = m_pTreeTop->GetRootItem();
 
802
    AddTreeChildren(m_pTreeTop, root, tkModule | tkSubmodule);
 
803
}
 
804
 
 
805
void WorkspaceBrowserBuilder::ExpandTopNode(wxTreeItemId node)
 
806
{
 
807
    if (Manager::IsAppShuttingDown() || (!(node.IsOk())) || (node == m_pTreeTop->GetRootItem()))
 
808
        return;
 
809
 
 
810
    m_pTreeTop->Freeze();
 
811
    TreeDataF* data = (TreeDataF*)m_pTreeTop->GetItemData(node);
 
812
    if (data)
 
813
    {
 
814
        wxString disName;
 
815
        switch (data->m_SpecialFolder)
 
816
        {
 
817
            case sfGFuncs:
 
818
            {
 
819
                AddTreeChildren(m_pTreeTop, node, tkFunction | tkProgram | tkSubroutine);
 
820
                break;
 
821
            }
 
822
            case sfOthers:
 
823
            {
 
824
                AddTreeChildren(m_pTreeTop, node, tkPreprocessor | tkInterface | tkBlockData);
 
825
                if (m_Options.showIncludeSeparately)
 
826
                    AddIncludeFiles(m_pTreeTop, node);
 
827
                break;
 
828
            }
 
829
            case sfToken:
 
830
            {
 
831
                TokenF* pToken = data->m_pToken;
 
832
                AddChildrenNodes(m_pTreeTop, node, pToken, tkFunction | tkSubroutine | tkInterface | tkType | tkVariable |
 
833
                                 tkProcedure | tkAccessList | tkInterfaceExplicit);
 
834
                break;
 
835
            }
 
836
            default: break;
 
837
        }
 
838
        disName = m_pTreeTop->GetItemText(node);
 
839
        if (m_ExpandedNodes.Index(disName) == wxNOT_FOUND)
 
840
            m_ExpandedNodes.Add(disName);
 
841
    }
 
842
    m_pTreeTop->Thaw();
 
843
}
 
844
 
 
845
void WorkspaceBrowserBuilder::CollapsTopNode(wxTreeItemId node)
 
846
{
 
847
    if (Manager::IsAppShuttingDown() || (!(node.IsOk())) || (node == m_pTreeTop->GetRootItem()))
 
848
        return;
 
849
 
 
850
    int indx = m_ExpandedNodes.Index(m_pTreeTop->GetItemText(node));
 
851
    if (indx != wxNOT_FOUND)
 
852
    {
 
853
        m_ExpandedNodes.RemoveAt(indx);
 
854
    }
 
855
}
 
856
 
 
857
void WorkspaceBrowserBuilder::SelectItem(TokenF* token)
 
858
{
 
859
    if (Manager::IsAppShuttingDown())
 
860
        return;
 
861
 
 
862
    wxTreeItemId item;
 
863
    if (token && token->m_pParent)
 
864
    {
 
865
        if (token->m_pParent->m_TokenKind == tkFile)
 
866
        {
 
867
            if (token->m_TokenKind == tkFunction)
 
868
            {
 
869
                item = FindItemByName(m_pTreeTop, _("Global procedures"));
 
870
                if (item.IsOk())
 
871
                {
 
872
                    m_pTreeTop->SelectItem(item);
 
873
                    item = FindItemByName(m_pTreeBottom, token->m_DisplayName);
 
874
                    if (item.IsOk())
 
875
                        m_pTreeBottom->SelectItem(item);
 
876
                }
 
877
            }
 
878
            else if (token->m_TokenKind == tkPreprocessor)
 
879
            {
 
880
                item = FindItemByName(m_pTreeTop, _("Preprocessor symbols"));
 
881
                if (item.IsOk())
 
882
                {
 
883
                    m_pTreeTop->SelectItem(item);
 
884
                    item = FindItemByName(m_pTreeBottom, token->m_DisplayName);
 
885
                    if (item.IsOk())
 
886
                        m_pTreeBottom->SelectItem(item);
 
887
                }
 
888
            }
 
889
            else if (token->m_TokenKind == tkModule || token->m_TokenKind == tkSubmodule)
 
890
            {
 
891
                item = FindItemByName(m_pTreeTop, token->m_DisplayName);
 
892
                if (item.IsOk())
 
893
                    m_pTreeTop->SelectItem(item);
 
894
            }
 
895
        }
 
896
        else if (token->m_pParent->m_TokenKind == tkModule || token->m_pParent->m_TokenKind == tkSubmodule)
 
897
        {
 
898
            item = FindItemByName(m_pTreeTop, token->m_pParent->m_DisplayName);
 
899
            if (item.IsOk())
 
900
            {
 
901
                m_pTreeTop->SelectItem(item);
 
902
                item = FindItemByName(m_pTreeBottom, token->m_DisplayName);
 
903
                if (item.IsOk())
 
904
                    m_pTreeBottom->SelectItem(item);
 
905
            }
 
906
        }
 
907
    }
 
908
}
 
909
 
 
910
wxTreeItemId WorkspaceBrowserBuilder::FindItemByName(wxTreeCtrl* tree, wxString name, wxString name2)
 
911
{
 
912
    bool foundFirst = false;
 
913
    wxTreeItemId firstItem;
 
914
 
 
915
    wxTreeItemIdValue cookie;
 
916
    wxTreeItemId root = tree->GetRootItem();
 
917
    if (!root.IsOk())
 
918
        return root;
 
919
    wxTreeItemId item = tree->GetFirstChild(root, cookie);
 
920
    while (item.IsOk())
 
921
    {
 
922
        if (tree->GetItemText(item).IsSameAs(name))
 
923
        {
 
924
            if (name2.IsEmpty())
 
925
                return item;
 
926
            else
 
927
            {
 
928
                firstItem = item;
 
929
                foundFirst = true;
 
930
                break;
 
931
            }
 
932
        }
 
933
        else if(name2.IsEmpty())
 
934
        {
 
935
            wxTreeItemIdValue cookie2;
 
936
            wxTreeItemId item2 = tree->GetFirstChild(item, cookie2);
 
937
            while (item2.IsOk())
 
938
            {
 
939
                if (tree->GetItemText(item2).IsSameAs(name))
 
940
                {
 
941
                    return item2;
 
942
                }
 
943
                item2 = tree->GetNextChild(item, cookie2);
 
944
            }
 
945
        }
 
946
        item = tree->GetNextChild(root, cookie);
 
947
    }
 
948
    if (!name2.IsEmpty() && foundFirst)
 
949
    {
 
950
        wxTreeItemIdValue cookie3;
 
951
        wxTreeItemId item2 = tree->GetFirstChild(firstItem, cookie3);
 
952
        while (item2.IsOk())
 
953
        {
 
954
            if (tree->GetItemText(item2).IsSameAs(name2))
 
955
            {
 
956
                return item2;
 
957
            }
 
958
            item2 = tree->GetNextChild(item, cookie3);
 
959
        }
 
960
        return firstItem;
 
961
    }
 
962
    item.Unset();
 
963
        return item;
 
964
}
 
965
 
 
966
int WorkspaceBrowserBuilder::GetTokenKindImageIdx(TokenF* token)
 
967
{
 
968
    if (!token)
 
969
        return m_ImgNr["none"];
 
970
 
 
971
    switch (token->m_TokenKind)
 
972
    {
 
973
        case tkUse: return m_ImgNr["use"];
 
974
 
 
975
        case tkModule: return m_ImgNr["module"];
 
976
 
 
977
        case tkSubroutine:
 
978
            {
 
979
                if (token->m_TokenAccess == taPrivate)
 
980
                    return m_ImgNr["subroutine_private"];
 
981
                else
 
982
                    return m_ImgNr["subroutine"];
 
983
            }
 
984
        case tkFunction:
 
985
            {
 
986
                if (token->m_TokenAccess == taPrivate)
 
987
                    return m_ImgNr["function_private"];
 
988
                else
 
989
                    return m_ImgNr["function"];
 
990
            }
 
991
        case tkProgram: return m_ImgNr["program"];
 
992
 
 
993
        case tkType:
 
994
            {
 
995
                if (token->m_TokenAccess == taPrivate)
 
996
                {
 
997
                    if (token->m_IsAbstract)
 
998
                        return m_ImgNr["type_abstract_private"];
 
999
                    else
 
1000
                        return m_ImgNr["type_private"];
 
1001
                }
 
1002
                else
 
1003
                {
 
1004
                    if (token->m_IsAbstract)
 
1005
                        return m_ImgNr["type_abstract"];
 
1006
                    else
 
1007
                        return m_ImgNr["type"];
 
1008
                }
 
1009
            }
 
1010
        case tkInterface:
 
1011
            {
 
1012
                if (token->m_TypeDefinition.IsSameAs(_T("subroutine")))
 
1013
                {
 
1014
                    if (token->m_TokenAccess == taPrivate)
 
1015
                        return m_ImgNr["interface_sub_gen_private"];
 
1016
                    else
 
1017
                        return m_ImgNr["interface_sub_gen"];
 
1018
                }
 
1019
                else if (token->m_TypeDefinition.IsSameAs(_T("function")))
 
1020
                {
 
1021
                    if (token->m_TokenAccess == taPrivate)
 
1022
                        return m_ImgNr["interface_fun_gen_private"];
 
1023
                    else
 
1024
                        return m_ImgNr["interface_fun_gen"];
 
1025
                }
 
1026
                else
 
1027
                {
 
1028
                    if (token->m_TokenAccess == taPrivate)
 
1029
                        return m_ImgNr["interface_private"];
 
1030
                    else
 
1031
                        return m_ImgNr["interface"];
 
1032
                }
 
1033
            }
 
1034
        case tkInterfaceExplicit:
 
1035
            {
 
1036
                if (token->m_TokenAccess == taPrivate)
 
1037
                    return m_ImgNr["interface_private"];
 
1038
                else
 
1039
                    return m_ImgNr["interface"];
 
1040
            }
 
1041
 
 
1042
        case tkCommonblock: return m_ImgNr["none"];
 
1043
 
 
1044
        case tkPreprocessor: return m_ImgNr["preproc"];
 
1045
 
 
1046
        case tkFile: return m_ImgNr["none"];
 
1047
 
 
1048
        case tkVariable:
 
1049
            {
 
1050
                if (token->m_TokenAccess == taPrivate)
 
1051
                    return m_ImgNr["variable_private"];
 
1052
                else if (token->m_TokenAccess == taProtected)
 
1053
                    return m_ImgNr["variable_protected"];
 
1054
                else
 
1055
                    return m_ImgNr["variable"];
 
1056
            }
 
1057
 
 
1058
        case tkInterfaceFunction: return m_ImgNr["interface_function"];
 
1059
 
 
1060
        case tkInterfaceSubroutine: return m_ImgNr["interface_subroutine"];
 
1061
 
 
1062
        case tkProcedure:
 
1063
            {
 
1064
                if (token->m_TypeDefinition.IsSameAs(_T("subroutine")))
 
1065
                {
 
1066
                    if (token->m_TokenAccess == taPrivate)
 
1067
                        return m_ImgNr["subroutine_private"];
 
1068
                    else
 
1069
                        return m_ImgNr["subroutine"];
 
1070
                }
 
1071
                else if (token->m_TypeDefinition.IsSameAs(_T("function")))
 
1072
                {
 
1073
                    if (token->m_TokenAccess == taPrivate)
 
1074
                        return m_ImgNr["function_private"];
 
1075
                    else
 
1076
                        return m_ImgNr["function"];
 
1077
                }
 
1078
                else
 
1079
                {
 
1080
                    if (token->m_TokenAccess == taPrivate)
 
1081
                        return m_ImgNr["procedure_private"];
 
1082
                    else
 
1083
                        return m_ImgNr["procedure"];
 
1084
                }
 
1085
            }
 
1086
 
 
1087
        case tkAccessList:
 
1088
            {
 
1089
                if (token->m_TokenAccess == taPrivate)
 
1090
                    return m_ImgNr["access_list_private"];
 
1091
                else if (token->m_TokenAccess == taProtected)
 
1092
                    return m_ImgNr["access_list_protected"];
 
1093
                else
 
1094
                    return m_ImgNr["access_list_public"];
 
1095
            }
 
1096
 
 
1097
        case tkSubmodule: return m_ImgNr["submodule"];
 
1098
 
 
1099
        case tkProcedureFinal: return m_ImgNr["procedure_final"];
 
1100
 
 
1101
        default: return m_ImgNr["none"];
 
1102
    }
 
1103
}
 
1104
 
 
1105
wxImageList* WorkspaceBrowserBuilder::GetImageList()
 
1106
{
 
1107
    return m_pImlist;
 
1108
}
 
1109
 
 
1110
void WorkspaceBrowserBuilder::MarkSymbol(const wxString& filename, int line)
 
1111
{
 
1112
    if (Manager::IsAppShuttingDown() || m_AtWork)
 
1113
        return;
 
1114
 
 
1115
    bool found = false;
 
1116
    bool unmarked = true;
 
1117
    wxTreeItemIdValue cookie;
 
1118
    wxTreeItemId root = m_pTreeTop->GetRootItem();
 
1119
    if(!root.IsOk())
 
1120
        return;
 
1121
    wxTreeItemId item = m_pTreeTop->GetFirstChild(root, cookie);
 
1122
    wxTreeItemId itemGlob;
 
1123
    bool haveGlob = false;
 
1124
    wxTreeItemId itemOthers;
 
1125
    bool haveOthers = false;
 
1126
    while (item.IsOk())
 
1127
    {
 
1128
        TreeDataF* data = (TreeDataF*)m_pTreeTop->GetItemData(item);
 
1129
        if (data)
 
1130
        {
 
1131
            switch (data->m_SpecialFolder)
 
1132
            {
 
1133
                case sfGFuncs:
 
1134
                {
 
1135
                    itemGlob = item;
 
1136
                    haveGlob = true;
 
1137
                    break;
 
1138
                }
 
1139
                case sfOthers:
 
1140
                {
 
1141
                    itemOthers = item;
 
1142
                    haveOthers = true;
 
1143
                    break;
 
1144
                }
 
1145
                case sfToken:
 
1146
                {
 
1147
                    if (m_pTreeTop->IsBold(item))
 
1148
                    {
 
1149
                        if (!data->m_pToken->m_Filename.IsSameAs(filename)
 
1150
                            || ((int)data->m_pToken->m_LineStart > line)
 
1151
                            || ((int)data->m_pToken->m_LineEnd < line))
 
1152
                        {
 
1153
                            MarkItem(m_pTreeTop, item, false);
 
1154
                            if (!m_Options.visibleBottomTree && m_pTreeTop->HasChildren(item))
 
1155
                            {
 
1156
                                MarkChildSymbol(m_pTreeTop, item, line, false);
 
1157
                            }
 
1158
                            unmarked = true;
 
1159
                        }
 
1160
                        else
 
1161
                            unmarked = false;
 
1162
                    }
 
1163
                    if (!found)
 
1164
                    {
 
1165
                        if (data->m_pToken->m_Filename.IsSameAs(filename))
 
1166
                        {
 
1167
                            if (((int)data->m_pToken->m_LineStart <= line) && ((int)data->m_pToken->m_LineEnd >= line))
 
1168
                            {
 
1169
                                if (unmarked)
 
1170
                                    MarkItem(m_pTreeTop, item);
 
1171
                                if ((m_pTreeTop->GetSelection() == item) && m_Options.visibleBottomTree)
 
1172
                                {
 
1173
                                    MarkBottomSymbol(filename, line);
 
1174
                                }
 
1175
                                else if (m_Options.visibleBottomTree)
 
1176
                                {
 
1177
                                    UnmarkBottomSymbol();
 
1178
                                }
 
1179
                                else if (!m_Options.visibleBottomTree && m_pTreeTop->HasChildren(item))
 
1180
                                {
 
1181
                                    MarkChildSymbol(m_pTreeTop, item, line);
 
1182
                                }
 
1183
                                found = true;
 
1184
                            }
 
1185
                        }
 
1186
                    }
 
1187
                    break;
 
1188
                }
 
1189
                default:
 
1190
                {
 
1191
                    break;
 
1192
                }
 
1193
            }
 
1194
        }
 
1195
        item = m_pTreeTop->GetNextChild(root, cookie);
 
1196
    }
 
1197
 
 
1198
    if (haveGlob && found)
 
1199
    {
 
1200
        if (m_Options.visibleBottomTree && (m_pTreeTop->GetSelection() == itemGlob))
 
1201
        {
 
1202
            UnmarkBottomSymbol();
 
1203
        }
 
1204
        else if (!m_Options.visibleBottomTree && m_pTreeTop->HasChildren(itemGlob) &&  m_pTreeTop->GetLastChild(itemGlob).IsOk())
 
1205
        {
 
1206
            MarkChildSymbol(m_pTreeTop, itemGlob, line, false);
 
1207
        }
 
1208
        if (m_pTreeTop->IsBold(itemGlob))
 
1209
            MarkItem(m_pTreeTop, itemGlob, false);
 
1210
    }
 
1211
    else if (haveGlob)
 
1212
    {
 
1213
        bool foundGlob = false;
 
1214
        if (m_Options.visibleBottomTree && (m_pTreeTop->GetSelection() == itemGlob))
 
1215
        {
 
1216
            foundGlob = MarkBottomSymbol(filename, line);
 
1217
        }
 
1218
        else if (!m_Options.visibleBottomTree && m_pTreeTop->HasChildren(itemGlob) &&  m_pTreeTop->GetLastChild(itemGlob).IsOk())
 
1219
        {
 
1220
            foundGlob = MarkGlobalSymbol(m_pTreeTop, itemGlob, filename, line);
 
1221
        }
 
1222
        else
 
1223
        {
 
1224
            foundGlob = IsLineInGlobals(filename, line);
 
1225
            if (m_Options.visibleBottomTree && foundGlob && (m_pTreeTop->GetSelection() != itemGlob))
 
1226
            {
 
1227
                UnmarkBottomSymbol();
 
1228
            }
 
1229
        }
 
1230
        if (foundGlob)
 
1231
        {
 
1232
            MarkItem(m_pTreeTop, itemGlob);
 
1233
            found = true;
 
1234
        }
 
1235
        else if (m_pTreeTop->IsBold(itemGlob))
 
1236
        {
 
1237
            MarkItem(m_pTreeTop, itemGlob, false);
 
1238
        }
 
1239
    }
 
1240
 
 
1241
    if (haveOthers && found)
 
1242
    {
 
1243
        if (m_Options.visibleBottomTree && (m_pTreeTop->GetSelection() == itemOthers))
 
1244
        {
 
1245
            UnmarkBottomSymbol();
 
1246
        }
 
1247
        else if (!m_Options.visibleBottomTree && m_pTreeTop->HasChildren(itemOthers) &&  m_pTreeTop->GetLastChild(itemOthers).IsOk())
 
1248
        {
 
1249
            MarkChildSymbol(m_pTreeTop, itemOthers, line, false);
 
1250
            MarkGlobalSymbol(m_pTreeTop, itemOthers, filename, line);
 
1251
        }
 
1252
        if (m_pTreeTop->IsBold(itemOthers))
 
1253
            MarkItem(m_pTreeTop, itemOthers, false);
 
1254
    }
 
1255
    else if (haveOthers)
 
1256
    {
 
1257
        bool foundOthers = false;
 
1258
        if (m_Options.visibleBottomTree && (m_pTreeTop->GetSelection() == itemOthers))
 
1259
        {
 
1260
            foundOthers = MarkBottomSymbol(filename, line);
 
1261
        }
 
1262
        else if (!m_Options.visibleBottomTree && m_pTreeTop->HasChildren(itemOthers) &&  m_pTreeTop->GetLastChild(itemOthers).IsOk())
 
1263
        {
 
1264
            foundOthers = MarkGlobalSymbol(m_pTreeTop, itemOthers, filename, line);
 
1265
        }
 
1266
        else
 
1267
        {
 
1268
            foundOthers = (m_Options.showIncludeSeparately && m_pParser->IsIncludeFile(filename));
 
1269
            if (m_Options.visibleBottomTree && foundOthers && (m_pTreeTop->GetSelection() != itemOthers))
 
1270
            {
 
1271
                UnmarkBottomSymbol();
 
1272
            }
 
1273
        }
 
1274
        if (foundOthers)
 
1275
        {
 
1276
            MarkItem(m_pTreeTop, itemOthers);
 
1277
            found = true;
 
1278
        }
 
1279
        else if (m_pTreeTop->IsBold(itemOthers))
 
1280
        {
 
1281
            MarkItem(m_pTreeTop, itemOthers, false);
 
1282
        }
 
1283
    }
 
1284
 
 
1285
    if (!found && m_Options.visibleBottomTree)
 
1286
    {
 
1287
        UnmarkBottomSymbol();
 
1288
    }
 
1289
}
 
1290
 
 
1291
void WorkspaceBrowserBuilder::MarkItem(wxTreeCtrl* tree, wxTreeItemId& item, bool mark)
 
1292
{
 
1293
    if (item.IsOk())
 
1294
    {
 
1295
        tree->SetItemBold(item, mark);
 
1296
#ifdef __WXGTK__
 
1297
        tree->Refresh();
 
1298
#endif
 
1299
    }
 
1300
}
 
1301
 
 
1302
bool WorkspaceBrowserBuilder::MarkBottomSymbol(const wxString& filename, int line)
 
1303
{
 
1304
    bool found = false;
 
1305
    bool foundFile = false;
 
1306
    bool unmarked = true;
 
1307
    wxTreeItemIdValue cookie;
 
1308
    wxTreeItemId root = m_pTreeBottom->GetRootItem();
 
1309
    if (!root.IsOk())
 
1310
        return false;
 
1311
    wxTreeItemId item = m_pTreeBottom->GetFirstChild(root, cookie);
 
1312
    while (item.IsOk())
 
1313
    {
 
1314
        bool goInside = false;
 
1315
        TreeDataF* data = (TreeDataF*)m_pTreeBottom->GetItemData(item);
 
1316
        if (data)
 
1317
        {
 
1318
            if (data->m_SpecialFolder == sfToken)
 
1319
            {
 
1320
                if (m_pTreeBottom->IsBold(item))
 
1321
                {
 
1322
                    if (!data->m_pToken->m_Filename.IsSameAs(filename)
 
1323
                        || (int)data->m_pToken->m_LineStart > line
 
1324
                        || (int)data->m_pToken->m_LineEnd < line)
 
1325
                    {
 
1326
                        MarkItem(m_pTreeBottom, item, false);
 
1327
                        unmarked = true;
 
1328
                    }
 
1329
                    else
 
1330
                        unmarked = false;
 
1331
                }
 
1332
                if (!found)
 
1333
                {
 
1334
                    if (data->m_pToken->m_Filename.IsSameAs(filename))
 
1335
                    {
 
1336
                        if (((int)data->m_pToken->m_LineStart <= line) && ((int)data->m_pToken->m_LineEnd >= line))
 
1337
                        {
 
1338
                            if (unmarked)
 
1339
                                MarkItem(m_pTreeBottom, item);
 
1340
                            found = true;
 
1341
                        }
 
1342
                    }
 
1343
                }
 
1344
            }
 
1345
            else if(data->m_SpecialFolder == sfFile)
 
1346
            {
 
1347
                if (data->m_pToken->m_Filename.IsSameAs(filename))
 
1348
                {
 
1349
                    MarkItem(m_pTreeBottom, item);
 
1350
                    goInside = true;
 
1351
                    foundFile = true;
 
1352
                }
 
1353
                else
 
1354
                    MarkItem(m_pTreeBottom, item, false);
 
1355
            }
 
1356
        }
 
1357
        else
 
1358
            goInside = true;
 
1359
 
 
1360
        if (goInside)
 
1361
        {
 
1362
            bool unmarked2 = true;
 
1363
            wxTreeItemIdValue cookie2;
 
1364
            wxTreeItemId item2 = m_pTreeBottom->GetFirstChild(item, cookie2);
 
1365
            while (item2.IsOk())
 
1366
            {
 
1367
                TreeDataF* data2 = (TreeDataF*)m_pTreeBottom->GetItemData(item2);
 
1368
                if (data2)
 
1369
                {
 
1370
                    if (data2->m_SpecialFolder == sfToken)
 
1371
                    {
 
1372
                        if (m_pTreeBottom->IsBold(item2))
 
1373
                        {
 
1374
                            if (!data2->m_pToken->m_Filename.IsSameAs(filename)
 
1375
                                || (int)data2->m_pToken->m_LineStart > line
 
1376
                                || (int)data2->m_pToken->m_LineEnd < line)
 
1377
                            {
 
1378
                                MarkItem(m_pTreeBottom, item2, false);
 
1379
                                unmarked2 = true;
 
1380
                            }
 
1381
                            else
 
1382
                                unmarked2 = false;
 
1383
                        }
 
1384
                        if (!found)
 
1385
                        {
 
1386
                            if (data2->m_pToken->m_Filename.IsSameAs(filename))
 
1387
                            {
 
1388
                                if (((int)data2->m_pToken->m_LineStart <= line) && ((int)data2->m_pToken->m_LineEnd >= line))
 
1389
                                {
 
1390
                                    if (unmarked2)
 
1391
                                        MarkItem(m_pTreeBottom, item2);
 
1392
                                    found = true;
 
1393
                                }
 
1394
                            }
 
1395
                        }
 
1396
                    }
 
1397
                }
 
1398
                item2 = m_pTreeBottom->GetNextChild(item, cookie2);
 
1399
            }
 
1400
        }
 
1401
        item = m_pTreeBottom->GetNextChild(root, cookie);
 
1402
    }
 
1403
    return (found || foundFile);
 
1404
}
 
1405
 
 
1406
 
 
1407
void WorkspaceBrowserBuilder::UnmarkBottomSymbol()
 
1408
{
 
1409
    bool found = false;
 
1410
    bool goInside = false;
 
1411
    wxTreeItemIdValue cookie;
 
1412
    wxTreeItemId root = m_pTreeBottom->GetRootItem();
 
1413
    if (!root.IsOk())
 
1414
        return;
 
1415
    wxTreeItemId item = m_pTreeBottom->GetFirstChild(root, cookie);
 
1416
    while (item.IsOk())
 
1417
    {
 
1418
        TreeDataF* data = (TreeDataF*)m_pTreeBottom->GetItemData(item);
 
1419
        if (data)
 
1420
        {
 
1421
            if (m_pTreeBottom->IsBold(item))
 
1422
            {
 
1423
                MarkItem(m_pTreeBottom, item, false);
 
1424
                found = true;
 
1425
                goInside = true;
 
1426
            }
 
1427
        }
 
1428
        else
 
1429
            goInside = true;
 
1430
 
 
1431
        if (goInside)
 
1432
        {
 
1433
            wxTreeItemIdValue cookie2;
 
1434
            wxTreeItemId item2 = m_pTreeBottom->GetFirstChild(item, cookie2);
 
1435
            while (item2.IsOk())
 
1436
            {
 
1437
                TreeDataF* data2 = (TreeDataF*)m_pTreeBottom->GetItemData(item2);
 
1438
                if (data2)
 
1439
                {
 
1440
                    if (data2->m_SpecialFolder == sfToken)
 
1441
                    {
 
1442
                        if (m_pTreeBottom->IsBold(item2))
 
1443
                        {
 
1444
                            MarkItem(m_pTreeBottom, item2, false);
 
1445
                            found = true;
 
1446
                            break;
 
1447
                        }
 
1448
                    }
 
1449
                }
 
1450
                item2 = m_pTreeBottom->GetNextChild(item, cookie2);
 
1451
            }
 
1452
        }
 
1453
        if (found)
 
1454
            break;
 
1455
        item = m_pTreeBottom->GetNextChild(root, cookie);
 
1456
    }
 
1457
}
 
1458
 
 
1459
 
 
1460
void WorkspaceBrowserBuilder::MarkChildSymbol(wxTreeCtrl* tree, wxTreeItemId& root, int line, bool mark)
 
1461
{
 
1462
    bool found = false;
 
1463
    bool unmarked = true;
 
1464
    wxTreeItemIdValue cookie;
 
1465
    if (!root.IsOk())
 
1466
        return;
 
1467
    wxTreeItemId item = tree->GetFirstChild(root, cookie);
 
1468
    while (item.IsOk())
 
1469
    {
 
1470
        TreeDataF* data = (TreeDataF*)tree->GetItemData(item);
 
1471
        if (data)
 
1472
        {
 
1473
            if (data->m_SpecialFolder == sfToken)
 
1474
            {
 
1475
                if (tree->IsBold(item))
 
1476
                {
 
1477
                    if (mark)
 
1478
                    {
 
1479
                        if (((int)data->m_pToken->m_LineStart > line) || ((int)data->m_pToken->m_LineEnd < line))
 
1480
                        {
 
1481
                            MarkItem(tree, item, false);
 
1482
                            unmarked = true;
 
1483
                        }
 
1484
                        else
 
1485
                            unmarked = false;
 
1486
                    }
 
1487
                    else
 
1488
                        MarkItem(tree, item, false);
 
1489
                }
 
1490
                if (!found && mark)
 
1491
                {
 
1492
                    if (((int)data->m_pToken->m_LineStart <= line) && ((int)data->m_pToken->m_LineEnd >= line))
 
1493
                    {
 
1494
                        if (unmarked)
 
1495
                            MarkItem(tree, item);
 
1496
                        found = true;
 
1497
                    }
 
1498
                }
 
1499
            }
 
1500
            else if (data->m_SpecialFolder == sfFile)
 
1501
            {
 
1502
                if ((tree->IsBold(item) && !mark) || (!tree->IsBold(item) && mark))
 
1503
                    MarkItem(tree, item, mark);
 
1504
                MarkChildSymbol(tree, item, line, mark);
 
1505
            }
 
1506
        }
 
1507
        item = tree->GetNextChild(root, cookie);
 
1508
    }
 
1509
}
 
1510
 
 
1511
bool WorkspaceBrowserBuilder::MarkGlobalSymbol(wxTreeCtrl* tree, wxTreeItemId& root, const wxString& filename, int line)
 
1512
{
 
1513
    bool found = false;
 
1514
    bool foundFile  = false;
 
1515
    wxTreeItemIdValue cookie;
 
1516
    if (!root.IsOk())
 
1517
        return false;
 
1518
    wxTreeItemId item = tree->GetFirstChild(root, cookie);
 
1519
    while (item.IsOk())
 
1520
    {
 
1521
        TreeDataF* data = (TreeDataF*)tree->GetItemData(item);
 
1522
        if (data)
 
1523
        {
 
1524
            if (data->m_SpecialFolder == sfToken)
 
1525
            {
 
1526
                if (tree->IsBold(item))
 
1527
                {
 
1528
                    MarkItem(tree, item, false);
 
1529
                }
 
1530
                if (!found)
 
1531
                {
 
1532
                    if (data->m_pToken->m_Filename.IsSameAs(filename))
 
1533
                    {
 
1534
                        if (((int)data->m_pToken->m_LineStart <= line) && ((int)data->m_pToken->m_LineEnd >= line))
 
1535
                        {
 
1536
                            MarkItem(tree, item);
 
1537
                            found = true;
 
1538
                        }
 
1539
                    }
 
1540
                }
 
1541
            }
 
1542
            else if (data->m_SpecialFolder == sfFile)
 
1543
            {
 
1544
                bool isSameFile = data->m_pToken->m_Filename.IsSameAs(filename);
 
1545
                if (isSameFile)
 
1546
                {
 
1547
                    MarkItem(tree, item);
 
1548
                    foundFile = true;
 
1549
                }
 
1550
                else
 
1551
                    MarkItem(tree, item, false);
 
1552
                wxTreeItemIdValue cookie2;
 
1553
                wxTreeItemId item2 = tree->GetFirstChild(item, cookie2);
 
1554
 
 
1555
                while (item2.IsOk())
 
1556
                {
 
1557
                    TreeDataF* data2 = (TreeDataF*)tree->GetItemData(item2);
 
1558
                    if (data2)
 
1559
                    {
 
1560
                        if (data2->m_SpecialFolder == sfToken)
 
1561
                        {
 
1562
                            if (tree->IsBold(item2))
 
1563
                            {
 
1564
                                MarkItem(tree, item2, false);
 
1565
                            }
 
1566
                            if (!found && isSameFile)
 
1567
                            {
 
1568
                                if (((int)data2->m_pToken->m_LineStart <= line) && ((int)data2->m_pToken->m_LineEnd >= line))
 
1569
                                {
 
1570
                                    MarkItem(tree, item2);
 
1571
                                    found = true;
 
1572
                                }
 
1573
                            }
 
1574
                        }
 
1575
                    }
 
1576
                    item2 = tree->GetNextChild(item, cookie2);
 
1577
                }
 
1578
            }
 
1579
        }
 
1580
        item = tree->GetNextChild(root, cookie);
 
1581
    }
 
1582
    return (found || foundFile);
 
1583
}
 
1584
 
 
1585
 
 
1586
bool WorkspaceBrowserBuilder::IsLineInGlobals(const wxString& file, int line)
 
1587
{
 
1588
    if (m_Options.showIncludeSeparately && m_pParser->IsIncludeFile(file))
 
1589
        return false;
 
1590
 
 
1591
    int tokenKindMask = tkFunction | tkProgram | tkSubroutine;
 
1592
    TokensArrayF* pTokens = m_pParser->GetTokens();
 
1593
    bool found = false;
 
1594
    bool foundFileToken = false;
 
1595
    for (size_t i=0; i < pTokens->GetCount(); ++i)
 
1596
    {
 
1597
        TokenF* token = pTokens->Item(i);
 
1598
 
 
1599
        if (token->m_TokenKind == tkFile && token->m_Filename.IsSameAs(file))
 
1600
        {
 
1601
            switch (m_Options.displayFilter)
 
1602
            {
 
1603
                case bdfFile:
 
1604
                {
 
1605
                    foundFileToken = true;
 
1606
                    break;
 
1607
                }
 
1608
                case bdfProject:
 
1609
                {
 
1610
                    for (FilesList::iterator it = m_pActiveProject->GetFilesList().begin(); it != m_pActiveProject->GetFilesList().end(); ++it)
 
1611
                    {
 
1612
                        ProjectFile* pf = *it;
 
1613
                        foundFileToken = UnixFilename(pf->file.GetFullPath()).IsSameAs(file);
 
1614
                        if(foundFileToken)
 
1615
                            break;
 
1616
                    }
 
1617
                    break;
 
1618
                }
 
1619
                default: // bdfWorkspace
 
1620
                {
 
1621
                    foundFileToken = true;
 
1622
                    break;
 
1623
                }
 
1624
            }
 
1625
            if (foundFileToken)
 
1626
            {
 
1627
                TokensArrayF* children = &token->m_Children;
 
1628
                for (size_t j=0; j < children->GetCount(); ++j)
 
1629
                {
 
1630
                    TokenF* childToken = children->Item(j);
 
1631
                    if (childToken->m_TokenKind & tokenKindMask)
 
1632
                    {
 
1633
                        if ( ((int)childToken->m_LineStart <= line) && ((int)childToken->m_LineEnd >= line) )
 
1634
                        {
 
1635
                            found = true;
 
1636
                            break;
 
1637
                        }
 
1638
                    }
 
1639
                }
 
1640
            }
 
1641
            break;
 
1642
        }
 
1643
    }
 
1644
    return found;
 
1645
}
 
1646
 
 
1647
 
 
1648
void WorkspaceBrowserBuilder::MakeVisibleCurrent()
 
1649
{
 
1650
    if (Manager::IsAppShuttingDown() || m_AtWork)
 
1651
        return;
 
1652
 
 
1653
    wxTreeItemIdValue cookie;
 
1654
    wxTreeItemId root = m_pTreeTop->GetRootItem();
 
1655
    if (!root.IsOk())
 
1656
        return;
 
1657
    wxTreeItemId item = m_pTreeTop->GetFirstChild(root, cookie);
 
1658
    while (item.IsOk())
 
1659
    {
 
1660
        if (m_pTreeTop->IsBold(item))
 
1661
        {
 
1662
            m_pTreeTop->SelectItem(item);
 
1663
            m_pTreeTop->EnsureVisible(item);
 
1664
            break;
 
1665
        }
 
1666
        item = m_pTreeTop->GetNextChild(root, cookie);
 
1667
    }
 
1668
 
 
1669
    if (m_Options.visibleBottomTree)
 
1670
    {
 
1671
        root = m_pTreeBottom->GetRootItem();
 
1672
        if (!root.IsOk())
 
1673
            return;
 
1674
        item = m_pTreeBottom->GetFirstChild(root, cookie);
 
1675
        bool found = false;
 
1676
        while (item.IsOk())
 
1677
        {
 
1678
            if (m_pTreeBottom->IsBold(item))
 
1679
            {
 
1680
                m_pTreeBottom->SelectItem(item);
 
1681
                m_pTreeBottom->EnsureVisible(item);
 
1682
                break;
 
1683
            }
 
1684
            else if (m_pTreeBottom->HasChildren(item))
 
1685
            {
 
1686
                wxTreeItemIdValue cookie2;
 
1687
                wxTreeItemId item2 = m_pTreeBottom->GetFirstChild(item, cookie2);
 
1688
                while (item2.IsOk())
 
1689
                {
 
1690
                    if (m_pTreeBottom->IsBold(item2))
 
1691
                    {
 
1692
                        m_pTreeBottom->SelectItem(item2);
 
1693
                        m_pTreeBottom->EnsureVisible(item2);
 
1694
                        found = true;
 
1695
                        break;
 
1696
                    }
 
1697
                    item2 = m_pTreeBottom->GetNextChild(item, cookie2);
 
1698
                }
 
1699
                if (found)
 
1700
                    break;
 
1701
            }
 
1702
            item = m_pTreeBottom->GetNextChild(root, cookie);
 
1703
        }
 
1704
    }
 
1705
}
 
1706
 
 
1707
void WorkspaceBrowserBuilder::AddIncludeFiles(wxTreeCtrl* tree, wxTreeItemId parent)
 
1708
{
 
1709
    if (Manager::IsAppShuttingDown())
 
1710
        return;
 
1711
 
 
1712
    int tokenKindMask = tkModule | tkFunction | tkProgram | tkSubroutine | tkInterface | tkInterfaceExplicit | tkBlockData |
 
1713
                    tkType | tkVariable | tkProcedure | tkAccessList | tkCommonblock | tkSubmodule;
 
1714
 
 
1715
    bool sorted = m_Options.sortAlphabetically;
 
1716
    switch (m_Options.displayFilter)
 
1717
    {
 
1718
        case bdfFile:
 
1719
        {
 
1720
            if (m_pParser->IsIncludeFile(m_ActiveFilename))
 
1721
            {
 
1722
                TokenF* fileToken= m_pParser->FindFile(m_ActiveFilename);
 
1723
                if (fileToken)
 
1724
                {
 
1725
                    wxFileName fn(m_ActiveFilename);
 
1726
                    wxString tn = _("include '");
 
1727
                    tn << fn.GetFullName() << _("'");
 
1728
                    wxTreeItemId idni = AddNodeIfNotThere(tree, parent, tn, m_ImgNr["symbols_folder"], new TreeDataF(sfFile, fileToken), sorted);
 
1729
                    AddFileNodes(tree, idni, UnixFilename(m_ActiveFilename), tokenKindMask);
 
1730
                }
 
1731
            }
 
1732
            break;
 
1733
        }
 
1734
        case bdfProject:
 
1735
        {
 
1736
            for (FilesList::iterator it = m_pActiveProject->GetFilesList().begin(); it != m_pActiveProject->GetFilesList().end(); ++it)
 
1737
            {
 
1738
                ProjectFile* pf = *it;
 
1739
                if (m_pParser->IsIncludeFile(pf->file.GetFullPath()))
 
1740
                {
 
1741
                    TokenF* fileToken= m_pParser->FindFile(pf->file.GetFullPath());
 
1742
                    if (fileToken)
 
1743
                    {
 
1744
                        wxString tn = _("include '");
 
1745
                        tn << pf->file.GetFullName() << _("'");
 
1746
                        wxTreeItemId idni = AddNodeIfNotThere(tree, parent, tn, m_ImgNr["symbols_folder"], new TreeDataF(sfFile, fileToken), sorted);
 
1747
                        AddFileNodes(tree, idni, UnixFilename(pf->file.GetFullPath()), tokenKindMask);
 
1748
                    }
 
1749
                }
 
1750
            }
 
1751
            break;
 
1752
        }
 
1753
        case bdfWorkspace:
 
1754
        {
 
1755
            TokensArrayF* pTokens = m_pParser->GetTokens();
 
1756
            for (size_t i=0; i< pTokens->GetCount(); ++i)
 
1757
            {
 
1758
                TokenF* token = pTokens->Item(i);
 
1759
                if (token->m_TokenKind == tkFile &&
 
1760
                    m_pParser->IsIncludeFile(token->m_Filename))
 
1761
                {
 
1762
                    wxString tn = _("include '");
 
1763
                    tn << token->m_DisplayName << _("'");
 
1764
                    wxTreeItemId idni = AddNodeIfNotThere(tree, parent, tn, m_ImgNr["symbols_folder"], new TreeDataF(sfFile, token), sorted);
 
1765
                    AddChildrenNodes(tree, idni, token, tokenKindMask);
 
1766
                }
 
1767
            }
 
1768
            break;
 
1769
        }
 
1770
    }
 
1771
}
 
1772
 
 
1773
void WorkspaceBrowserBuilder::SetActiveProject(cbProject* prj)
 
1774
{
 
1775
    m_pActiveProject = prj;
 
1776
}
 
1777