solved: bug while alternatin toggles

Author: vladdez

src/explore.jl

@@ -27,7 +27,7 @@ function explore(model::UnfoldModel; positions = nothing, size = (700, 600))
         mapping, mapping_dom = mapping_dropdowns(var_names, var_types)
 
         # Create interactive topoplot widget on the lower left panel of the dashboard.
-        channel_chosen = Observable(4)
+        channel_chosen = Observable(1)
         if isnothing(positions)   
             topo_widget = nothing
         else
@@ -47,7 +47,8 @@ function explore(model::UnfoldModel; positions = nothing, size = (700, 600))
         end
 
         # Create a new empty grid layout
-        plot_layout = Observable(S.GridLayout())
+        
+        global plot_layout = Observable(S.GridLayout())
 
         # Create a new reentrant mutex (mutual exclusion) lock for safe thread synchronization during plot updates
         # mutex - allows only one thread to access protected code at a time
@@ -73,7 +74,6 @@ function explore(model::UnfoldModel; positions = nothing, size = (700, 600))
 
         css = Asset(joinpath(@__DIR__, "..", "style.css"))
         fig = plot(plot_layout; figure = (size = size,))
-
         # Create header, sidebar, topo and content (figure) panels
         cards = Grid(
             Card(formula_DOM, style = Styles("grid-area" => "header")),

src/functions_plotting.jl

@@ -1,13 +1,13 @@
 
 """
-    update_grid(data, value_ranges, categorical_vars, continuous_vars, mapping_obs)
+    update_grid(data, formula_values, categorical_vars, continuous_terms, mapping_obs)
 Plotting and updating an interactive dashboard.
 
  Arguments:\\
 - `data::DataFrame` - the result of `effects(Dict(...), model) ` with columns: yhat, channel, dummy, time, eventname and unique columns for each formula term.\\
-- `value_ranges::Vector{Pair{Symbol}}` - value range for continuous variables, levels for categorical.\\
+- `formula_values::Vector{Pair{Symbol}}` - value range for continuous variables, levels for categorical.\\
 - `categorical_vars::Vector{Symbol}` - categorical terms.\\
-- `continuous_vars::Vector{Symbol}` - continuous terms.\\
+- `continuous_terms::Vector{Symbol}` - continuous terms.\\
 - `mapping::Dict{Symbol, Symbol}` - dictionary with dropdown menus and their default values.\\
 
 Action:\\
@@ -19,33 +19,33 @@ Action:\\
 
 **Return Value:** `Makie.GridLayoutSpec`.
 """
-function update_grid(data, value_ranges, cat_terms, continuous_vars, mapping_obs)
+function update_grid(data, formula_values, cat_terms, continuous_terms, mapping_obs)
     # Convert observable mapping to values
     mapping = to_value(mapping_obs)
 
-    # Identify activated categorical and continuous variables
+    # Identify is categorical term activated
     cat_active = Dict(cat => data[1, cat] != "typical_value" for cat in cat_terms)
-    cont_active = Dict(cont => data[1, cont] != "typical_value" for cont in continuous_vars)
-#@debug cat_active
-    # Retrieve unique categorical levels
-    cat_levels = [unique(data[!, cat]) for cat in cat_terms]
+    # Identify is continuous term activated
+    cont_active = Dict(cont => data[1, cont] != "typical_value" for cont in continuous_terms)
+    # Retrieve levels for selected and unselected categorical terms
+    cat_levels = [unique(data[!, cat]) for cat in cat_terms] # empty unless selected
 
     # Prepare styles for categorical and continuous variables
     scatter_styles, line_styles = prepare_styles(
         data,
         cat_terms,
-        continuous_vars,
+        continuous_terms,
         mapping,
         cat_active,
         cont_active,
         cat_levels,
     )
 
-    col_term = mapping[:col]
-    row_term = mapping[:row]
+    col_term = mapping[:col] # not used yet
+    row_term = mapping[:row] # not used yet
 
     legend_entries =
-        [n => v for (n, v) in value_ranges if merge(cat_active, cont_active)[n]]
+        [n => v for (n, v) in formula_values if merge(cat_active, cont_active)[n]]
 
     row_levels =
         row_term == :none ? [""] :
@@ -75,45 +75,45 @@ function update_grid(data, value_ranges, cat_terms, continuous_vars, mapping_obs
             if col_term != :none
                 active_cat_vars[col_term] = [col_level]
             end
+
             # Iterate over categorical levels to define styles
             for level_grid in Iterators.product(collect(values(active_cat_vars))...)
                 if !isempty(level_grid) && level_grid[1] .== "typical_value"
                     continue
                 end
-                # create a new term => values (e.g. animal => [fish,cow] ) Dict
+                dict_grid = Dict(collect(keys(active_cat_vars)) .=> level_grid)
                 define_scatter_line_style!(
                     plots,
                     subdata,
-                    Dict(collect(keys(active_cat_vars)) .=> level_grid),
+                    dict_grid,
                     scatter_styles,
                     line_styles,
-                    continuous_vars,
+                    continuous_terms,
                 )
             end
-            axes[r_ix, c_ix] = S.Axis(; plots = plots)
+            axes[r_ix, c_ix] = S.Axis(; plots = plots)           
         end
     end
     palettes = merge(line_styles, scatter_styles)
 
-    legends = Union{Nothing,Makie.BlockSpec}[]
+    legends = Union{Nothing, Makie.BlockSpec}[]
     for (term, levels) in legend_entries
         if haskey(palettes, term)
             push!(legends, variable_legend(term, levels, Dict(palettes[term])))
         end
     end
-
-    if isempty(legends)
-        return S.GridLayout(axes)
-    else
-        return S.GridLayout([(1, 1) => S.GridLayout(axes), (:, 2) => S.GridLayout(legends)])
-    end
+    res = S.GridLayout([
+        (1, 1) => S.GridLayout(axes), 
+        (:, 2) => S.GridLayout(legends)
+    ])
+    return res
 end
 
 
 function prepare_styles(
     data,
     cat_terms,
-    continuous_vars,
+    continuous_terms,
     mapping,
     cat_active,
     cont_active,
@@ -127,30 +127,28 @@ function prepare_styles(
 
     # Assign styles to categorical variables
     scatter_styles = Dict()
-
     for (vals, cat) in zip(cat_levels, cat_terms)
         if !cat_active[cat]
             continue
         end
-
         for (target, pal) in
             zip([:color, :marker, :linestyle], (cpalette, mpalette, lpalette))
-            if mapping[target] == cat
+            if mapping[target] == cat 
                 p = cat => (target => Dict(zip(vals, pal)))
                 push!(scatter_styles, p)
             end
         end
     end
     # Assign styles to continuous variables
-    continuous_values = [extrema(data[!, con]) for con in continuous_vars]
-    if isempty(continuous_vars)
+    continuous_values = [extrema(data[!, con]) for con in continuous_terms]
+    if isempty(continuous_terms)
         # if no continuous variable, use the scatter-color for plotting
         line_styles = Dict()
 
     else
         line_styles = Dict(
             cont => (:colormap => (val, style)) for (style, val, cont) in
-            zip(continuous_styles, continuous_values, continuous_vars) if
+            zip(continuous_styles, continuous_values, continuous_terms) if
             cont_active[cont]
         )
     end

src/functions_scatter_linestyle.jl

@@ -41,17 +41,16 @@ function define_scatter_line_style!(
         (term, val) in dict_grid if term ∈ keys(scatter_styles)
     ]
 
-    # define style for lines 
+    # define style for lines and scatter
     if isempty(line_styles)
         line_cmap = []
         line_crange = []
 
-        line_color = args
-        if isempty(args) || !any(x -> x[1] == :color, args)
-            args = convert(Vector{Pair{Symbol, Any}}, args)
-            push!(args, :color => RGBA(0.0f0, 0.0f0, 0.0f0, 1.0f0)) # set scatte color to default black
-            line_color = [:color => Dict(args)[:color]] # set line color to default black
+        args = convert(Vector{Pair{Symbol, Any}}, args)
+        if isempty(args) || !any(x -> x[1] == :color, args)  
+            push!(args, :color => RGBA(0.0f0, 0.0f0, 0.0f0, 1.0f0)) # set scatter color to default black 
         end
+        line_color = [:color => Dict(args)[:color]]
 
     else # if contionus terms are present
         line_cmap = [kw => cmap for (_, (kw, (_, cmap))) in line_styles]

src/widgets_long.jl

@@ -1,19 +1,17 @@
-
-
 """
     mapping_dropdowns(varnames, var_types)
-Map and arrange dropdown menus on the left panel of the dashboard.\\
+Map and arrange drop-down menus on the left panel of the dashboard.\\
 
 Arguments:\\
 - `varnames::Vector{Symbol}` - vector of the model formula terms.\\
 - `var_types::Vector{Symbol}` - vector of types of the model formula terms.\\
 
 Actions:\\
-- Take categorical variables and put their values into dropdown menus.\\
+- Take categorical variables and put their values into drop-down menus.\\
 - There will be 5 menus for: color, markers, line styles, column and row facets.\\
-- Map each menu object with its name on the Figure.\\
-- Create HTML containers using Document Object Model (DOM) from Bonito.\\
-- Arrange containers on the panel using Col() and Row(). Specify their styling.\\
+- Map each menu object to its name in the image.\\
+- Create HTML containers using Bonito's Document Object Model (DOM).\\
+- Arrange the containers on the panel using Col() and Row(). Specify their styling.\\
 
 **Return Values:**\\
 - `mapping::Observable{Dict{Symbol, Symbol}}` - interactive dictionary with menues and their default value.\\