jungle-server/js/grids/makeRemoveSplitGrid.js

import { makeDiv,
         makeCenteredTextDiv,
         setElementPosition,
         getInputHeight } from '/domUtilities.js';

import { getGridCoordinates,
         returnPanels } from './gridUtilities.js';


import { jc as jcGlobal } from '/configuration.js';




function makeTabsRemoveSplitPanel(coords,
                                  tabs,
                                  gridContents,
                                  i,
                                  redraw,
                                  availablePanels,
                                  gridSplits,
                                  prevGrid) {

    const jc = jcGlobal.jc;

    const inputHeight = getInputHeight();
    
    const div = makeDiv();
    setElementPosition(div, coords);
    
    const tabsCoords = [coords[0],
                        coords[1],
                        coords[2],
                        inputHeight];

    const contentCoords = [coords[0],
                           coords[1] + inputHeight,
                           coords[2],
                           coords[3] - inputHeight];
    

    if(gridSplits) {


        const tabsPanel = makeDiv(); 
        tabsPanel.style.opacity = 0;
        setElementPosition(tabsPanel, tabsCoords);

        const tabsDisplayPanel = makeCenteredTextDiv('remove split');
        tabsDisplayPanel.style.background = jc.General.removeSplitColor;
        tabsDisplayPanel.style.opacity = 0;
        setElementPosition(tabsDisplayPanel, coords);

        div.append(tabsDisplayPanel, tabsPanel);

        tabsPanel.onmouseover = () => {
            tabsDisplayPanel.style.opacity = 1;
        };
        
        
        tabsPanel.onmouseleave = () => {
            tabsDisplayPanel.style.opacity = 0;
        };

        tabsPanel.onmousedown = () => {
            

            const split = gridSplits[i];
            if(i > 0 && i < gridSplits.length - 1) {
                gridSplits[i-1] += split / 2;
                gridSplits[i+1] += split / 2;

            }else if(i === 0) {
                gridSplits[1] += split;
            }else if(i === gridSplits.length - 1) {
                gridSplits[gridSplits.length - 2] += split;
            }

            gridSplits.splice(i, 1);
            gridContents.splice(i, 1);

            returnPanels(tabs.contents, availablePanels);
            
            if(gridContents.length === 1 && prevGrid) {
                
                prevGrid.contents[prevGrid.i] = gridContents[0];

            }
            
            redraw();

            
            
            
        };
    }

     const currentContent = tabs.contents[tabs.getCurrentIndex()];

    if(currentContent.type  === 'grid') {

        div.append(makeRemoveSplitGrid(contentCoords[0],
                                       contentCoords[1],
                                       contentCoords[2],
                                       contentCoords[3],
                                       currentContent.contents,
                                       currentContent.splits,
                                       currentContent.direction,
                                       redraw,
                                       jc,
                                       availablePanels,
                                       {contents: tabs.contents,
                                        i: tabs.getCurrentIndex()}));

        
    }else if(currentContent.type === 'tabs') {

        div.append(makeTabsRemoveSplitPanel(contentCoords,
                                            currentContent,
                                            tabs.contents,
                                            tabs.getCurrentIndex(),
                                            redraw,
                                            availablePanels));

        
    }
    

    return div;

    
}




function makeRemoveSplitGrid(x,
                             y,
                             width,
                             height,
                             contents,
                             splits,
                             direction,
                             redraw,
                             jc,
                             availablePanels,
                             prevGrid) {


    const div = makeDiv();
    setElementPosition(div, [x, y, width, height]);

    const coords = getGridCoordinates(x, y, width, height, splits, direction);

    contents.forEach((content, i) => {

        if(content.type === 'tabs') {

            div.append(makeTabsRemoveSplitPanel(coords[i],
                                                content,
                                                contents,
                                                i,
                                                redraw,
                                                availablePanels,
                                                splits,
                                                prevGrid));
            
        }else if(content.type !== 'grid') {
            const panel = makeCenteredTextDiv('remove split');
            panel.style.background = jc.General.removeSplitColor;
            setElementPosition(panel, coords[i]);
            panel.style.opacity = 0;

            
            panel.onmouseover = () => {
                panel.style.opacity = 1;
            };

            panel.onmouseleave = () => {
                panel.style.opacity = 0;
            };

            panel.onmousedown = () => {

                if(prevGrid || contents.length > 1) {

                    if(contents[i].label) {
                        availablePanels.push(contents[i]);
                    }
                    const split = splits[i];
                    if(i > 0 && i < splits.length - 1) {
                        splits[i-1] += split / 2;
                        splits[i+1] += split / 2;

                    }else if(i === 0) {
                        splits[1] += split;
                    }else if(i === splits.length - 1) {
                        splits[splits.length - 2] += split;
                    }

                    splits.splice(i, 1);
                    contents.splice(i, 1);

                    if(contents.length === 1 && prevGrid) {
                        
                        prevGrid.contents[prevGrid.i] = contents[0];

                    }
                    
                    redraw();

                }
                
            };
            
            div.append(panel);
            
        }else {

            div.append(makeRemoveSplitGrid(coords[i][0],
                                           coords[i][1],
                                           coords[i][2],
                                           coords[i][3],
                                           contents[i].contents,
                                           contents[i].splits,
                                           contents[i].direction,
                                           redraw,
                                           jc,
                                           availablePanels,
                                           {contents, i}));

        }

    });

    return div;


    

}

export { makeRemoveSplitGrid }