playbook_ui 12.26.0 → 12.26.1.pre.alpha.play716popoverkitcloseonclickissue833

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f05ba004408818dfcba9bd10157c3c88af1dd4d310795c061f333b5945fc4f5a
-  data.tar.gz: e0634afd89ddd77122ed2a6fedf1a0af05dbc0a07e93dccae55b1e2227303cbc
+  metadata.gz: bc05d54c9a3beeca0cdfd89f672b2aa6a3b5ed7cd3eb0ce9fe49aad64c2c5cf4
+  data.tar.gz: 40811095a508f62f3b0be30ba0910c8f7bf1e0a058b3c3cef71418c2db782382
 SHA512:
-  metadata.gz: d9c746e3c5e9e738c378c47f109c3c7ac8f069da5d04fca517dc58128053d6b02a75b0ba2d244d1f070348f856d8348438721f59708afd9b9be90ba82f66267f
-  data.tar.gz: '050496ad839d51a4fc1e6440d9356f578cb3613b788770ffbd703b99c1f1f14d1e060e6dd7b7bc1fb878c61f5f1a697b0a8df3ddb55b8f0ee4085d047a6be9a8'
+  metadata.gz: 21ae38d7936b12cafb50c6fb7a6bd7a1c250359e0c375eb34e713c9127876c583f22e7b983dea3fb8c54207997ea55e15221af2dc78cc87765b99868bd22b1ba
+  data.tar.gz: 1253d8ba46fb06dab662b03797e95f5b82ed240d613e4d8277d1b65c185823933ac54985828fc782c05de3cd72a889902393ffb9d0445d5ca9bbb35ebf011f11

data/app/pb_kits/playbook/pb_multi_level_select/_helper_functions.tsx

@@ -1,58 +1,16 @@
-//function for unchecking items in formattedData
-export const unCheckIt = (
-  formattedData: { [key: string]: any }[],
-  id: string
-) => {
-  formattedData.map((item: { [key: string]: any }) => {
-    if (item.id === id && item.checked) {
-      item.checked = false;
-    }
-    if (item.children && item.children.length > 0) {
-      unCheckIt(item.children, id);
-    }
-    return item;
-  });
-};
-
 //function to retrieve all ancestors of unchecked item and set checked to false
 export const getAncestorsOfUnchecked = (
-  formattedData: { [key: string]: any }[],
+  data: { [key: string]: any }[],
   item: { [key: string]: any }
 ) => {
   if (item.parent_id) {
-    const ancestors = filterFormattedDataById(formattedData, item.parent_id);
-    ancestors[0].checked = false;
-
-    if (ancestors[0].parent_id) {
-      getAncestorsOfUnchecked(formattedData, ancestors[0]);
-    }
+    const ancestor = filterFormattedDataById(data, item.parent_id);
+    ancestor[0].checked = false;
+    ancestor[0].parent_id && getAncestorsOfUnchecked(data, ancestor[0])
   }
+  return data;
 };
