acme
Foundational cross-platform layer of the ca2 framework
Loading...
Searching...
No Matches
tree.h
1#pragma once
2
3
4#include "acme/parallelization/synchronous_lock.h"
5#include "acme/prototype/data/tree_base.h"
6#include "acme/prototype/data/tree_item.h"
7
8
9namespace data
10{
11
12
13 template < prototype_item ITEM >
14 class tree :
15 virtual public ::data::tree_base,
16 virtual public ::data::tree_item < ITEM >
17 {
18 public:
19
20
21 pointer_array < tree > m_treea;
22 //::pointer<tree_item < ITEM >> m_proot;
23 bool m_bFill;
24 index_array m_iaLevelNext;
25
26
27
28
29 tree();
30 ~tree() override;
31
32 virtual ::pointer < ::data::tree_item < ITEM > > create_tree_item();
33 ::pointer < ::data::tree_item_base > _create_tree_item() override;
34
35 void destroy() override;
36
37 virtual void on_insert_tree(tree * ptree);
38
39 virtual ::i64 increment_reference_count() override
40 {
41 return ::matter::increment_reference_count();
42 }
43
44 virtual ::i64 decrement_reference_count() override
45 {
46 return ::matter::decrement_reference_count();
47 }
48
49
50 ::collection::count _tree_count() override;
51 tree_base * _tree_at(::collection::index iIndex) override;
52
53
54 void erase_all() override;
55
56 void update_tree() override;
57
58 tree_item < ITEM > * find(const ITEM * pitem, ::collection::index * piIndex = nullptr);
59 bool contains(const ITEM * pitem);
60
61 bool contains(const tree_item < ITEM > * pitem) override;
62
63 void _001OnTreeDataChange() override;
64
65 void _001OnItemExpand(::data::tree_item_base * ptreeitembase, const ::action_context & action_context) override;
66 void _001OnItemCollapse(::data::tree_item_base * ptreeitembase, const ::action_context & action_context) override;
67 void _001OnOpenItem(::data::tree_item_base * ptreeitembase, const ::action_context & action_context) override;
68 void _001OnItemContextMenu(::data::tree_item_base * ptreeitembase, const ::action_context & action_context, ::user::element * ptree, const ::i32_point & point) override;
69 //virtual void _001OnOpenItem(::data::tree_item_base * ptreeitembase, const ::action_context & context) override;
70
71 void erase(tree_item_ptr_array < ITEM > & itemptra);
72 void erase(tree_item < ITEM > * pitem);
73 void erase( ITEM * pitem, ::collection::index i = 0);
74
75
76 tree_item_base * __previous() override;
77 tree_item_base * __next() override;
78 //template < typename PRED >
79 //void sort_children(PRED pred)
80 //{
81
82 // tree_sort(this, pred);
83
84 //}
85 void sort_children(const ::function < bool(const tree_item < ITEM > * p1, const tree_item < ITEM > * p2) > & functionLess) override;
86
87 tree_item < ITEM > * _get_proper_item(::collection::index iIndex, ::collection::index * piLevel, ::collection::index * piCount = nullptr);
88 tree_item < ITEM > * get_proper_item(::collection::index iIndex, ::collection::index * piLevel) override;
89 ::collection::index get_proper_item_index(tree_item < ITEM > * pitemParam, ::collection::index * piLevel, ::collection::index * piCount = nullptr);
90// virtual ::collection::count get_proper_item_count() override;
91
92 void update_levels();
93
94 tree_item_base * _get_base_item() override { return get_base_item(); }
95
96
97 const tree_item_base * _get_base_item() const override { return get_base_item(); }
98
99 tree_item < ITEM > * get_base_item();
100
101 const tree_item < ITEM > * get_base_item() const;
102
103 tree_item < ITEM > * insert_item( ITEM * pitemNew, enum_relative erelativeNewItem = e_relative_last_child, tree_item < ITEM > * pitemRelative = nullptr, bool bVoidTreeDataChangeEvent = false);
104 bool insert_item(tree_item < ITEM > * pitemNew, enum_relative erelativeNewItem = e_relative_last_child, tree_item < ITEM > * pitemRelative = nullptr, bool bVoidTreeDataChangeEvent = false);
105
106 ::image::image_list * get_tree_image_list() override;
107
108 virtual void _001ExpandItem(tree_item < ITEM > * pitem, const ::action_context & action_context, bool bExpand = true, bool bRedraw = true, bool bLayout = true);
109 virtual void _001EnsureVisible(tree_item < ITEM > * pitem);
110 virtual void _001SelectItem(tree_item < ITEM > * pitem);
111
112 virtual void get_selection(::data::tree_item_ptr_array < ITEM> & itemptraSelected) const;
113 virtual bool is_selected(const tree_item < ITEM > * pitem) const;
114 virtual bool is_selected(const ITEM * pitem) const;
115
116 virtual ::collection::count selection_set(::data::tree_item_ptr_array < ITEM> & itemptra);
117 virtual bool selection_set(tree_item < ITEM > * pitem, bool bIfNotInSelection = false, bool bIfParentInSelection = false);
118 virtual bool selection_set( ITEM * pitem, bool bIfNotInSelection = false, bool bIfParentInSelection = false);
119 virtual bool selection_set(::collection::index iIndex, ITEM * pitem, bool bIfNotInSelection = false, bool bIfParentInSelection = false);
120
121
122 //void signal(::signal * psignal) override;
123 void handle(::topic * ptopic, ::handler_context * phandlercontext) override;
124
125
126 virtual void on_fill_children() override;
127 //virtual void start_fill_children();
128
129 void on_tree_layout() override;
130
131 void fill_children() override;
132
133
134 //virtual void tree_layout(::draw2d::graphics_pointer & pgraphics);
135
136
137 };
138
139 template < prototype_item ITEM >
140 tree < ITEM >::tree()
141 {
142
143 //defer_create_synchronization();
144
145 m_bFill = false;
146
147 //m_proot = allocateø tree_item < ITEM >();
148
149 //if (m_proot == nullptr)
150 //{
151
152 // throw ::exception(error_no_memory);
153
154 //}
155
156 this->m_etreeitemstate |= ::data::e_tree_item_state_expandable;
157
158 this->m_etreeitemstate |= ::data::e_tree_item_state_expanded;
159
160 this->m_ptree = this;
161
162 this->m_ptreeitemParent = allocateø tree_item < ITEM >();
163
164 this->m_ptreeitemParent->insert(e_relative_first_child, this);
165
166 }
167
168
169 template < prototype_item ITEM >
170 tree < ITEM >::~tree()
171 {
172
173 }
174
175 template < prototype_item ITEM >
176 tree_item < ITEM > * tree < ITEM >::find(const ITEM * pitem, ::collection::index * piIndex)
177 {
178
179 ::collection::index iIndex;
180
181 if (pitem == nullptr)
182 {
183
184 return nullptr;
185
186 }
187
188 if (piIndex == nullptr)
189 {
190
191 iIndex = 0;
192
193 }
194 else
195 {
196
197 iIndex = *piIndex;
198
199 }
200
201 ::data::tree_item < ITEM > * ptreeitem = this;
202
203 for (; ptreeitem != nullptr; ptreeitem = ptreeitem->get_item(e_tree_navigation_expanded_forward))
204 {
205
206 if (ptreeitem->_item() == pitem)
207 {
208
209 iIndex--;
210
211 if (iIndex < 0)
212 {
213
214 return ptreeitem;
215
216 }
217
218 }
219
220 }
221
222 if (piIndex != nullptr)
223 {
224
225 *piIndex = iIndex;
226
227 }
228
229 return nullptr;
230
231 }
232
233
234 template < prototype_item ITEM >
235 bool tree < ITEM >::contains(const ITEM * pitem)
236 {
237
238 return find(pitem) != nullptr;
239
240 }
241
242
243 template < prototype_item ITEM >
244 bool tree < ITEM >::contains(const tree_item < ITEM > * ptreeitemParam)
245 {
246
247 return tree_item < ITEM >::contains(ptreeitemParam);
248
249 //if (pitemParam == this)
250 //{
251
252 // return true;
253
254 //}
255 //
256 //::data::tree_item < ITEM > * pitem = this;
257
258 //for(; pitem != nullptr; pitem = pitem->get_item(e_tree_navigation_expanded_forward))
259 //{
260
261 // if (pitem == pitemParam)
262 // {
263
264 // return true;
265
266 // }
267
268 //}
269
270 //return false;
271
272 }
273
274 template < prototype_item ITEM >
275 void tree < ITEM >::_001OnTreeDataChange()
276 {
277
278 update_levels();
279
280 }
281
282 template < prototype_item ITEM >
283 void tree < ITEM >::erase(ITEM * pitem, ::collection::index i)
284 {
285
286 tree_item < ITEM > * ptreeitem = find(pitem, &i);
287
288 if (ptreeitem == nullptr)
289 {
290
291 return;
292
293 }
294
295 return erase(ptreeitem);
296
297 }
298
299
300 template < prototype_item ITEM >
301 void tree < ITEM >::erase(tree_item_ptr_array< ITEM> & itemptra)
302 {
303
304 for (::i32 i = 0; i < itemptra.get_count(); i++)
305 {
306
307 erase(itemptra[i]);
308
309 }
310
311 }
312
313
314 template < prototype_item ITEM >
315 void tree < ITEM >::erase(tree_item < ITEM > * ptreeitem)
316 {
317
318 if (ptreeitem->m_ptree == this)
319 {
320
321 ptreeitem->erase_tree_item();
322
323 }
324
325 }
326
327
328 template < prototype_item ITEM >
329 void tree < ITEM >::sort_children(const ::function < bool(const ::data::tree_item < ITEM > * p1, const ::data::tree_item < ITEM > * p2) > & functionLess)
330 {
331
332 if (!this->m_ptreeitema2)
333 {
334
335return;
336
337 }
338
339 this->m_ptreeitema2->predicate_sort(functionLess);
340
341 this->m_ptreeitema2->predicate_each([](auto pitem) {pitem->clear_cache(); });
342
343 }
344
345
346 template < prototype_item ITEM >
347 ::data::tree_item < ITEM > * tree < ITEM >::_get_proper_item(::collection::index iIndex, ::collection::index * piLevel, ::collection::index * piCount)
348 {
349
350 ::collection::index iCount = 0;
351
352 if (piLevel)
353 {
354
355 *piLevel = 0;
356
357 }
358
359 ::pointer<::data::tree_item < ITEM >>pitem = this;
360
361 while (pitem && iIndex >= 0)
362 {
363
364 pitem = pitem->get_proper_next(piLevel);
365
366 iIndex--;
367
368 }
369
370 if (iIndex < 0 && pitem)
371 {
372
373 return pitem;
374
375 }
376
377 if (piCount != nullptr)
378 {
379
380 *piCount = iCount;
381
382 }
383
384 return nullptr;
385
386 }
387
388 template < prototype_item ITEM >
389 ::data::tree_item < ITEM > * tree < ITEM >::get_proper_item(::collection::index iIndex, ::collection::index * piLevel)
390 {
391
392 if (piLevel)
393 {
394
395 *piLevel = 0;
396
397 }
398
399 ::pointer<::data::tree_item < ITEM >>pitem = this;
400
401 while (pitem && iIndex >= 0)
402 {
403
404 pitem = pitem->get_proper_next(piLevel);
405
406 iIndex--;
407
408 }
409
410 if (iIndex < 0 && pitem)
411 {
412
413 return pitem;
414
415 }
416
417 return nullptr;
418
419 }
420
421 template < prototype_item ITEM >
422 ::collection::index tree < ITEM >::get_proper_item_index(::data::tree_item < ITEM > * pitemParam, ::collection::index * piLevel, ::collection::index * piCount)
423 {
424
425 ::i32 iIndex = 0;
426
427 ::collection::count iCount = 0;
428
429 if (piLevel != nullptr)
430 {
431
432 *piLevel = 0;
433
434 }
435
436 ::pointer<::data::tree_item < ITEM >>pitem = get_base_item();
437
438 while (pitem != nullptr)
439 {
440
441 pitem = pitem->get_proper_next(piLevel);
442
443 if (pitem == pitemParam)
444 {
445
446 if (piCount != nullptr)
447 {
448
449 *piCount += iCount;
450
451 }
452
453 return iIndex;
454
455 }
456
457 iIndex++;
458
459 iCount++;
460
461 }
462
463 if (piCount != nullptr)
464 {
465
466 *piCount += iCount;
467
468 }
469
470 return -1;
471
472 }
473
474
475 //::collection::count tree < ITEM >::get_proper_item_count()
476 //{
477
478 // _synchronous_lock synchronouslock(this->synchronization(), DEFAULT_SYNCHRONOUS_LOCK_SUFFIX);
479
480 // return get_base_item()->get_proper_item_count();
481
482 //}
483
484 template < prototype_item ITEM >
485 ::data::tree_item < ITEM > * tree < ITEM >::get_base_item()
486 {
487
488 return this;
489
490 }
491
492 template < prototype_item ITEM >
493 const ::data::tree_item < ITEM > * tree < ITEM >::get_base_item() const
494 {
495
496 return this;
497
498 }
499
500
501 template < prototype_item ITEM >
502 ::data::tree_item_base * tree < ITEM >::__previous()
503 {
504
505 return nullptr;
506
507 }
508
509
510 template < prototype_item ITEM >
511 ::data::tree_item_base * tree < ITEM >::__next()
512 {
513
514 return nullptr;
515
516 }
517
518
519 template < prototype_item ITEM >
520 ::data::tree_item < ITEM > * tree < ITEM >::insert_item(ITEM * pitem, enum_relative erelativeNewItem, ::data::tree_item < ITEM > * pitemRelative, bool bVoidTreeDataChangeEvent)
521 {
522
523 if (pitemRelative == nullptr)
524 {
525
526 pitemRelative = this;
527
528 }
529
530 if (erelativeNewItem == e_relative_replace)
531 {
532
533 if (!contains(pitemRelative))
534 {
535
536 return nullptr;
537
538 }
539
540 pitemRelative->m_pitem = pitem;
541
542 return pitemRelative;
543
544 }
545
546 auto ptreeitemNew = allocateø tree_item < ITEM >();
547
548 if (!ptreeitemNew)
549 {
550
551 return nullptr;
552
553 }
554
555 ptreeitemNew->m_pitem = pitem;
556
557 if (!insert_item(ptreeitemNew, erelativeNewItem, pitemRelative, bVoidTreeDataChangeEvent))
558 {
559
560 return nullptr;
561
562 }
563
564 return ptreeitemNew;
565
566 }
567
568
569 template < prototype_item ITEM >
570 ::pointer < ::data::tree_item < ITEM > > tree < ITEM >::create_tree_item()
571 {
572
573 return create_newø < ::data::tree_item < ITEM > >();
574
575 }
576
577
578 template < prototype_item ITEM >
579 ::pointer < ::data::tree_item_base > tree < ITEM >::_create_tree_item()
580 {
581
582 return this->create_tree_item();
583
584 }
585
586
587 template < prototype_item ITEM >
588 void tree < ITEM >::destroy()
589 {
590
591 ::data::data::destroy();
592 ::data::tree_item < ITEM >::destroy();
593
594 }
595
596
597 template < prototype_item ITEM >
598 void tree < ITEM >::on_insert_tree(tree * ptree)
599 {
600
601 m_treea.add(ptree);
602
603 }
604
605
606 template < prototype_item ITEM >
607 bool tree < ITEM >::insert_item(::data::tree_item < ITEM > * pitemNew, enum_relative erelativeNewItem, ::data::tree_item < ITEM > * pitemRelative, bool bVoidTreeDataChangeEvent)
608 {
609
610 ::pointer<tree>ptreeNew = pitemNew;
611
612 if (ptreeNew)
613 {
614
615 on_insert_tree(ptreeNew);
616
617 }
618
619 if (pitemRelative == nullptr)
620 {
621
622 pitemRelative = this;
623
624 }
625
626 _synchronous_lock synchronouslock(this->synchronization(), DEFAULT_SYNCHRONOUS_LOCK_SUFFIX);
627
628 if (pitemNew == nullptr)
629 {
630
631 return false;
632
633 }
634
635 if (!contains(pitemRelative))
636 {
637
638 return false;
639
640 }
641
642 if (erelativeNewItem == e_relative_parent)
643 {
644
645 return false;
646
647 }
648
649 if (erelativeNewItem == e_relative_last_sibling)
650 {
651
652 if (pitemRelative == this)
653 {
654
655 erelativeNewItem = e_relative_first_child;
656
657 }
658
659 }
660
661 bool bOk = false;
662
663 switch (erelativeNewItem)
664 {
665 case e_relative_first_child:
666 {
667
668 bOk = pitemRelative->insert(erelativeNewItem, pitemNew);
669
670 }
671 break;
672 case e_relative_last_child:
673 {
674
675 bOk = pitemRelative->insert(erelativeNewItem, pitemNew);
676
677 }
678 break;
679 case e_relative_previous_sibling:
680 {
681
682 bOk = pitemRelative->insert(erelativeNewItem, pitemNew);
683
684 }
685 break;
686 case e_relative_next_sibling:
687 {
688
689 bOk = pitemRelative->insert(erelativeNewItem, pitemNew);
690
691 }
692 break;
693 case e_relative_last_sibling:
694 {
695
696 bOk = pitemRelative->insert(erelativeNewItem, pitemNew);
697
698 }
699 break;
700 case e_relative_replace:
701 {
702
703 pitemNew->m_dwUser = pitemRelative->m_dwUser;
704 pitemNew->m_dwMetaData = pitemRelative->m_dwMetaData;
705 pitemNew->m_etreeitemstate = pitemRelative->m_etreeitemstate;
706 pitemNew->m_pitem = pitemRelative->m_pitem;
707
708 pitemNew->m_iLevel = pitemRelative->m_iLevel;
709
710 bOk = pitemRelative->insert(erelativeNewItem, pitemNew);
711
712 }
713 break;
714
715 case e_relative_macro_record:
716 {
717
718 if (pitemRelative->get_next() != nullptr)
719 {
720
721 bOk = insert_item(pitemNew, ::data::e_relative_first_child, pitemRelative);
722
723 }
724 else
725 {
726
727 bOk = insert_item(pitemNew, ::data::e_relative_last_sibling, pitemRelative);
728
729 }
730
731 }
732 break;
733 default:
734
735 throw ::exception(error_not_supported);
736
737 }
738
739 pitemNew->m_ptree = this;
740
741 if (!bVoidTreeDataChangeEvent)
742 {
743
744 _001OnTreeDataChange();
745
746 }
747
748 return bOk;
749
750 }
751
752 template < prototype_item ITEM >
753 void tree < ITEM >::erase_all()
754 {
755
756 this->erase_tree_item_descendants();
757
758 }
759
760
761 template < prototype_item ITEM >
762 ::collection::count tree < ITEM >::_tree_count()
763 {
764
765 return this->m_treea.size();
766
767 }
768
769
770 template < prototype_item ITEM >
771 tree_base * tree < ITEM >::_tree_at(::collection::index iIndex)
772 {
773
774 return this->m_treea[iIndex];
775
776 }
777
778
779 template < prototype_item ITEM >
780 void tree < ITEM >::update_tree()
781 {
782
783 _001OnTreeDataChange();
784
785 }
786
787
788 //void tree < ITEM >::sort(index ( * pfnCompare )(const ::pointer<tree_item < ITEM >>&, const ::pointer<tree_item < ITEM >>))
789
790 //{
791
792 // ::pointer<tree_item < ITEM >>pitem = get_base_item();
793
794 // while(pitem != nullptr)
795 // {
796
797 // pitem->sort_children(pfnCompare);
798
799
800 // pitem = pitem->get_child_next_or_parent();
801
802 // }
803
804 //}
805 template < prototype_item ITEM >
806 void tree < ITEM >::update_levels()
807 {
808
809 ::collection::index iLevel = -1;
810
811 ::pointer<tree_item < ITEM >>pitem = get_base_item();
812
813 while (pitem != nullptr)
814 {
815
816 pitem->m_iLevel = iLevel;
817
818 pitem = pitem->get_child_next_or_parent(&iLevel);
819
820 }
821
822 }
823
824 template < prototype_item ITEM >
825 void tree < ITEM >::_001ExpandItem(::data::tree_item < ITEM > * pitem, const ::action_context & context, bool bExpand, bool bRedraw, bool bLayout)
826 {
827
828
829 }
830 template < prototype_item ITEM >
831 void tree < ITEM >::_001EnsureVisible(::data::tree_item < ITEM > * pitem)
832 {
833
834
835 }
836
837 template < prototype_item ITEM >
838 void tree < ITEM >::_001SelectItem(::data::tree_item < ITEM > * pitem)
839 {
840
841
842 }
843 template < prototype_item ITEM >
844 void tree < ITEM >::get_selection(::data::tree_item_ptr_array< ITEM> & itemptraSelected) const
845 {
846
847
848 }
849 template < prototype_item ITEM >
850
851 bool tree < ITEM >::is_selected(const ::data::tree_item < ITEM > * pitem) const
852 {
853
854
855 return false;
856
857 }
858
859 template < prototype_item ITEM >
860 bool tree < ITEM >::is_selected(const ITEM * pitem) const
861 {
862
863
864 return false;
865
866 }
867
868 template < prototype_item ITEM >
869 void tree < ITEM >::_001OnItemExpand(::data::tree_item_base * ptreeitembase, const ::action_context & context)
870 {
871
872 if (ptreeitembase->is_expanded())
873 return;
874
875 ptreeitembase->on_fill_children();
876
877 if (ptreeitembase->get_children_count() > 0)
878 {
879 ptreeitembase->m_etreeitemstate |= ::data::e_tree_item_state_expanded;
880 ptreeitembase->m_etreeitemstate |= ::data::e_tree_item_state_expandable;
881 }
882
883 /* for (::collection::index i = 0; i < m_treeptra.get_count(); i++)
884 {
885
886 m_treeptra[i]._001OnItemExpand(pitem, context);
887
888 }*/
889
890
891
892
893 }
894
895 template < prototype_item ITEM >
896 void tree < ITEM >::_001OnItemCollapse(::data::tree_item_base * ptreeitembase, const ::action_context & context)
897 {
898
899 if (!ptreeitembase->is_expanded())
900 return;
901 if (ptreeitembase->get_children_count() > 0)
902 {
903 ptreeitembase->m_etreeitemstate |= ::data::e_tree_item_state_expandable;
904 }
905 ptreeitembase->m_etreeitemstate -= ::data::e_tree_item_state_expanded;
906 /*for (::collection::index i = 0; i < m_treeptra.get_count(); i++)
907 {
908
909 m_treeptra[i]._001OnItemCollapse(pitem);
910
911 }*/
912
913 }
914
915 template < prototype_item ITEM >
916 void tree < ITEM >::_001OnOpenItem(::data::tree_item_base * ptreeitembase, const ::action_context & context)
917 {
918
919
920 }
921
922
923 // template < prototype_item ITEM >
924 // void tree < ITEM >::_001OnOpenItem(::data::tree_item_base * ptreeitembase, const ::action_context & context)
925 // {
926 //
927 // ::cast < ::data::tree_item < ITEM > > ptreeitem = pitem;
928 //
929 // _001OnOpenItem(ptreeitem, context);
930 //
931 // }
932
933
934 template < prototype_item ITEM >
935 void tree < ITEM >::_001OnItemContextMenu(::data::tree_item_base * ptreeitembase, const ::action_context & context, ::user::element * ptree, const ::i32_point & point)
936 {
937
938
939 }
940
941 template < prototype_item ITEM >
942 ::collection::count tree < ITEM >::selection_set(::data::tree_item_ptr_array< ITEM> & itemptra)
943 {
944
945 return 0;
946
947 }
948
949 template < prototype_item ITEM >
950 bool tree < ITEM >::selection_set(::data::tree_item < ITEM > * pitem, bool bIfNotInSelection, bool bIfParentInSelection)
951 {
952
953 return false;
954
955 }
956
957 template < prototype_item ITEM >
958 bool tree < ITEM >::selection_set( ITEM * pitem, bool bIfNotInSelection, bool bIfParentInSelection)
959 {
960
961 return false;
962
963 }
964
965 template < prototype_item ITEM >
966 bool tree < ITEM >::selection_set(::collection::index iIndex, ITEM * pitem, bool bIfNotInSelection, bool bIfParentInSelection)
967 {
968
969 return false;
970
971 }
972
973
974 template < prototype_item ITEM >
975 ::image::image_list * tree < ITEM >::get_tree_image_list()
976 {
977
978 return nullptr;
979
980 }
981
982
983 //void tree < ITEM >::signal(::signal * psignal)
984 //{
985
986 //}
987
988 template < prototype_item ITEM >
989 void tree < ITEM >::handle(::topic * ptopic, ::handler_context * phandlercontext)
990 {
991
992 for (auto & ptree : m_treea)
993 {
994
995 ptree->handle(ptopic, phandlercontext);
996
997 }
998
999 }
1000
1001
1002
1003 //void tree < ITEM >::handle(::topic * ptopic, ::handler_context * phandlercontext)
1004 //{
1005
1006 //}
1007
1008
1009 template < prototype_item ITEM >
1010 void tree < ITEM >::on_fill_children()
1011 {
1012
1013 }
1014
1015
1016 //void tree < ITEM >::start_fill_children()
1017 //{
1018
1019 // _synchronous_lock synchronouslock(this->synchronization(), DEFAULT_SYNCHRONOUS_LOCK_SUFFIX);
1020
1021 // m_bFill = true;
1022
1023 // fork([this]()
1024 // {
1025
1026 // fill_children();
1027
1028 // });
1029
1030 //}
1031
1032 template < prototype_item ITEM >
1033 void tree < ITEM >::on_tree_layout()
1034 {
1035
1036 }
1037
1038 template < prototype_item ITEM >
1039 void tree < ITEM >::fill_children()
1040 {
1041
1042 try
1043 {
1044
1045 on_fill_children();
1046
1047 }
1048 catch (...)
1049 {
1050
1051 }
1052
1053
1054 try
1055 {
1056
1057 //auto pgraphics = ::draw2d::create_memory_graphics();
1058
1059 //tree_layout(pgraphics);
1060
1061 on_tree_layout();
1062
1063 }
1064 catch (...)
1065 {
1066
1067 }
1068
1069 m_bFill = false;
1070
1071 }
1072
1073
1074 //void tree < ITEM >::tree_layout(::draw2d::graphics_pointer & pgraphics)
1075 //{
1076
1077 //}
1078
1079 template < prototype_item ITEM >
1080 tree_base * tree_item < ITEM >::_get_tree() const
1081 {
1082
1083 return m_ptree;
1084
1085 }
1086
1087 template < prototype_item ITEM >
1088 void tree_item < ITEM >::_set_tree(tree_base * ptreebase)
1089 {
1090
1091 m_ptree = dynamic_cast <::data::tree < ITEM > *>(ptreebase);
1092
1093 }
1094
1095
1096
1097} // namespace data
1098
1099//
1100//
1101//inline stream & operator <<(stream & s, const ::data::tree & tree);
1102//
1103//inline stream & operator >>(stream & s, ::data::tree & tree);
1104//
1105//
1106
action_context
Definition action_context.h:9
ITEM
data::tree_base
Definition tree_base.h:20
data::tree_item_base
Definition tree_item_base.h:18
data::tree_item_ptr_array
Definition tree_item.h:1680
data::tree_item
Definition tree_item.h:34
data::tree
Definition tree.h:17
handler_context
Definition handler_context.h:9
object::destroy
virtual void destroy() override
Definition bbb_context_object.cpp:242
topic
Definition topic.h:17