@itwin/tree-widget-react 4.0.0-alpha.7 → 4.0.0-alpha.8

package/lib/esm/tree-widget-react/components/trees/categories-tree/internal/CategoriesTreeVisibilityHandler.js

@@ -8,8 +8,8 @@ import { PerModelCategoryVisibility } from "@itwin/core-frontend";
 import { HierarchyNode, HierarchyNodeKey } from "@itwin/presentation-hierarchies";
 import { AlwaysAndNeverDrawnElementInfo } from "../../common/internal/AlwaysAndNeverDrawnElementInfo.js";
 import { toVoidPromise } from "../../common/internal/Rxjs.js";
-import { createVisibilityStatus, getTooltipOptions } from "../../common/internal/Tooltip.js";
-import { getClassesByView, getDistinctMapValues, releaseMainThreadOnItemsCount, setDifference, setIntersection } from "../../common/internal/Utils.js";
+import { createVisibilityStatus } from "../../common/internal/Tooltip.js";
+import { getClassesByView, releaseMainThreadOnItemsCount, setDifference, setIntersection } from "../../common/internal/Utils.js";
 import { createVisibilityChangeEventListener } from "../../common/internal/VisibilityChangeEventListener.js";
 import { changeElementStateNoChildrenOperator, enableCategoryDisplay, enableSubCategoryDisplay, filterSubModeledElementIds, getElementOverriddenVisibility, getElementVisibility, getSubModeledElementsVisibilityStatus, getVisibilityFromAlwaysAndNeverDrawnElementsImpl, mergeVisibilityStatuses, } from "../../common/internal/VisibilityUtils.js";
 import { createVisibilityHandlerResult } from "../../common/UseHierarchyVisibility.js";
