KiCad PCB EDA Suite
Loading...
Searching...
No Matches
lib_tree_model_adapter.cpp
Go to the documentation of this file.
1/*
2 * This program source code file is part of KiCad, a free EDA CAD application.
3 *
4 * Copyright (C) 2017 Chris Pavlina <[email protected]>
5 * Copyright (C) 2014 Henner Zeller <[email protected]>
6 * Copyright (C) 2023 CERN
7 * Copyright The KiCad Developers, see AUTHORS.txt for contributors.
8 *
9 * This program is free software: you can redistribute it and/or modify it
10 * under the terms of the GNU General Public License as published by the
11 * Free Software Foundation, either version 3 of the License, or (at your
12 * option) any later version.
13 *
14 * This program is distributed in the hope that it will be useful, but
15 * WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public License along
20 * with this program. If not, see <http://www.gnu.org/licenses/>.
21 */
22
23#include <eda_base_frame.h>
24#include <eda_pattern_match.h>
25#include <kiface_base.h>
26#include <kiplatform/ui.h>
30#include <widgets/ui_common.h>
31#include <wx/tokenzr.h>
32#include <wx/wupdlock.h>
33#include <wx/settings.h>
34#include <wx/dc.h>
35#include <wx/log.h>
36#include <string_utils.h>
37
38
39static const int kDataViewIndent = 20;
40
41
42class LIB_TREE_RENDERER : public wxDataViewCustomRenderer
43{
44public:
46 m_canvasItem( false )
47 {}
48
49 wxSize GetSize() const override
50 {
51 return wxSize( GetOwner()->GetWidth(), GetTextExtent( m_text ).y + 2 );
52 }
53
54 bool GetValue( wxVariant& aValue ) const override
55 {
56 aValue = m_text;
57 return true;
58 }
59
60 bool SetValue( const wxVariant& aValue ) override
61 {
62 m_text = aValue.GetString();
63 return true;
64 }
65
66 void SetAttr( const wxDataViewItemAttr& aAttr ) override
67 {
68 // Use strikethrough as a proxy for is-canvas-item
69 m_canvasItem = aAttr.GetStrikethrough();
70
71 wxDataViewItemAttr realAttr = aAttr;
72 realAttr.SetStrikethrough( false );
73
74 wxDataViewCustomRenderer::SetAttr( realAttr );
75 }
76
77 bool Render( wxRect aRect, wxDC *dc, int aState ) override
78 {
79 RenderBackground( dc, aRect );
80
81 if( m_canvasItem )
82 {
83 wxPoint points[6];
84 points[0] = aRect.GetTopLeft();
85 points[1] = aRect.GetTopRight() + wxPoint( -4, 0 );
86 points[2] = aRect.GetTopRight() + wxPoint( 0, aRect.GetHeight() / 2 );
87 points[3] = aRect.GetBottomRight() + wxPoint( -4, 1 );
88 points[4] = aRect.GetBottomLeft() + wxPoint( 0, 1 );
89 points[5] = aRect.GetTopLeft();
90
91 dc->SetPen( KIPLATFORM::UI::IsDarkTheme() ? *wxWHITE_PEN : *wxBLACK_PEN );
92 dc->DrawLines( 6, points );
93 }
94
95 aRect.Deflate( 1 );
96
97#ifdef __WXOSX__
98 // We should be able to pass wxDATAVIEW_CELL_SELECTED into RenderText() and have it do
99 // the right thing -- but it picks wxSYS_COLOUR_HIGHLIGHTTEXT on MacOS (instead
100 // of wxSYS_COLOUR_LISTBOXHIGHLIGHTTEXT).
101 if( aState & wxDATAVIEW_CELL_SELECTED )
102 dc->SetTextForeground( wxSystemSettings::GetColour( wxSYS_COLOUR_LISTBOXHIGHLIGHTTEXT ) );
103
104 RenderText( m_text, 0, aRect, dc, 0 );
105#else
106 RenderText( m_text, 0, aRect, dc, aState );
107#endif
108 return true;
109 }
110
111private:
113 wxString m_text;
114};
115
116
117wxDataViewItem LIB_TREE_MODEL_ADAPTER::ToItem( const LIB_TREE_NODE* aNode )
118{
119 return wxDataViewItem( const_cast<void*>( static_cast<void const*>( aNode ) ) );
120}
121
122
124{
125 return static_cast<LIB_TREE_NODE*>( aItem.GetID() );
126}
127
128
130 const wxString& aPinnedKey,
131 APP_SETTINGS_BASE::LIB_TREE& aSettingsStruct ) :
132 m_widget( nullptr ),
133 m_parent( aParent ),
134 m_cfg( aSettingsStruct ),
136 m_show_units( true ),
137 m_preselect_unit( 0 ),
138 m_freeze( 0 ),
139 m_filter( nullptr )
140{
141 // Default column widths. Do not translate these names.
142 m_colWidths[ _HKI( "Item" ) ] = 300;
143 m_colWidths[ _HKI( "Description" ) ] = 600;
144
145 m_availableColumns = { _HKI( "Item" ), _HKI( "Description" ) };
146
147 for( const std::pair<const wxString, int>& pair : m_cfg.column_widths )
148 m_colWidths[pair.first] = pair.second;
149
150 m_shownColumns = m_cfg.columns;
151
152 if( m_shownColumns.empty() )
153 m_shownColumns = { _HKI( "Item" ), _HKI( "Description" ) };
154
155 if( m_shownColumns[0] != _HKI( "Item" ) )
156 m_shownColumns.insert( m_shownColumns.begin(), _HKI( "Item" ) );
157}
158
159
162
163
164std::vector<wxString> LIB_TREE_MODEL_ADAPTER::GetOpenLibs() const
165{
166 std::vector<wxString> openLibs;
167 wxDataViewItem rootItem( nullptr );
168 wxDataViewItemArray children;
169
170 GetChildren( rootItem, children );
171
172 for( const wxDataViewItem& child : children )
173 {
174 if( m_widget->IsExpanded( child ) )
175 openLibs.emplace_back( ToNode( child )->m_LibId.GetLibNickname().wx_str() );
176 }
177
178 return openLibs;
179}
180
181
182void LIB_TREE_MODEL_ADAPTER::OpenLibs( const std::vector<wxString>& aLibs )
183{
184 wxWindowUpdateLocker updateLock( m_widget );
185
186 for( const wxString& lib : aLibs )
187 {
188 wxDataViewItem item = FindItem( LIB_ID( lib, wxEmptyString ) );
189
190 if( item.IsOk() )
191 m_widget->Expand( item );
192 }
193}
194
195
197{
198 if( m_widget )
199 {
200 m_cfg.columns = GetShownColumns();
201 m_cfg.column_widths.clear();
202
203 for( const std::pair<const wxString, wxDataViewColumn*>& pair : m_colNameMap )
204 m_cfg.column_widths[pair.first] = pair.second->GetWidth();
205
206 m_cfg.open_libs = GetOpenLibs();
207 }
208}
209
210
212{
213 m_show_units = aShow;
214}
215
216
217void LIB_TREE_MODEL_ADAPTER::SetPreselectNode( const LIB_ID& aLibId, int aUnit )
218{
219 m_preselect_lib_id = aLibId;
220 m_preselect_unit = aUnit;
221}
222
223
225 const wxString& aDesc,
226 bool pinned )
227{
228 LIB_TREE_NODE_LIBRARY& lib_node = m_tree.AddLib( aNodeName, aDesc );
229
230 lib_node.m_Pinned = pinned;
231
232 return lib_node;
233}
234
235
237 const wxString& aDesc,
238 const std::vector<LIB_TREE_ITEM*>& aItemList,
239 bool pinned, bool presorted )
240{
241 LIB_TREE_NODE_LIBRARY& lib_node = DoAddLibraryNode( aNodeName, aDesc, pinned );
242
243 for( LIB_TREE_ITEM* item: aItemList )
244 lib_node.AddItem( item );
245
246 lib_node.AssignIntrinsicRanks( m_shownColumns, presorted );
247
248 return lib_node;
249}
250
251
252void LIB_TREE_MODEL_ADAPTER::RemoveGroup( bool aRecentGroup, bool aPlacedGroup )
253{
254 m_tree.RemoveGroup( aRecentGroup, aPlacedGroup );
255}
256
257
258void LIB_TREE_MODEL_ADAPTER::UpdateSearchString( const wxString& aSearch, bool aState )
259{
260 {
261 wxWindowUpdateLocker updateLock( m_widget );
262
263 // Even with the updateLock, wxWidgets sometimes ties its knickers in a knot trying to
264 // run a wxdataview_selection_changed_callback() on a row that has been deleted.
265 // https://bugs.launchpad.net/kicad/+bug/1756255
266 m_widget->UnselectAll();
267
268 // This collapse is required before the call to "Freeze()" below. Once Freeze()
269 // is called, GetParent() will return nullptr. While this works for some calls, it
270 // segfaults when we have any expanded elements b/c the sub units in the tree don't
271 // have explicit references that are maintained over a search
272 // The tree will be expanded again below when we get our matches
273 //
274 // Also note that this cannot happen when we have deleted a symbol as GTK will also
275 // iterate over the tree in this case and find a symbol that has an invalid link
276 // and crash https://gitlab.com/kicad/code/kicad/-/issues/6910
277 if( !aState && !aSearch.IsNull() && m_tree.m_Children.size() )
278 {
279 for( std::unique_ptr<LIB_TREE_NODE>& child: m_tree.m_Children )
280 m_widget->Collapse( wxDataViewItem( &*child ) );
281 }
282
283 // DO NOT REMOVE THE FREEZE/THAW. This freeze/thaw is a flag for this model adapter
284 // that tells it when it shouldn't trust any of the data in the model. When set, it will
285 // not return invalid data to the UI, since this invalid data can cause crashes.
286 // This is different than the update locker, which locks the UI aspects only.
287 Freeze();
288 BeforeReset();
289
290 // Don't cause KiCad to hang if someone accidentally pastes the PCB or schematic into
291 // the search box.
292 constexpr int MAX_TERMS = 100;
293
294 wxStringTokenizer tokenizer( aSearch, " \t\r\n", wxTOKEN_STRTOK );
295 std::vector<std::unique_ptr<EDA_COMBINED_MATCHER>> termMatchers;
296
297 while( tokenizer.HasMoreTokens() && termMatchers.size() < MAX_TERMS )
298 {
299 wxString term = tokenizer.GetNextToken().Lower();
300 termMatchers.emplace_back( std::make_unique<EDA_COMBINED_MATCHER>( term, CTX_LIBITEM ) );
301 }
302
303 m_tree.UpdateScore( termMatchers, m_filter );
304
305 m_tree.SortNodes( m_sort_mode == BEST_MATCH );
306 AfterReset();
307 Thaw();
308 }
309
310 const LIB_TREE_NODE* firstMatch = ShowResults();
311
312#ifdef __WXGTK__
313 // Ensure the control is repainted with the updated data. Without an explicit
314 // refresh the Gtk port can display stale rows until the user interacts with
315 // them, leading to mismatched tree contents.
316 m_widget->Refresh();
317 m_widget->Update();
318 wxYield();
319#endif
320
321 if( firstMatch )
322 {
323 wxDataViewItem item = ToItem( firstMatch );
324 m_widget->Select( item );
325
326 // Make sure the *parent* item is visible. The selected item is the first (shown) child
327 // of the parent. So it's always right below the parent, and this way the user can also
328 // see what library the selected part belongs to, without having a case where the selection
329 // is off the screen (unless the window is a single row high, which is unlikely).
330 //
331 // This also happens to circumvent https://bugs.launchpad.net/kicad/+bug/1804400 which
332 // appears to be a GTK+3 bug.
333 {
334 wxDataViewItem parent = GetParent( item );
335
336 if( parent.IsOk() )
337 m_widget->EnsureVisible( parent );
338 }
339
340 m_widget->EnsureVisible( item );
341 }
342}
343
344
345void LIB_TREE_MODEL_ADAPTER::AttachTo( wxDataViewCtrl* aDataViewCtrl )
346{
347 m_widget = aDataViewCtrl;
348 aDataViewCtrl->SetIndent( kDataViewIndent );
349 aDataViewCtrl->AssociateModel( this );
351}
352
353
355{
356 m_widget->ClearColumns();
357
358 m_columns.clear();
359 m_colIdxMap.clear();
360 m_colNameMap.clear();
361
362 // The Item column is always shown
363 doAddColumn( wxT( "Item" ) );
364
365 for( const wxString& colName : m_shownColumns )
366 {
367 if( !m_colNameMap.count( colName ) )
368 doAddColumn( colName, colName == wxT( "Description" ) );
369 }
370}
371
372
374{
375 Freeze();
376 BeforeReset();
377
378 m_tree.SortNodes( m_sort_mode == BEST_MATCH );
379
380 AfterReset();
381 Thaw();
382}
383
384
386{
387 m_parent->Prj().PinLibrary( aTreeNode->m_LibId.GetLibNickname(), getLibType() );
388 aTreeNode->m_Pinned = true;
389
390 resortTree();
391 m_widget->EnsureVisible( ToItem( aTreeNode ) );
392}
393
394
396{
397 m_parent->Prj().UnpinLibrary( aTreeNode->m_LibId.GetLibNickname(), getLibType() );
398 aTreeNode->m_Pinned = false;
399
400 resortTree();
401 // Keep focus at top when unpinning
402}
403
404
406{
408
409 for( const std::unique_ptr<LIB_TREE_NODE>& lib: m_tree.m_Children )
410 {
411 if( lib->m_IsRecentlyUsedGroup )
412 lib->m_Name = wxT( "-- " ) + _( "Recently Used" ) + wxT( " --" );
413 else if( lib->m_IsAlreadyPlacedGroup )
414 lib->m_Name = wxT( "-- " ) + _( "Already Placed" ) + wxT( " --" );
415 }
416}
417
418
419wxDataViewColumn* LIB_TREE_MODEL_ADAPTER::doAddColumn( const wxString& aHeader, bool aTranslate )
420{
421 wxString translatedHeader = aTranslate ? wxGetTranslation( aHeader ) : aHeader;
422
423 // The extent of the text doesn't take into account the space on either side
424 // in the header, so artificially pad it
425 wxSize headerMinWidth = KIUI::GetTextSize( translatedHeader + wxT( "MMM" ), m_widget );
426
427 if( !m_colWidths.count( aHeader ) || m_colWidths[aHeader] < headerMinWidth.x )
428 m_colWidths[aHeader] = headerMinWidth.x;
429
430 int index = (int) m_columns.size();
431
432 wxDataViewColumn* col = new wxDataViewColumn(
433 translatedHeader, new LIB_TREE_RENDERER(), index, m_colWidths[aHeader], wxALIGN_NOT,
434 wxDATAVIEW_CELL_INERT | static_cast<int>( wxDATAVIEW_COL_RESIZABLE ) );
435 m_widget->AppendColumn( col );
436
437 col->SetMinWidth( headerMinWidth.x );
438
439 m_columns.emplace_back( col );
440 m_colNameMap[aHeader] = col;
441 m_colIdxMap[m_columns.size() - 1] = aHeader;
442
443 return col;
444}
445
446
447void LIB_TREE_MODEL_ADAPTER::addColumnIfNecessary( const wxString& aHeader )
448{
449 if( m_colNameMap.count( aHeader ) )
450 return;
451
452 // Columns will be created later
453 m_colNameMap[aHeader] = nullptr;
454 m_availableColumns.emplace_back( aHeader );
455}
456
457
458void LIB_TREE_MODEL_ADAPTER::SetShownColumns( const std::vector<wxString>& aColumnNames )
459{
460 bool recreate = m_shownColumns != aColumnNames;
461
462 m_shownColumns = aColumnNames;
463
464 if( recreate && m_widget )
466
467 for( std::unique_ptr<LIB_TREE_NODE>& lib: m_tree.m_Children )
468 lib->AssignIntrinsicRanks( m_shownColumns );
469}
470
471
472LIB_ID LIB_TREE_MODEL_ADAPTER::GetAliasFor( const wxDataViewItem& aSelection ) const
473{
474 const LIB_TREE_NODE* node = ToNode( aSelection );
475 return node ? node->m_LibId : LIB_ID();
476}
477
478
479int LIB_TREE_MODEL_ADAPTER::GetUnitFor( const wxDataViewItem& aSelection ) const
480{
481 const LIB_TREE_NODE* node = ToNode( aSelection );
482 return node ? node->m_Unit : 0;
483}
484
485
486LIB_TREE_NODE::TYPE LIB_TREE_MODEL_ADAPTER::GetTypeFor( const wxDataViewItem& aSelection ) const
487{
488 const LIB_TREE_NODE* node = ToNode( aSelection );
489 return node ? node->m_Type : LIB_TREE_NODE::TYPE::INVALID;
490}
491
492
493LIB_TREE_NODE* LIB_TREE_MODEL_ADAPTER::GetTreeNodeFor( const wxDataViewItem& aSelection ) const
494{
495 return ToNode( aSelection );
496}
497
498
500{
501 int n = 0;
502
503 for( const std::unique_ptr<LIB_TREE_NODE>& lib: m_tree.m_Children )
504 n += lib->m_Children.size();
505
506 return n;
507}
508
509
510wxDataViewItem LIB_TREE_MODEL_ADAPTER::FindItem( const LIB_ID& aLibId )
511{
512 for( std::unique_ptr<LIB_TREE_NODE>& lib: m_tree.m_Children )
513 {
514 if( lib->m_Name != aLibId.GetLibNickname().wx_str() )
515 continue;
516
517 // if part name is not specified, return the library node
518 if( aLibId.GetLibItemName() == "" )
519 return ToItem( lib.get() );
520
521 for( std::unique_ptr<LIB_TREE_NODE>& alias: lib->m_Children )
522 {
523 if( alias->m_Name == aLibId.GetLibItemName().wx_str() )
524 return ToItem( alias.get() );
525 }
526
527 break; // could not find the part in the requested library
528 }
529
530 return wxDataViewItem();
531}
532
533
538
539
540unsigned int LIB_TREE_MODEL_ADAPTER::GetChildren( const wxDataViewItem& aItem,
541 wxDataViewItemArray& aChildren ) const
542{
543 const LIB_TREE_NODE* node = ( aItem.IsOk() ? ToNode( aItem ) : &m_tree );
544 unsigned int count = 0;
545
546 if( node->m_Type == LIB_TREE_NODE::TYPE::ROOT
547 || node->m_Type == LIB_TREE_NODE::TYPE::LIBRARY
548 || ( m_show_units && node->m_Type == LIB_TREE_NODE::TYPE::ITEM ) )
549 {
550 for( std::unique_ptr<LIB_TREE_NODE> const& child: node->m_Children )
551 {
552 if( child->m_Score > 0 )
553 {
554 aChildren.Add( ToItem( &*child ) );
555 ++count;
556 }
557 }
558 }
559
560 return count;
561}
562
563
565{
566 wxDataViewColumn* col = nullptr;
567 size_t idx = 0;
568 int totalWidth = 0;
569 wxString header;
570
571 for( ; idx < m_columns.size() - 1; idx++ )
572 {
573 wxASSERT( m_colIdxMap.count( idx ) );
574
575 col = m_columns[idx];
576 header = m_colIdxMap[idx];
577
578 wxASSERT( m_colWidths.count( header ) );
579
580 col->SetWidth( m_colWidths[header] );
581 totalWidth += col->GetWidth();
582 }
583
584 int remainingWidth = m_widget->GetSize().x - totalWidth;
585 header = m_columns[idx]->GetTitle();
586
587 m_columns[idx]->SetWidth( std::max( m_colWidths[header], remainingWidth ) );
588}
589
590
592{
593 // Yes, this is an enormous hack. But it works on all platforms, it doesn't suffer
594 // the On^2 sorting issues that ItemChanged() does on OSX, and it doesn't lose the
595 // user's scroll position (which re-attaching or deleting/re-inserting columns does).
596 static int walk = 1;
597
598 std::vector<int> widths;
599
600 for( const wxDataViewColumn* col : m_columns )
601 widths.emplace_back( col->GetWidth() );
602
603 wxASSERT( widths.size() );
604
605 // Only use the widths read back if they are non-zero.
606 // GTK returns the displayed width of the column, which is not calculated immediately
607 if( widths[0] > 0 )
608 {
609 size_t i = 0;
610
611 for( const auto& [ colName, colPtr ] : m_colNameMap )
612 m_colWidths[ colName ] = widths[i++];
613 }
614
615 auto colIt = m_colWidths.begin();
616
617 colIt->second += walk;
618 colIt++;
619
620 if( colIt != m_colWidths.end() )
621 colIt->second -= walk;
622
623 for( const auto& [ colName, colPtr ] : m_colNameMap )
624 {
625 if( colPtr == m_columns[0] )
626 continue;
627
628 wxASSERT( m_colWidths.count( colName ) );
629 colPtr->SetWidth( m_colWidths[ colName ] );
630 }
631
632 walk = -walk;
633}
634
635
636bool LIB_TREE_MODEL_ADAPTER::HasContainerColumns( const wxDataViewItem& aItem ) const
637{
638 return IsContainer( aItem );
639}
640
641
642bool LIB_TREE_MODEL_ADAPTER::IsContainer( const wxDataViewItem& aItem ) const
643{
644 LIB_TREE_NODE* node = ToNode( aItem );
645 return node ? node->m_Children.size() : true;
646}
647
648
649wxDataViewItem LIB_TREE_MODEL_ADAPTER::GetParent( const wxDataViewItem& aItem ) const
650{
651 if( m_freeze )
652 return ToItem( nullptr );
653
654 LIB_TREE_NODE* node = ToNode( aItem );
655 LIB_TREE_NODE* parent = node ? node->m_Parent : nullptr;
656
657 // wxDataViewModel has no root node, but rather top-level elements have
658 // an invalid (null) parent.
659 if( !node || !parent || parent->m_Type == LIB_TREE_NODE::TYPE::ROOT )
660 return ToItem( nullptr );
661 else
662 return ToItem( parent );
663}
664
665
666void LIB_TREE_MODEL_ADAPTER::GetValue( wxVariant& aVariant,
667 const wxDataViewItem& aItem,
668 unsigned int aCol ) const
669{
670 if( IsFrozen() )
671 {
672 aVariant = wxEmptyString;
673 return;
674 }
675
676 LIB_TREE_NODE* node = ToNode( aItem );
677 wxCHECK( node, /* void */ );
678 wxString valueStr;
679
680 switch( aCol )
681 {
682 case NAME_COL:
683 if( node->m_Pinned )
684 valueStr = GetPinningSymbol() + UnescapeString( node->m_Name );
685 else
686 valueStr = UnescapeString( node->m_Name );
687
688 break;
689
690 default:
691 if( m_colIdxMap.count( aCol ) )
692 {
693 const wxString& key = m_colIdxMap.at( aCol );
694
695 if( key == wxT( "Description" ) )
696 valueStr = UnescapeString( node->m_Desc );
697 else if( node->m_Fields.count( key ) )
698 valueStr = UnescapeString( node->m_Fields.at( key ) );
699 else
700 valueStr = wxEmptyString;
701 }
702
703 break;
704 }
705
706 valueStr.Replace( wxS( "\n" ), wxS( " " ) ); // Clear line breaks
707
708 aVariant = valueStr;
709}
710
711
712bool LIB_TREE_MODEL_ADAPTER::GetAttr( const wxDataViewItem& aItem,
713 unsigned int aCol,
714 wxDataViewItemAttr& aAttr ) const
715{
716 if( IsFrozen() )
717 return false;
718
719 LIB_TREE_NODE* node = ToNode( aItem );
720 wxCHECK( node, false );
721
722 if( node->m_Type == LIB_TREE_NODE::TYPE::ITEM )
723 {
724 if( !node->m_IsRoot && aCol == 0 )
725 {
726 // Names of non-root aliases are italicized
727 aAttr.SetItalic( true );
728 return true;
729 }
730 }
731
732 return false;
733}
734
735
736void recursiveDescent( LIB_TREE_NODE& aNode, const std::function<int( const LIB_TREE_NODE* )>& f )
737{
738 for( std::unique_ptr<LIB_TREE_NODE>& node: aNode.m_Children )
739 {
740 int r = f( node.get() );
741
742 if( r == 0 )
743 break;
744 else if( r == -1 )
745 continue;
746
747 recursiveDescent( *node, f );
748 }
749}
750
751
753{
754 const LIB_TREE_NODE* firstMatch = nullptr;
755
756 // Expand parents of leaf nodes with some level of matching
758 [&]( const LIB_TREE_NODE* n )
759 {
760 if( n->m_Type == LIB_TREE_NODE::TYPE::ITEM && n->m_Score > 1 )
761 {
762 if( !firstMatch )
763 firstMatch = n;
764 else if( n->m_Score > firstMatch->m_Score )
765 firstMatch = n;
766
767 m_widget->ExpandAncestors( ToItem( n ) );
768 }
769
770 return 1; // keep going to expand ancestors of all found items
771 } );
772
773 // If no matches, find and show the preselect node
774 if( !firstMatch && m_preselect_lib_id.IsValid() )
775 {
777 [&]( const LIB_TREE_NODE* n )
778 {
779 // Don't match the recent and already placed libraries
780 if( n->m_Name.StartsWith( "-- " ) )
781 return -1; // Skip this node and its children
782
783 if( n->m_Type == LIB_TREE_NODE::TYPE::ITEM
784 && ( n->m_Children.empty() || !m_preselect_unit )
785 && m_preselect_lib_id == n->m_LibId )
786 {
787 firstMatch = n;
788 m_widget->ExpandAncestors( ToItem( n ) );
789 return 0;
790 }
791 else if( n->m_Type == LIB_TREE_NODE::TYPE::UNIT
794 {
795 firstMatch = n;
796 m_widget->ExpandAncestors( ToItem( n ) );
797 return 0;
798 }
799
800 return 1;
801 } );
802 }
803
804 // If still no matches expand a single library if there is only one
805 if( !firstMatch )
806 {
807 int libraries = 0;
808
809 for( const std::unique_ptr<LIB_TREE_NODE>& child : m_tree.m_Children )
810 {
811 if( !child->m_Name.StartsWith( "-- " ) )
812 libraries++;
813 }
814
815 if( libraries != 1 )
816 return nullptr;
817
819 [&]( const LIB_TREE_NODE* n )
820 {
821 if( n->m_Type == LIB_TREE_NODE::TYPE::ITEM )
822 {
823 firstMatch = n;
824 m_widget->ExpandAncestors( ToItem( n ) );
825 return 0;
826 }
827
828 return 1;
829 } );
830 }
831
832 return firstMatch;
833}
834
835
The base frame for deriving all KiCad main window classes.
A logical library item identifier and consists of various portions much like a URI.
Definition lib_id.h:49
const UTF8 & GetLibItemName() const
Definition lib_id.h:102
const UTF8 & GetLibNickname() const
Return the logical library name portion of a LIB_ID.
Definition lib_id.h:87
A mix-in to provide polymorphism between items stored in libraries (symbols, aliases and footprints).
LIB_TREE_MODEL_ADAPTER(EDA_BASE_FRAME *aParent, const wxString &aPinnedKey, APP_SETTINGS_BASE::LIB_TREE &aSettingsStruct)
Create the adapter.
std::vector< wxString > GetOpenLibs() const
int GetUnitFor(const wxDataViewItem &aSelection) const
Return the unit for the given item.
LIB_TREE_NODE::TYPE GetTypeFor(const wxDataViewItem &aSelection) const
Return node type for the given item.
APP_SETTINGS_BASE::LIB_TREE & m_cfg
bool GetAttr(const wxDataViewItem &aItem, unsigned int aCol, wxDataViewItemAttr &aAttr) const override
Get any formatting for an item.
std::map< wxString, int > m_colWidths
void FinishTreeInitialization()
A final-stage initialization to be called after the window hierarchy has been realized and the window...
void addColumnIfNecessary(const wxString &aHeader)
void PinLibrary(LIB_TREE_NODE *aTreeNode)
virtual PROJECT::LIB_TYPE_T getLibType()=0
virtual wxDataViewItem GetCurrentDataViewItem()
void SetPreselectNode(const LIB_ID &aLibId, int aUnit)
Set the symbol name to be selected if there are no search results.
static LIB_TREE_NODE * ToNode(wxDataViewItem aItem)
Convert wxDataViewItem -> #SYM_TREE_NODE.
LIB_ID GetAliasFor(const wxDataViewItem &aSelection) const
Return the alias for the given item.
void AttachTo(wxDataViewCtrl *aDataViewCtrl)
Attach to a wxDataViewCtrl and initialize it.
void SetShownColumns(const std::vector< wxString > &aColumnNames)
Sets which columns are shown in the widget.
static wxDataViewItem ToItem(const LIB_TREE_NODE *aNode)
Convert #SYM_TREE_NODE -> wxDataViewItem.
bool IsContainer(const wxDataViewItem &aItem) const override
Check whether an item can have children.
static const wxString GetPinningSymbol()
void ShowUnits(bool aShow)
Whether or not to show units.
LIB_TREE_NODE * GetTreeNodeFor(const wxDataViewItem &aSelection) const
unsigned int GetChildren(const wxDataViewItem &aItem, wxDataViewItemArray &aChildren) const override
Populate a list of all the children of an item.
void SaveSettings()
Save the column widths to the config file.
@ NAME_COL
Library or library item name column.
std::map< unsigned, wxString > m_colIdxMap
wxDataViewColumn * doAddColumn(const wxString &aHeader, bool aTranslate=true)
std::vector< wxDataViewColumn * > m_columns
std::vector< wxString > GetShownColumns() const
int GetItemCount() const
Return the number of symbols loaded in the tree.
const LIB_TREE_NODE * ShowResults()
Find and expand successful search results.
std::vector< wxString > m_shownColumns
void RemoveGroup(bool aRecentlyUsedGroup, bool aAlreadyPlacedGroup)
Remove one of the system groups from the library.
void GetValue(wxVariant &aVariant, const wxDataViewItem &aItem, unsigned int aCol) const override
Get the value of an item.
void UnpinLibrary(LIB_TREE_NODE *aTreeNode)
std::map< wxString, wxDataViewColumn * > m_colNameMap
bool HasContainerColumns(const wxDataViewItem &aItem) const override
Check whether a container has columns too.
wxDataViewItem GetParent(const wxDataViewItem &aItem) const override
Get the parent of an item.
LIB_TREE_NODE_LIBRARY & DoAddLibraryNode(const wxString &aNodeName, const wxString &aDesc, bool pinned)
std::vector< wxString > m_availableColumns
LIB_TREE_NODE_LIBRARY & DoAddLibrary(const wxString &aNodeName, const wxString &aDesc, const std::vector< LIB_TREE_ITEM * > &aItemList, bool pinned, bool presorted)
Add the given list of symbols by alias.
wxDataViewItem FindItem(const LIB_ID &aLibId)
Returns tree item corresponding to part.
void UpdateSearchString(const wxString &aSearch, bool aState)
Set the search string provided by the user.
std::function< bool(LIB_TREE_NODE &aNode)> * m_filter
void OpenLibs(const std::vector< wxString > &aLibs)
Node type: library.
LIB_TREE_NODE_ITEM & AddItem(LIB_TREE_ITEM *aItem)
Construct a new alias node, add it to this library, and return it.
Model class in the component selector Model-View-Adapter (mediated MVC) architecture.
std::map< wxString, wxString > m_Fields
List of weighted search terms.
PTR_VECTOR m_Children
LIB_TREE_NODE * m_Parent
void AssignIntrinsicRanks(const std::vector< wxString > &aShownColumns, bool presorted=false)
Store intrinsic ranks on all children of this node.
void SetAttr(const wxDataViewItemAttr &aAttr) override
bool SetValue(const wxVariant &aValue) override
wxSize GetSize() const override
bool GetValue(wxVariant &aValue) const override
bool Render(wxRect aRect, wxDC *dc, int aState) override
wxString wx_str() const
Definition utf8.cpp:45
static void recursiveDescent(wxSizer *aSizer, std::map< int, wxString > &aLabels)
#define _(s)
Base window classes and related definitions.
Abstract pattern-matching tool and implementations.
@ CTX_LIBITEM
void recursiveDescent(LIB_TREE_NODE &aNode, const std::function< int(const LIB_TREE_NODE *)> &f)
static const int kDataViewIndent
bool IsDarkTheme()
Determine if the desktop interface is currently using a dark theme or a light theme.
Definition wxgtk/ui.cpp:48
KICOMMON_API wxSize GetTextSize(const wxString &aSingleLine, wxWindow *aWindow)
Return the size of aSingleLine of text when it is rendered in aWindow using whatever font is currentl...
Definition ui_common.cpp:78
#define _HKI(x)
Definition page_info.cpp:44
wxString UnescapeString(const wxString &aSource)
Functions to provide common constants and other functions to assist in making a consistent UI.