-
-//recursively check all child and grandchild items if parent checked
-export const checkedRecursive = (item: { [key: string]: any }) => {
-  if (!item.checked) {
-    item.checked = true;
-  }
-  if (item.children && item.children.length > 0) {
-    item.children.forEach((childItem: { [key: string]: any }) => {
-      checkedRecursive(childItem);
-    });
-  }
-};
-
-//recursively uncheck all child and grandchild items if parent unchecked
-export const unCheckedRecursive = (item: { [key: string]: any }) => {
-  if (item.checked) {
-    item.checked = false;
-  }
-  if (item.children && item.children.length > 0) {
-    item.children.forEach((childItem: { [key: string]: any }) => {
-      unCheckedRecursive(childItem);
-    });
-  }
-};
-
+  
 //function is going over formattedData and returning all objects that match the
 //id of the clicked item from the dropdown
 export const filterFormattedDataById = (
@@ -64,6 +22,7 @@ export const filterFormattedDataById = (
     for (const item of data) {
       if (item.id.toLowerCase() === (term.toLowerCase())) {
         matched.push(item);
+        return
       }
 
       if (item.children && item.children.length > 0) {
@@ -116,97 +75,60 @@ export const getCheckedItems = (
   });
   return checkedItems;
 };
+    
+export const getDefaultCheckedItems = (treeData:{ [key: string]: any }[]) => {
+  const checkedDefault: { [key: string]: any }[] = [];
 
-export const getChildIds = (
-  item: { [key: string]: any },
-  defaultArray: { [key: string]: any }[]
-) => {
-  let childIds: string[] = [];
-  item.children.forEach((child: { [key: string]: any }) => {
-    childIds.push(child.id);
-    if (child.children && child.children.length > 0) {
-      const childChildIds = getChildIds(child, defaultArray);
-      childIds.push(...childChildIds);
+  const traverseTree = (items:{ [key: string]: any }[]) => {
+    if (!Array.isArray(items)) {
+      return;
     }
-  });
-  return childIds;
-};
+    items.forEach((item:{ [key: string]: any }) => {
+      if (item.checked) {
+        if (item.children && item.children.length > 0) {
+          const uncheckedChildren = item.children.filter((child:{ [key: string]: any }) => !child.checked);
+          if (uncheckedChildren.length === 0) {
+            checkedDefault.push(item);
+            return;
+          }
+        } else {
+          const parent = items.find((parentItem:{ [key: string]: any }) => parentItem.id === item.parentId);
+          if (!parent || !parent.checked) {
+            checkedDefault.push(item);
+          }
+        }
+      }
 
-export const updateReturnItems = (newChecked: { [key: string]: any }[]) => {
-  const updatedCheckedItems: { [key: string]: any }[] = [];
-  for (const item of newChecked) {
-    if (item.children && item.children.length > 0) {
-      const allChildrenChecked = item.children.every(
-        (child: { [key: string]: any }) => child.checked
-      );
-      if (allChildrenChecked) {
-        updatedCheckedItems.push(item);
+      if (item.children && item.children.length > 0) {
+        traverseTree(item.children);
       }
-    }
-    const childItem = updatedCheckedItems.some((x) => x.id === item?.parent_id);
-    if (!childItem) {
-      updatedCheckedItems.push(item);
-    }
-  }
-  const filteredReturn = updatedCheckedItems.filter((item) => {
-    return !updatedCheckedItems.find(
-      (otherItem) => otherItem.id === item.parent_id
-    );
-  });
-  return filteredReturn;
+    });
+  };
+
+  traverseTree(treeData);
+
+  return checkedDefault;
 };
 
-export const recursiveReturnOnlyParent = (
-  items: { [key: string]: any },
-  formattedData: { [key: string]: any }[],
-  defaultReturn: { [key: string]: any }[],
-  setDefaultReturn: any
+export const recursiveCheckParent = (
+  item: { [key: string]: any },
+  data:any
 ) => {
-  const parent = filterFormattedDataById(formattedData, items.parent_id);
+  if (item.parent_id !== null) {
+  const parent = filterFormattedDataById(data, item.parent_id);
   const allChildrenChecked = parent[0].children.every(
     (child: { [key: string]: any }) => child.checked
   );
   if (allChildrenChecked) {
-    // Only return the parent and remove its children from defaultReturn
     parent[0].checked = true;
-    const filteredDefaultReturn = defaultReturn.filter((item) => {
-      // Remove children of the specific parent
-      if (
-        parent[0].children.find(
-          (child: { [key: string]: any }) => child.id === item.id
-        )
-      ) {
-        return false;
-      }
-    });
-    setDefaultReturn([...filteredDefaultReturn, parent[0]]);
-    // Check if the parent has a parent and its children are all checked
     const parentHasParent = parent[0].parent_id !== null;
     if (parentHasParent) {
-      recursiveReturnOnlyParent(
+      recursiveCheckParent(
         parent[0],
-        formattedData,
-        filteredDefaultReturn,
-        setDefaultReturn
+        data
       );
     }
-  } else {
-    const checkedChildren = parent[0].children.filter(
-      (child: { [key: string]: any }) => child.checked
-    );
-    const updatedDefaultReturn = [...defaultReturn, ...checkedChildren];
-    setDefaultReturn(updatedDefaultReturn);
-  }
-};
-
-export const removeChildrenIfParentChecked = (
-  items: { [key: string]: any },
-  defaultReturn: { [key: string]: any }[],
-  setDefaultReturn: any
-) => {
-  const childIds = getChildIds(items, defaultReturn);
-  const filteredDefaultArray = defaultReturn.filter(
-    (item: { [key: string]: any }) => childIds !== item.id
-  );
-  setDefaultReturn([...filteredDefaultArray, items]);
-};
+}
+}
+return data;
+}

data/app/pb_kits/playbook/pb_multi_level_select/_multi_level_select.tsx

@@ -6,18 +6,15 @@ import Icon from "../pb_icon/_icon";
 import Checkbox from "../pb_checkbox/_checkbox";
 import FormPill from "../pb_form_pill/_form_pill";
 import CircleIconButton from "../pb_circle_icon_button/_circle_icon_button";
+import { cloneDeep } from "lodash";
+
 import {
-  unCheckIt,
   getAncestorsOfUnchecked,
-  unCheckedRecursive,
-  checkedRecursive,
   filterFormattedDataById,
   findByFilter,
   getCheckedItems,
-  updateReturnItems,
-  recursiveReturnOnlyParent,
-  removeChildrenIfParentChecked,
-  getChildIds,
+  getDefaultCheckedItems,
+  recursiveCheckParent,
 } from "./_helper_functions";
 
 type MultiLevelSelectProps = {
@@ -51,6 +48,8 @@ const MultiLevelSelect = (props: MultiLevelSelectProps) => {
 
   const dropdownRef = useRef(null);
 
+  //state for expanded property
+  const [expanded, setExpanded] = useState([]);
   //state for whether dropdown is open or closed
   const [isClosed, setIsClosed] = useState(true);
   //state from onchange for textinput, to use for filtering to create typeahead
@@ -58,45 +57,29 @@ const MultiLevelSelect = (props: MultiLevelSelectProps) => {
   //this is essentially the return that the user will get when they use the kit
   const [returnedArray, setReturnedArray] = useState([]);
   //formattedData with checked and parent_id added
-  const [formattedData, setFormattedData] = useState(treeData);
-  //toggle chevron in dropdown
-  //@ts-ignore
-  const [isToggled, setIsToggled] = useState<{ [id: number]: boolean }>({}); 
+  const [formattedData, setFormattedData] = useState([]);
   //state for return for default
   const [defaultReturn, setDefaultReturn] = useState([]);
 
   useEffect(() => {
-    let el = document.getElementById(`pb_data_wrapper_${id}`);
-    if (el) {
-      el.setAttribute(
-        "data-tree",
-        JSON.stringify(returnAllSelected ? returnedArray : defaultReturn)
-      );
+    setFormattedData(addCheckedAndParentProperty(treeData));
+  }, [treeData]);
+
+  useEffect(() => {
+    if (returnAllSelected) {
+      setReturnedArray(getCheckedItems(formattedData));
+    } else {
+      setDefaultReturn(getDefaultCheckedItems(formattedData));
     }
-    returnAllSelected
-      ? onSelect(returnedArray)
-      : onSelect(
-          defaultReturn.filter(
-            (item, index, self) =>
-              index === self.findIndex((obj) => obj.id === item.id)
-          )
-        );
-  }, [returnedArray, defaultReturn]);
+  }, [formattedData]);
 
   useEffect(() => {
-    //Create new formattedData array for use
-    setFormattedData(addCheckedAndParentProperty(treeData));
     // Function to handle clicks outside the dropdown
     const handleClickOutside = (event: any) => {
       if (dropdownRef.current && !dropdownRef.current.contains(event.target)) {
         setIsClosed(true);
       }
     };
-    //if any items already checked in first render, set return accordingly
-    const initialChecked = getCheckedItems(treeData)
-    initialChecked && returnAllSelected && setReturnedArray(initialChecked)
-    initialChecked && !returnAllSelected && setDefaultReturn(initialChecked)
-
     // Attach the event listener
     window.addEventListener("click", handleClickOutside);
     // Clean up the event listener on unmount
@@ -105,11 +88,72 @@ const MultiLevelSelect = (props: MultiLevelSelectProps) => {
     };
   }, []);
 
+  const modifyRecursive = (tree: { [key: string]: any }[], check: boolean) => {
+    if (!Array.isArray(tree)) {
+      return;
+    }
+    return tree.map((item: { [key: string]: any }) => {
+      item.checked = check;
+      item.children = modifyRecursive(item.children, check);
+      return item;
+    });
+  };
+
+  //iterate over tree, find item and set checked or unchecked
+  const modifyValue = (
+    id: string,
+    tree: { [key: string]: any }[],
+    check: boolean
+  ) => {
+    if (!Array.isArray(tree)) {
+      return;
+    }
+    return tree.map((item: any) => {
+      if (item.id != id) item.children = modifyValue(id, item.children, check);
+      else {
+        item.checked = check;
+        item.children = modifyRecursive(item.children, check);
+      }
+
+      return item;
+    });
+  };
+
+  //clone tree, check items + children
+  const checkItem = (item: { [key: string]: any }) => {
+    const tree = cloneDeep(formattedData);
+    if (returnAllSelected) {
+      return modifyValue(item.id, tree, true);
+    } else {
+      const checkedTree = modifyValue(item.id, tree, true);
+      return recursiveCheckParent(item, checkedTree);
+    }
+  };
+
+  //clone tree, uncheck items + children
+  const unCheckItem = (item: { [key: string]: any }) => {
+    const tree = cloneDeep(formattedData);
+    if (returnAllSelected) {
+      return modifyValue(item.id, tree, false);
+    } else {
+      const uncheckedTree = modifyValue(item.id, tree, false);
+      return getAncestorsOfUnchecked(uncheckedTree, item);
+    }
+  };
+
+  //setformattedData with proper properties
+  const changeItem = (item: { [key: string]: any }, check: boolean) => {
+    const tree = check ? checkItem(item) : unCheckItem(item);
+    setFormattedData(tree);
+
+    return tree;
+  };
+
   //function to map over data and add parent_id + depth property to each item
   const addCheckedAndParentProperty = (
     treeData: { [key: string]: any }[],
     parent_id: string = null,
-    depth: number = 0,
+    depth: number = 0
   ) => {
     if (!Array.isArray(treeData)) {
       return;
@@ -121,10 +165,14 @@ const MultiLevelSelect = (props: MultiLevelSelectProps) => {
         depth,
       };
       if (newItem.children && newItem.children.length > 0) {
+        const children =
+          item.checked && !returnAllSelected
+            ? modifyRecursive(item.children, true)
+            : item.children;
         newItem.children = addCheckedAndParentProperty(
-          newItem.children,
+          children,
           newItem.id,
-          depth + 1,
+          depth + 1
         );
       }
       return newItem;
@@ -135,37 +183,13 @@ const MultiLevelSelect = (props: MultiLevelSelectProps) => {
   const handlePillClose = (event: any, clickedItem: { [key: string]: any }) => {
     // prevents the dropdown from closing when clicking on the pill
     event.stopPropagation();
+    const updatedTree = changeItem(clickedItem, false);
     //logic for removing items from returnArray or defaultReturn when pills clicked
     if (returnAllSelected) {
-      if (returnedArray.includes(clickedItem)) {
-        if (clickedItem.children && clickedItem.children.length > 0) {
-          const childrenOfChecked = getChildIds(clickedItem, returnedArray);
-          const updatedFiltered = returnedArray
-            .filter((item) => item !== clickedItem)
-            .filter((item) => !childrenOfChecked.includes(item.id));
-          setReturnedArray(updatedFiltered);
-        } else {
-          const updatedFiltered = returnedArray.filter(
-            (item) => item !== clickedItem
-          );
-          setReturnedArray(updatedFiltered);
-        }
-      }
+      onSelect(getCheckedItems(updatedTree));
     } else {
-      if (defaultReturn.includes(clickedItem)) {
-        getAncestorsOfUnchecked(formattedData, clickedItem);
-        const newChecked = getCheckedItems(formattedData);
-        const filteredReturn = updateReturnItems(newChecked).filter(
-          (item) => item.id !== clickedItem.id
-        );
-        setDefaultReturn(filteredReturn);
-      }
-    }
-    if (clickedItem.children && clickedItem.children.length > 0) {
-      unCheckedRecursive(clickedItem);
+      onSelect(getDefaultCheckedItems(updatedTree));
     }
-    //logic to uncheck clickedItem in formattedData
-    unCheckIt(formattedData, clickedItem.id);
   };
 
   //handle click on input wrapper(entire div with pills, typeahead, etc) so it doesn't close when input or form pill is clicked
@@ -181,95 +205,36 @@ const MultiLevelSelect = (props: MultiLevelSelectProps) => {
   };
 
   //Main function to handle any click inside dropdown
-  const handledropdownItemClick = (e: any) => {
+  const handledropdownItemClick = (e: any, check: boolean) => {
     const clickedItem = e.target.parentNode.id;
     //setting filterItem to "" will clear textinput and clear typeahead
     setFilterItem("");
 
     const filtered = filterFormattedDataById(formattedData, clickedItem);
-    //check and uncheck all children of checked/unchecked parent item
-    if (filtered[0].children && filtered[0].children.length > 0) {
-      if (filtered[0].checked) {
-        filtered[0].children.forEach((item: { [key: string]: any }) => {
-          checkedRecursive(item);
-        });
-      } else if (!filtered[0].checked) {
-        filtered[0].children.forEach((item: { [key: string]: any }) => {
-          unCheckedRecursive(item);
-        });
-      }
-    }
-
-    const checkedItems = getCheckedItems(formattedData);
-
-    //checking and unchecking items for returnAllSelected variant
-    if (returnedArray.includes(filtered[0])) {
-      if (!filtered[0].checked) {
-        if (filtered[0].children && filtered[0].children.length > 0) {
-          const childrenOfChecked = getChildIds(filtered[0], returnedArray);
-          const updatedFiltered = returnedArray
-            .filter((item) => item !== filtered[0])
-            .filter((item) => !childrenOfChecked.includes(item.id));
-
-          setReturnedArray(updatedFiltered);
-        } else {
-          const updatedFiltered = returnedArray.filter(
-            (item) => item !== filtered[0]
-          );
-          setReturnedArray(updatedFiltered);
-        }
-      }
+    const updatedTree = changeItem(filtered[0], check);
+    console.log(updatedTree);
+    if (returnAllSelected) {
+      onSelect(getCheckedItems(updatedTree));
     } else {
-      setReturnedArray(checkedItems);
-    }
-
-    //when item is unchecked for default variant
-    if (!filtered[0].checked && !returnAllSelected) {
-      //uncheck parent and grandparent if any child unchecked
-      getAncestorsOfUnchecked(formattedData, filtered[0]);
-
-      const newChecked = getCheckedItems(formattedData);
-      //get all checked items, and filter to check if all children checked, if yes return only parent
-      const filteredReturn = updateReturnItems(newChecked);
-      setDefaultReturn(filteredReturn);
-    }
-
-    //when item is checked for default variant
-    if (!returnAllSelected && filtered[0].checked) {
-      //if checked item has children
-      if (filtered[0].children && filtered[0].children.length > 0) {
-        removeChildrenIfParentChecked(
-          filtered[0],
-          defaultReturn,
-          setDefaultReturn
-        );
-      }
-
-      //if clicked item has parent_id, find parent and check if all children checked or not
-      if (filtered[0].parent_id !== null) {
-        recursiveReturnOnlyParent(
-          filtered[0],
-          formattedData,
-          defaultReturn,
-          setDefaultReturn
-        );
-      } else {
-        setDefaultReturn([filtered[0]]);
-      }
+      onSelect(getDefaultCheckedItems(updatedTree));
     }
   };
 
+  const isExpanded = (item: any) => expanded.indexOf(item.id) > -1;
+
   //handle click on chevron toggles in dropdown
   const handleToggleClick = (id: string, event: React.MouseEvent) => {
     event.stopPropagation();
-    setIsToggled((prevState: { [id: string]: boolean }) => ({
-      ...prevState,
-      [id]: !prevState[id],
-    }));
     const clickedItem = filterFormattedDataById(formattedData, id);
-
     if (clickedItem) {
-      clickedItem[0].expanded = !clickedItem[0].expanded;
+      let expandedArray = [...expanded];
+      const itemExpanded = isExpanded(clickedItem[0]);
+
+      if (itemExpanded)
+        expandedArray = expandedArray.filter((i) => i != clickedItem[0].id);
+      else expandedArray.push(clickedItem[0].id);
+
+      setExpanded(expandedArray);
     }
   };
 
@@ -281,23 +246,23 @@ const MultiLevelSelect = (props: MultiLevelSelectProps) => {
           items.map((item: { [key: string]: any }) => {
             return (
               <>
-                <li
-                  key={item.id}
-                  className="dropdown_item"
-                  data-name={item.id}
-                >
+                <li key={item.id} className="dropdown_item" data-name={item.id}>
                   <div className="dropdown_item_checkbox_row">
                     <div
-                      key={
-                        item.expanded ? "chevron-down" : "chevron-right"
-                      }
+                      key={isExpanded(item) ? "chevron-down" : "chevron-right"}
                     >
                       <CircleIconButton
                         icon={
-                          item.expanded ? "chevron-down" : "chevron-right"
+                          isExpanded(item) ? "chevron-down" : "chevron-right"
+                        }
+                        className={
+                          item.children && item.children.length > 0
+                            ? ""
+                            : "toggle_icon"
+                        }
+                        onClick={(event: any) =>
+                          handleToggleClick(item.id, event)
                         }
-                        className={item.children && item.children.length > 0 ? "" : "toggle_icon"}
-                        onClick={(event) => handleToggleClick(item.id, event)}
                         variant="link"
                       />
                     </div>
@@ -308,13 +273,12 @@ const MultiLevelSelect = (props: MultiLevelSelectProps) => {
                         name={item.label}
                         value={item.label}
                         onChange={(e) => {
-                          item.checked = !item.checked;
-                          handledropdownItemClick(e);
+                          handledropdownItemClick(e, !item.checked);
                         }}
                       />
                     </Checkbox>
                   </div>
-                  {item.expanded &&
+                  {isExpanded(item) &&
                     item.children &&
                     item.children.length > 0 &&
                     !filterItem && ( // Show children if expanded is true
@@ -339,25 +303,20 @@ const MultiLevelSelect = (props: MultiLevelSelectProps) => {
                     key={index}
                     text={item.label}
                     size="small"
-                    onClick={(event) => handlePillClose(event, item)}
+                    onClick={(event: any) => handlePillClose(event, item)}
                   />
                 ))
               : null}
             {!returnAllSelected &&
               defaultReturn.length !== 0 &&
-              defaultReturn
-                .filter(
-                  (item, index, self) =>
-                    index === self.findIndex((obj) => obj.id === item.id)
-                )
-                .map((item, index) => (
-                  <FormPill
-                    key={index}
-                    text={item.label}
-                    size="small"
-                    onClick={(event) => handlePillClose(event, item)}
-                  />
-                ))}
+              defaultReturn.map((item, index) => (
+                <FormPill
+                  key={index}
+                  text={item.label}
+                  size="small"
+                  onClick={(event: any) => handlePillClose(event, item)}
+                />
+              ))}
             {returnedArray.length !== 0 && returnAllSelected && <br />}
             {defaultReturn.length !== 0 && !returnAllSelected && <br />}
             <input

data/app/pb_kits/playbook/pb_popover/_popover.tsx

@@ -171,17 +171,19 @@ const PbReactPopover = (props: PbPopoverProps) => {
 
         switch (closeOnClick) {
           case "outside":
-            if (!targetIsPopover || targetIsReference) {
+            if (!targetIsPopover && !targetIsReference) {
               shouldClosePopover(true);
             }
             break;
           case "inside":
-            if (targetIsPopover || targetIsReference) {
+            if (targetIsPopover) {
               shouldClosePopover(true);
             }
             break;
           case "any":
-            shouldClosePopover(true);
+            if (targetIsPopover || !targetIsPopover && !targetIsReference) {
+              shouldClosePopover(true);
+            }
             break;
         }
       },

data/app/pb_kits/playbook/pb_popover/index.ts

@@ -49,13 +49,16 @@ export default class PbPopover extends PbEnhancedElement {
   checkCloseTooltip() {
     document.querySelector('body').addEventListener('click', ({ target } ) => {
       const isTooltipElement = (target as HTMLElement).closest(`#${this.tooltipId}`) !== null
+      const isTriggerElement = (target as HTMLElement).closest(`#${this.triggerElementId}`) !== null
 
       switch (this.closeOnClick) {
       case 'any':
-        this.hideTooltip()
+        if (isTooltipElement || !isTooltipElement && !isTriggerElement) {
+          this.hideTooltip()
+        }
         break
       case 'outside':
-        if (!isTooltipElement) {
+        if (!isTooltipElement && !isTriggerElement) {
           this.hideTooltip()
         }
         break