@@ -31,7 +31,7 @@ class CategoriesTreeVisibilityHandlerImpl {
         this._eventListener = createVisibilityChangeEventListener({
             viewport: _props.viewport,
             listeners: {
-                models: _props.hierarchyConfig.showElements,
+                models: true,
                 categories: true,
                 elements: _props.hierarchyConfig.showElements,
                 displayStyle: true,
@@ -142,7 +142,7 @@ class CategoriesTreeVisibilityHandlerImpl {
         return from(this.getVisibilityChangeTargets(props)).pipe(mergeMap(({ definitionContainerIds: definitionContainers, subCategories, modelIds: models, categories, elements }) => {
             const observables = new Array();
             if (definitionContainers?.size) {
-                observables.push(from(definitionContainers).pipe(mergeMap((definitionContainerId) => this.getDefinitionContainerDisplayStatus({ definitionContainerIds: [definitionContainerId], ignoreTooltip: true }))));
+                observables.push(from(definitionContainers).pipe(mergeMap((definitionContainerId) => this.getDefinitionContainerDisplayStatus({ definitionContainerIds: [definitionContainerId] }))));
             }
             if (models?.size) {
                 observables.push(from(models).pipe(mergeMap((modelId) => this.getModelVisibilityStatus({ modelId }))));
@@ -150,110 +150,109 @@ class CategoriesTreeVisibilityHandlerImpl {
             if (categories?.size) {
                 observables.push(from(categories).pipe(mergeMap((key) => {
                     const { modelId, categoryId } = parseCategoryKey(key);
-                    return this.getCategoryDisplayStatus({ ignoreTooltip: true, ignoreSubCategories: !!modelId, modelId, categoryIds: [categoryId] });
+                    return this.getCategoryDisplayStatus({ ignoreSubCategories: !!modelId, modelId, categoryIds: [categoryId] });
                 })));
             }
             if (subCategories?.size) {
                 observables.push(from(subCategories).pipe(mergeMap((key) => {
                     const { subCategoryId, categoryId } = parseSubCategoryKey(key);
-                    return this.getSubCategoryDisplayStatus({ subCategoryIds: [subCategoryId], categoryId, ignoreTooltip: true });
+                    return this.getSubCategoryDisplayStatus({ subCategoryIds: [subCategoryId], categoryId });
                 })));
             }
             if (elements?.size) {
                 observables.push(from(elements).pipe(releaseMainThreadOnItemsCount(50), mergeMap(([categoryKey, elementIds]) => {
                     const { modelId, categoryId } = parseCategoryKey(categoryKey);
                     assert(modelId !== undefined);
-                    return from(elementIds).pipe(releaseMainThreadOnItemsCount(1000), mergeMap((elementId) => this.getElementDisplayStatus({ modelId, categoryId, elementId, ignoreTooltip: true })));
+                    return from(elementIds).pipe(releaseMainThreadOnItemsCount(1000), mergeMap((elementId) => this.getElementDisplayStatus({ modelId, categoryId, elementId })));
                 })));
             }
             return merge(...observables);
-        }), mergeVisibilityStatuses({ visible: undefined, hidden: undefined, partial: undefined }));
+        }), mergeVisibilityStatuses);
     }
     getModelVisibilityStatus({ modelId }) {
         const result = defer(() => {
             const viewport = this._props.viewport;
             if (!viewport.view.viewsModel(modelId)) {
                 return from(this._idsCache.getModelCategoryIds(modelId)).pipe(mergeMap((categoryIds) => from(this._idsCache.getCategoriesModeledElements(modelId, categoryIds))), getSubModeledElementsVisibilityStatus({
-                    ignoreTooltips: true,
-                    tooltips: { visible: undefined, hidden: undefined, partial: undefined },
                     parentNodeVisibilityStatus: createVisibilityStatus("hidden"),
                     getModelVisibilityStatus: (modelProps) => this.getModelVisibilityStatus(modelProps),
                 }));
             }
-            return from(this._idsCache.getModelCategoryIds(modelId)).pipe(mergeAll(), mergeMap((categoryId) => this.getCategoryDisplayStatus({ modelId, categoryIds: [categoryId], ignoreSubCategories: true, ignoreTooltip: true })), mergeVisibilityStatuses({
-                visible: undefined,
-                hidden: undefined,
-                partial: undefined,
-            }, true));
+            return from(this._idsCache.getModelCategoryIds(modelId)).pipe(mergeAll(), mergeMap((categoryId) => this.getCategoryDisplayStatus({ modelId, categoryIds: [categoryId], ignoreSubCategories: true })), mergeVisibilityStatuses);
         });
         return createVisibilityHandlerResult(this, { id: modelId }, result, undefined);
     }
     getDefinitionContainerDisplayStatus(props) {
         const result = defer(() => {
-            return from(this._idsCache.getAllContainedCategories(props.definitionContainerIds)).pipe(mergeAll(), mergeMap((categoryId) => {
-                return this.getCategoryDisplayStatus({ categoryIds: [categoryId], ignoreTooltip: true });
-            }), mergeVisibilityStatuses({
-                visible: "categoriesTree.definitionContainer.visibleThroughCategories",
-                hidden: "categoriesTree.definitionContainer.hiddenThroughCategories",
-                partial: "categoriesTree.definitionContainer.partialThroughCategories",
-            }));
+            return from(this._idsCache.getAllContainedCategories(props.definitionContainerIds)).pipe(mergeAll(), mergeMap((categoryId) => this.getCategoryDisplayStatus({ categoryIds: [categoryId] })), mergeVisibilityStatuses);
         });
         return createVisibilityHandlerResult(this, props, result, undefined);
     }
     getSubCategoryDisplayStatus(props) {
-        const result = defer(() => {
-            const { categoryId, subCategoryIds, ignoreTooltip } = props;
-            const categoryOverrideResult = this.getCategoryVisibilityFromOverrides([categoryId], ignoreTooltip);
-            if (categoryOverrideResult !== "none" && (categoryOverrideResult.state === "hidden" || categoryOverrideResult.state === "visible")) {
-                return of(createVisibilityStatus(categoryOverrideResult.state, getTooltipOptions(`categoriesTree.subCategory.${categoryOverrideResult.state}ThroughCategoryOverride`)));
+        const result = defer(async () => {
+            const { categoryId, subCategoryIds } = props;
+            let visibility = "unknown";
+            const categoryModels = [...(await this._idsCache.getCategoriesElementModels([categoryId], true)).values()].flat();
+            let nonDefaultModelDisplayStatesCount = 0;
+            for (const modelId of categoryModels) {
+                if (!this._props.viewport.view.viewsModel(modelId)) {
+                    if (visibility === "visible") {
+                        return createVisibilityStatus("partial");
+                    }
+                    visibility = "hidden";
+                    ++nonDefaultModelDisplayStatesCount;
+                    continue;
+                }
+                const override = this._props.viewport.perModelCategoryVisibility.getOverride(modelId, categoryId);
+                if (override === PerModelCategoryVisibility.Override.Show) {
+                    if (visibility === "hidden") {
+                        return createVisibilityStatus("partial");
+                    }
+                    visibility = "visible";
+                    ++nonDefaultModelDisplayStatesCount;
+                    continue;
+                }
+                if (override === PerModelCategoryVisibility.Override.Hide) {
+                    if (visibility === "visible") {
+                        return createVisibilityStatus("partial");
+                    }
+                    visibility = "hidden";
+                    ++nonDefaultModelDisplayStatesCount;
+                    continue;
+                }
+            }
+            if (categoryModels.length > 0 && nonDefaultModelDisplayStatesCount === categoryModels.length) {
+                assert(visibility === "visible" || visibility === "hidden");
+                return createVisibilityStatus(visibility);
             }
             if (!this._props.viewport.view.viewsCategory(categoryId)) {
-                return of(createVisibilityStatus("hidden", getTooltipOptions("categoriesTree.subCategory.hiddenThroughCategory", ignoreTooltip)));
+                return createVisibilityStatus(visibility === "visible" ? "partial" : "hidden");
             }
-            let visibleCount = 0;
-            let hiddenCount = 0;
-            for (const subCategoryId of subCategoryIds) {
-                const isVisible = this._props.viewport.isSubCategoryVisible(subCategoryId);
-                if (isVisible) {
-                    ++visibleCount;
+            if (subCategoryIds.length === 0) {
+                if (visibility === "hidden") {
+                    return createVisibilityStatus("partial");
                 }
-                else {
-                    ++hiddenCount;
+                return createVisibilityStatus("visible");
+            }
+            for (const subCategoryId of subCategoryIds) {
+                const isSubCategoryVisible = this._props.viewport.isSubCategoryVisible(subCategoryId);
+                if (isSubCategoryVisible && visibility === "hidden") {
+                    return createVisibilityStatus("partial");
                 }
-                if (visibleCount > 0 && hiddenCount > 0) {
-                    return of(createVisibilityStatus("partial", getTooltipOptions("categoriesTree.subCategory.partialThroughSubCategory", ignoreTooltip)));
+                if (!isSubCategoryVisible && visibility === "visible") {
+                    return createVisibilityStatus("partial");
                 }
+                visibility = isSubCategoryVisible ? "visible" : "hidden";
             }
-            return of(visibleCount > 0 ? createVisibilityStatus("visible") : createVisibilityStatus("hidden"));
+            assert(visibility === "visible" || visibility === "hidden");
+            return createVisibilityStatus(visibility);
         });
         return createVisibilityHandlerResult(this, props, result, undefined);
     }
-    getCategoryVisibilityFromOverrides(categoryIds, ignoreTooltip) {
-        let showOverrides = 0;
-        let hideOverrides = 0;
-        for (const currentOverride of this._props.viewport.perModelCategoryVisibility) {
-            if (categoryIds.includes(currentOverride.categoryId)) {
-                if (currentOverride.visible) {
-                    ++showOverrides;
-                }
-                else {
-                    ++hideOverrides;
-                }
-                if (showOverrides > 0 && hideOverrides > 0) {
-                    return createVisibilityStatus("partial", getTooltipOptions("categoriesTree.category.partialThroughOverrides", ignoreTooltip));
-                }
-            }
-        }
-        if (showOverrides === 0 && hideOverrides === 0) {
-            return "none";
-        }
-        const visibility = showOverrides > 0 ? "visible" : "hidden";
-        return createVisibilityStatus(visibility, getTooltipOptions(`categoriesTree.category.${visibility}ThroughOverrides`, ignoreTooltip));
-    }
-    getDefaultModelsCategoryVisibilityStatus({ modelId, categoryIds, ignoreTooltip, }) {
+    getDefaultModelsCategoryVisibilityStatus({ modelId, categoryIds }) {
         const viewport = this._props.viewport;
         if (!viewport.view.viewsModel(modelId)) {
-            return createVisibilityStatus("hidden", getTooltipOptions("categoriesTree.category.hiddenThroughModel", ignoreTooltip));
+            return createVisibilityStatus("hidden");
         }
         let visibleCount = 0;
         let hiddenCount = 0;
@@ -272,55 +271,26 @@ class CategoriesTreeVisibilityHandlerImpl {
                 continue;
             }
             if (visibleCount > 0 && hiddenCount > 0) {
-                return createVisibilityStatus("partial", getTooltipOptions("categoriesTree.category.partialThroughOverrides", ignoreTooltip));
+                return createVisibilityStatus("partial");
             }
         }
         if (hiddenCount + visibleCount > 0) {
-            const overridenVisibility = hiddenCount > 0 ? "hidden" : "visible";
-            return createVisibilityStatus(overridenVisibility, getTooltipOptions(`categoriesTree.category.${overridenVisibility}ThroughOverrides`, ignoreTooltip));
+            return createVisibilityStatus(hiddenCount > 0 ? "hidden" : "visible");
         }
-        const visbility = visibleThroughCategorySelectorCount > 0 ? "visible" : "hidden";
-        return createVisibilityStatus(visbility, getTooltipOptions(`categoriesTree.category.${visbility}ThroughCategorySelector`, ignoreTooltip));
+        return createVisibilityStatus(visibleThroughCategorySelectorCount > 0 ? "visible" : "hidden");
     }
-    async getDefaultCategoryVisibilityStatus({ categoryIds, ignoreTooltip, ignoreSubCategories, }) {
-        const overrideResult = this.getCategoryVisibilityFromOverrides(categoryIds);
-        if (overrideResult !== "none") {
-            return overrideResult;
-        }
-        let hiddenCount = 0;
-        for (const categoryId of categoryIds) {
-            const isVisible = this._props.viewport.view.viewsCategory(categoryId);
-            if (!isVisible) {
-                ++hiddenCount;
-            }
-        }
-        if (hiddenCount > 0 || this._props.hierarchyConfig.hideSubCategories || ignoreSubCategories) {
-            const visibility = hiddenCount > 0 ? "hidden" : "visible";
-            return createVisibilityStatus(visibility, getTooltipOptions(`categoriesTree.category.${visibility}ThroughCategorySelector`, ignoreTooltip));
-        }
-        const subCategories = getDistinctMapValues(await this._idsCache.getSubCategories(categoryIds));
-        let visibleSubCategoryCount = 0;
-        let hiddenSubCategoryCount = 0;
-        for (const subCategory of subCategories) {
-            const isVisible = this._props.viewport.isSubCategoryVisible(subCategory);
-            if (isVisible) {
-                ++visibleSubCategoryCount;
-            }
-            else {
-                ++hiddenSubCategoryCount;
-            }
-            if (hiddenSubCategoryCount > 0 && visibleSubCategoryCount > 0) {
-                return createVisibilityStatus("partial", getTooltipOptions("categoriesTree.category.partialThroughSubCategories", ignoreTooltip));
-            }
-        }
-        const subCategoryVisiblity = hiddenSubCategoryCount > 0 ? "hidden" : "visible";
-        const reason = subCategories.size > 0 ? "ThroughSubCategories" : "ThroughCategorySelector";
-        return createVisibilityStatus(subCategoryVisiblity, getTooltipOptions(`categoriesTree.category.${subCategoryVisiblity}${reason}`, ignoreTooltip));
+    getDefaultCategoryVisibilityStatus({ categoryIds }) {
+        return from(this._idsCache.getSubCategories(categoryIds)).pipe(mergeMap((categoriesSubCategoriesMap) => {
+            return from(categoryIds).pipe(mergeMap((categoryId) => {
+                const subCategoryIds = categoriesSubCategoriesMap.get(categoryId);
+                return this.getSubCategoryDisplayStatus({ subCategoryIds: subCategoryIds ?? [], categoryId });
+            }), mergeVisibilityStatuses);
+        }));
     }
-    getCategoryDisplayStatus({ ignoreTooltip, ...props }) {
+    getCategoryDisplayStatus(props) {
         const result = defer(() => {
             if (!this._props.hierarchyConfig.showElements) {
-                return from(this.getDefaultCategoryVisibilityStatus({ categoryIds: props.categoryIds, ignoreTooltip }));
+                return from(this.getDefaultCategoryVisibilityStatus({ categoryIds: props.categoryIds }));
             }
             const modelsObservable = props.modelId
                 ? of(new Map(props.categoryIds.map((id) => [id, [props.modelId]])))
@@ -331,57 +301,34 @@ class CategoriesTreeVisibilityHandlerImpl {
                 ? modelsObservable.pipe(mergeMap((categoryModelsMap) => {
                     if (categoryModelsMap.size === 0) {
                         return props.modelId
-                            ? of(this.getDefaultModelsCategoryVisibilityStatus({ modelId: props.modelId, categoryIds: props.categoryIds, ignoreTooltip }))
-                            : from(this.getDefaultCategoryVisibilityStatus({ categoryIds: props.categoryIds, ignoreTooltip }));
+                            ? of(this.getDefaultModelsCategoryVisibilityStatus({ modelId: props.modelId, categoryIds: props.categoryIds }))
+                            : from(this.getDefaultCategoryVisibilityStatus({ categoryIds: props.categoryIds }));
                     }
                     return from(categoryModelsMap).pipe(mergeMap(([category, models]) => from(models).pipe(mergeMap((model) => {
                         if (this._props.viewport.view.viewsModel(model)) {
                             return this.getVisibilityFromAlwaysAndNeverDrawnElements({
                                 queryProps: props,
-                                tooltips: {
-                                    allElementsInAlwaysDrawnList: "categoriesTree.category.allElementsVisible",
-                                    allElementsInNeverDrawnList: "categoriesTree.category.allElementsHidden",
-                                    elementsInBothAlwaysAndNeverDrawn: "categoriesTree.category.someElementsAreHidden",
-                                    noElementsInExclusiveAlwaysDrawnList: "categoriesTree.category.allElementsHidden",
-                                },
-                                defaultStatus: () => this.getDefaultModelsCategoryVisibilityStatus({ modelId: model, categoryIds: [category], ignoreTooltip }),
-                                ignoreTooltip: true,
+                                defaultStatus: () => this.getDefaultModelsCategoryVisibilityStatus({ modelId: model, categoryIds: [category] }),
                             }).pipe(mergeMap((visibilityStatusAlwaysAndNeverDraw) => {
                                 return from(this._idsCache.getCategoriesModeledElements(model, [category])).pipe(getSubModeledElementsVisibilityStatus({
-                                    tooltips: {
-                                        visible: undefined,
-                                        hidden: undefined,
-                                        partial: undefined,
-                                    },
                                     parentNodeVisibilityStatus: visibilityStatusAlwaysAndNeverDraw,
-                                    ignoreTooltips: true,
                                     getModelVisibilityStatus: (modelProps) => this.getModelVisibilityStatus(modelProps),
                                 }));
                             }));
                         }
                         return from(this._idsCache.getCategoriesModeledElements(model, [category])).pipe(getSubModeledElementsVisibilityStatus({
-                            tooltips: {
-                                visible: undefined,
-                                hidden: undefined,
-                                partial: undefined,
-                            },
                             parentNodeVisibilityStatus: createVisibilityStatus("hidden"),
-                            ignoreTooltips: true,
                             getModelVisibilityStatus: (modelProps) => this.getModelVisibilityStatus(modelProps),
                         }));
-                    }), mergeVisibilityStatuses({ visible: undefined, hidden: undefined, partial: undefined }))), mergeVisibilityStatuses({
-                        visible: "categoriesTree.category.allElementsVisible",
-                        hidden: "categoriesTree.category.allElementsHidden",
-                        partial: "categoriesTree.category.someElementsHidden",
-                    }, ignoreTooltip));
+                    }), mergeVisibilityStatuses)), mergeVisibilityStatuses);
                 }), map((visibilityStatus) => {
                     return { visibilityStatus, type: 0 };
                 }))
                 : EMPTY, 
             // get category status
             (props.modelId
-                ? of(this.getDefaultModelsCategoryVisibilityStatus({ modelId: props.modelId, categoryIds: props.categoryIds, ignoreTooltip }))
-                : from(this.getDefaultCategoryVisibilityStatus({ categoryIds: props.categoryIds, ignoreTooltip }))).pipe(map((visibilityStatus) => {
+                ? of(this.getDefaultModelsCategoryVisibilityStatus({ modelId: props.modelId, categoryIds: props.categoryIds }))
+                : from(this.getDefaultCategoryVisibilityStatus({ categoryIds: props.categoryIds }))).pipe(map((visibilityStatus) => {
                 return { visibilityStatus, type: 1 };
             }))).pipe(toArray(), mergeMap(async (visibilityStatusesInfo) => {
                 let defaultStatus;
@@ -409,28 +356,18 @@ class CategoriesTreeVisibilityHandlerImpl {
                 }
                 // In cases where
                 // a) SubCategories are hidden
-                // b) Category needs to ignore subCategories
-                // c) Category has model (it means that category is under hidden subModel)
+                // b) Category has model (it means that category is under hidden subModel)
                 // We dont need to look at default category status, it is already accounted for in always/never drawn visibility
-                if (this._props.hierarchyConfig.hideSubCategories || props.ignoreSubCategories || props.modelId) {
+                if (this._props.hierarchyConfig.hideSubCategories || props.modelId) {
                     return alwaysNeverDrawStatus;
                 }
                 if ((await this._idsCache.getSubCategories(props.categoryIds)).size === 0) {
                     return alwaysNeverDrawStatus;
                 }
-                if (alwaysNeverDrawStatus.state === "partial") {
-                    return createVisibilityStatus("partial", getTooltipOptions("categoriesTree.category.someChildrenVisible", ignoreTooltip));
+                if (alwaysNeverDrawStatus.state === "partial" || alwaysNeverDrawStatus.state !== defaultStatus.state) {
+                    return createVisibilityStatus("partial");
                 }
-                if (alwaysNeverDrawStatus.state === "hidden") {
-                    if (defaultStatus.state === "hidden") {
-                        return createVisibilityStatus("hidden", getTooltipOptions("categoriesTree.category.allChildrenHidden", ignoreTooltip));
-                    }
-                    return createVisibilityStatus("partial", getTooltipOptions("categoriesTree.category.partialThroughSubCategories", ignoreTooltip));
-                }
-                if (defaultStatus.state === "hidden") {
-                    return createVisibilityStatus("partial", getTooltipOptions("categoriesTree.category.someChildrenVisible", ignoreTooltip));
-                }
-                return createVisibilityStatus("visible", getTooltipOptions("categoriesTree.category.allChildrenVisible", ignoreTooltip));
+                return alwaysNeverDrawStatus;
             }));
         });
         return createVisibilityHandlerResult(this, props, result, undefined);
@@ -442,62 +379,33 @@ class CategoriesTreeVisibilityHandlerImpl {
             return from(modelElementsMap).pipe(mergeMap(([modelId, elementIds]) => {
                 if (!this._props.viewport.view.viewsModel(modelId)) {
                     return of([...elementIds]).pipe(filterSubModeledElementIds({ doesSubModelExist: async (id) => this._idsCache.hasSubModel(id) }), getSubModeledElementsVisibilityStatus({
-                        tooltips: {
-                            visible: undefined,
-                            hidden: undefined,
-                            partial: undefined,
-                        },
                         parentNodeVisibilityStatus: createVisibilityStatus("hidden"),
                         getModelVisibilityStatus: (modelProps) => this.getModelVisibilityStatus(modelProps),
                     }));
                 }
                 return this.getVisibilityFromAlwaysAndNeverDrawnElements({
                     elements: elementIds,
-                    defaultStatus: () => {
-                        const status = this.getDefaultModelsCategoryVisibilityStatus({ categoryIds: [categoryId], modelId, ignoreTooltip: true });
-                        return createVisibilityStatus(status.state, getTooltipOptions(`categoriesTree.groupingNode.${status.state}ThroughCategory`));
-                    },
-                    tooltips: {
-                        allElementsInAlwaysDrawnList: "categoriesTree.groupingNode.allElementsVisible",
-                        allElementsInNeverDrawnList: "categoriesTree.groupingNode.allElementsHidden",
-                        elementsInBothAlwaysAndNeverDrawn: "categoriesTree.groupingNode.someElementsAreHidden",
-                        noElementsInExclusiveAlwaysDrawnList: "categoriesTree.groupingNode.allElementsHidden",
-                    },
+                    defaultStatus: () => this.getDefaultModelsCategoryVisibilityStatus({ categoryIds: [categoryId], modelId }),
                 }).pipe(mergeMap((visibilityStatusAlwaysAndNeverDraw) => {
                     return of([...elementIds]).pipe(filterSubModeledElementIds({ doesSubModelExist: async (id) => this._idsCache.hasSubModel(id) }), getSubModeledElementsVisibilityStatus({
-                        tooltips: {
-                            visible: undefined,
-                            hidden: undefined,
-                            partial: undefined,
-                        },
                         parentNodeVisibilityStatus: visibilityStatusAlwaysAndNeverDraw,
                         getModelVisibilityStatus: (modelProps) => this.getModelVisibilityStatus(modelProps),
                     }));
                 }));
-            }), mergeVisibilityStatuses({
-                visible: undefined,
-                hidden: undefined,
-                partial: undefined,
-            }, true));
+            }), mergeVisibilityStatuses);
         });
         return createVisibilityHandlerResult(this, { node }, result, undefined);
     }
-    getElementDisplayStatus({ ignoreTooltip, ...props }) {
+    getElementDisplayStatus(props) {
         const result = defer(() => {
             const viewport = this._props.viewport;
             const { elementId, modelId, categoryId } = props;
             const viewsModel = viewport.view.viewsModel(modelId);
             const elementStatus = getElementOverriddenVisibility({
                 elementId,
-                ignoreTooltip,
                 viewport,
-                tooltips: {
-                    visibileThorughAlwaysDrawn: "categoriesTree.element.displayedThroughAlwaysDrawnList",
-                    hiddenThroughAlwaysDrawnExclusive: "categoriesTree.element.hiddenDueToOtherElementsExclusivelyAlwaysDrawn",
-                    hiddenThroughNeverDrawn: "categoriesTree.element.hiddenThroughNeverDrawnList",
-                },
             });
-            return from(this._idsCache.hasSubModel(elementId)).pipe(mergeMap((hasSubModel) => (hasSubModel ? this.getModelVisibilityStatus({ modelId: elementId }) : of(undefined))), map((subModelVisibilityStatus) => getElementVisibility(ignoreTooltip, viewsModel, elementStatus, this.getDefaultModelsCategoryVisibilityStatus({ categoryIds: [categoryId], modelId, ignoreTooltip: true }), "categoriesTree", subModelVisibilityStatus)));
+            return from(this._idsCache.hasSubModel(elementId)).pipe(mergeMap((hasSubModel) => (hasSubModel ? this.getModelVisibilityStatus({ modelId: elementId }) : of(undefined))), map((subModelVisibilityStatus) => getElementVisibility(viewsModel, elementStatus, this.getDefaultModelsCategoryVisibilityStatus({ categoryIds: [categoryId], modelId }), subModelVisibilityStatus)));
         });
         return createVisibilityHandlerResult(this, props, result, undefined);
     }
@@ -648,15 +556,25 @@ class CategoriesTreeVisibilityHandlerImpl {
     changeSubCategoryState(props) {
         const result = defer(() => {
             return concat(
-            // make sure parent category is enabled
-            props.on ? from(enableCategoryDisplay(this._props.viewport, [props.categoryId], props.on, false)) : EMPTY, from(props.subCategoryIds).pipe(map((subCategoryId) => enableSubCategoryDisplay(this._props.viewport, subCategoryId, props.on))));
+            // make sure parent category and models are enabled
+            props.on
+                ? concat(from(enableCategoryDisplay(this._props.viewport, [props.categoryId], props.on, false)), from(this.enableCategoriesElementModelsVisibility([props.categoryId])))
+                : EMPTY, from(props.subCategoryIds).pipe(map((subCategoryId) => enableSubCategoryDisplay(this._props.viewport, subCategoryId, props.on))));
         });
         return createVisibilityHandlerResult(this, props, result, undefined);
     }
+    async enableCategoriesElementModelsVisibility(categoryIds) {
+        const categoriesModelsMap = await this._idsCache.getCategoriesElementModels(categoryIds, true);
+        const modelIds = [...categoriesModelsMap.values()].flat();
+        const hiddenModels = modelIds.filter((modelId) => !this._props.viewport.view.viewsModel(modelId));
+        if (hiddenModels.length > 0) {
+            this._props.viewport.changeModelDisplay(hiddenModels, true);
+        }
+    }
     changeDefinitionContainerState(props) {
         const result = defer(() => {
-            return from(this._idsCache.getAllContainedCategories(props.definitionContainerIds)).pipe(mergeAll(), mergeMap((categoryId) => {
-                return this.changeCategoryState({ categoryIds: [categoryId], on: props.on });
+            return from(this._idsCache.getAllContainedCategories(props.definitionContainerIds)).pipe(mergeMap((categoryIds) => {
+                return this.changeCategoryState({ categoryIds, on: props.on });
             }));
         });
         return createVisibilityHandlerResult(this, props, result, undefined);
@@ -666,7 +584,7 @@ class CategoriesTreeVisibilityHandlerImpl {
             const { modelId, categoryIds, on, ignoreSubCategories } = props;
             const viewport = this._props.viewport;
             if (!this._props.hierarchyConfig.showElements) {
-                return from(enableCategoryDisplay(viewport, categoryIds, on, on));
+                return concat(from(enableCategoryDisplay(viewport, categoryIds, on, on)), on ? from(this.enableCategoriesElementModelsVisibility(categoryIds)) : EMPTY);
             }
             const modelIdsObservable = modelId
                 ? of(new Map(categoryIds.map((id) => [id, [modelId]])))
@@ -689,7 +607,7 @@ class CategoriesTreeVisibilityHandlerImpl {
             const { modelId, categoryId, elementIds, on } = props;
             const viewport = this._props.viewport;
             return concat(on && !viewport.view.viewsModel(modelId) ? this.showModelWithoutAnyCategoriesOrElements(modelId) : EMPTY, defer(() => {
-                const categoryVisibility = this.getDefaultModelsCategoryVisibilityStatus({ categoryIds: [categoryId], modelId, ignoreTooltip: true });
+                const categoryVisibility = this.getDefaultModelsCategoryVisibilityStatus({ categoryIds: [categoryId], modelId });
                 const isDisplayedByDefault = categoryVisibility.state === "visible";
                 return this.queueElementsVisibilityChange(elementIds, on, isDisplayedByDefault);
             }), from(elementIds).pipe(mergeMap(async (elementId) => ({ elementId, isSubModel: await this._idsCache.hasSubModel(elementId) })), filter(({ isSubModel }) => isSubModel), map(({ elementId }) => elementId), toArray(), mergeMap((subModelIds) => this.changeModelState({ ids: subModelIds, on }))));
@@ -736,11 +654,11 @@ class CategoriesTreeVisibilityHandlerImpl {
             },
         }), map(() => undefined));
     }
-    getVisibilityFromAlwaysAndNeverDrawnElements({ ignoreTooltip, ...props }) {
+    getVisibilityFromAlwaysAndNeverDrawnElements(props) {
         const viewport = this._props.viewport;
         if (viewport.isAlwaysDrawnExclusive) {
             if (!viewport?.alwaysDrawn?.size) {
-                return of(createVisibilityStatus("hidden", getTooltipOptions(props.tooltips.noElementsInExclusiveAlwaysDrawnList, ignoreTooltip)));
+                return of(createVisibilityStatus("hidden"));
             }
         }
         else if (!viewport?.neverDrawn?.size && !viewport?.alwaysDrawn?.size) {
@@ -752,7 +670,6 @@ class CategoriesTreeVisibilityHandlerImpl {
                 alwaysDrawn: viewport.alwaysDrawn?.size ? setIntersection(props.elements, viewport.alwaysDrawn) : undefined,
                 neverDrawn: viewport.neverDrawn?.size ? setIntersection(props.elements, viewport.neverDrawn) : undefined,
                 totalCount: props.elements.size,
-                ignoreTooltip,
                 viewport,
             }));
         }
@@ -770,7 +687,6 @@ class CategoriesTreeVisibilityHandlerImpl {
             return getVisibilityFromAlwaysAndNeverDrawnElementsImpl({
                 ...props,
                 ...state,
-                ignoreTooltip,
                 viewport,
             });
         }));