monomer/tasks.md

• Done

  • Check events only for interested widgets (use focus for keyboard and region for mouse)
  • Add handling of disabled widget nodes
  • Add handling of custom external actions for widgets
  • Do something with return of custom handlers (the exact same thing we do with event handlers)
  • Add scroll support
  • Add hstack/vstack containers
  • Improve input (keyboard) handling
  • Implement copy/paste
  • Add HiDPI handling
  • Handle window resize
  • Improve handling of Color (turn to 0.0 to 1.0 instead of 0 to 255? only do it for alpha?)
  • Add handling of non visible widget nodes
  • Handle widget fixed size
  • Add good looking caret to textField
  • Add support for onFocus/onBlur
  • Maybe we don't need this and we can get by with position in render function?
    • Add support for onEnter/onLeave (keep track of previous active widgets)
    • We probably need it for drag&drop
  • How is the user going to provide state updates?
    • We already provide this with the State monad and corresponding lenses
  • Improve mouse support/current state of mouse and keyboard for event handling
  • Make handleEvent run inside MonadState (required to update user provided lenses) CANCELLED
  • Add logic that allows widgets to update user state
  • Does it make sense to avoid lenses internally, given that we already include the dependency?
  • How will long running (i.e., not immediate) user tasks will be handled?
  • Using local coordinates for widgets CANCELLED
    • How do we adjust current displacement?
  • Track drawing operations made by a Widget
    • Reorganize drawing operations
  • Stop, think and design
    • How should all of this be organized?
    • How should modules be laid out?
    • What are good interfaces for the different parts of the system?
    • Does it make sense that handleEvent is the only pure function in a widget?
    • Based on the previous design, refactor modules
  • Current massive refactor
    • Replace Tree with Containers' Tree
    • Fix issue with event handling (click makes everything disappear)
    • Fix focus situation (remove _focusRing and replace with single focus, then use widgetNextFocusable)
    • Provide focus to render (needed by textField)
    • Check if resize children still makes sense (maybe the widget itself can resize on the corresponding event?)
    • Handle SetFocus request
    • Check if WidgetState is really needed
      • Maybe Data.Dynamic can be used, but currently abandoned
    • Rethink Tree.Path import
    • Clean up Seq imports
    • Where can we use Seq? Does it make sense to use it everywhere? What about Traversable?
    • Reorganize Common Types. What do other projects do? They should be simple to import and use
  • Create composite widget, allowing isolated event handling and UI creation
  • Create application widget, based on composite
    • Remove UserTask concept, handle it as WidgetTask
  • Support long running tasks that can provide events through a channel
  • Add Multiple response support (extra value in EventResponse)
  • Try to remove all those Typeable requirements in CompositeWidget
    • Removing Monad from Widget/WidgetInstance was good enough
    • Some Typeable constraints still needed, but user should not need to do anything
  • Provide a way of initializing the application
    • Probably taking a simple event that is relayed to appEventsHandler is enough?
  • Implement Global keys
  • Improve merge process
  • Add a way to get path of widget given an id, and provide a method to send a message/event (most likely, a new Request kind)
  • Rename EventResult to something more accurate
    • Replace resultWidget and friends with non-Maybe versions (update widgets)
  • Add renderLast function to Renderer, which delays rendering until the first pass is done
    • Futher calls to renderLast should not be ignored (tooltip on dropdown menu?)
    • A handleDelayedRendering also needs to be added
    • We also need a way of receiving events on upper layers
    • All this is needed for dropdowns, but it's also useful for tooltips
  • Create Dropdown
  • Improve hstack/vstack
    • If available space is greater than requested, do not apply resizing logic
  • Does a styling engine make sense or doing something similar to Flutter is simpler?
    • Does keeping style for some things (fixed width/height) make sense?
      • Yes! All these properties are staying
    • Could container handle padding and centering?
      • No, staying how it is now. It does not disallow having a container, of course
    • Implement styling engine. Think why Maybe Double instead of Maybe Dimension (to handle pixels, percent, etc)
      • Handle this with a widget that takes care of assigning space
    • Improve FixedSize. Consider adding min/max width/height
      • Not for the moment
  • Improve ergonomics
    • https://hackage.haskell.org/package/string-interpolate
    • Check if advanced type level features would improve the design
    • Check what syntax extensions can be abused to make life easier
      • https://limperg.de/ghc-extensions/#basic-patterns
      • https://limperg.de/ghc-extensions/#datakinds
      • Maybe -> https://typeclasses.com/extensions-intro
    • Look for ways that allow both lenses and user events to be used in the same widget
      • Most likely through a Default instance
    • Related to previous, look for ways to simplify widget setup. Default instance with common values?
    • Find way of providing instance config (style, visibility, etc) before providing children (some sort of flip operator)
      • Just provide style after children. SwiftUI does it this way
    • Fix border drawing. Handle simple case (more efficient)
  • Fix scroll click navigation
    • Highlight bar when mouse over
    • Highlight handle when mouse over
    • Handle clicks in bar outside handle
    • Handle handle drag
    • Mouse over on overlapping axis gives precedence to vertical scroll
  • Keep sending mouse move event if mouse is away but button is still pressed
    • Handle mouse enter/leave window events
  • Add support for scroll requests from children
  • Improve Dropdown
    • Expose customizable interface
    • Request scroll when needed
    • Validate Maybe values are supported
    • Create nullable version which takes care of fmapping traversable with Just
  • Check why vstack fails when using [spacer, listView]
  • Remove status from Click event. Add ButtonPressed and ButtonReleased events
  • Change order of parameters. We should always pass old before new
  • Unify criteria for instantiation
    • Component name without underscore receives parameters positionally
    • Component name with underscore receives Config instance
  • If two flexible sized and one remaining elements are in a vstack, problems arise
  • Add renderer parameter to resize. It will be needed for auto adjustable Label and to handle ellipsis in texts
    • Maybe creating a record of functions would be useful?
    • Besides calcTextBounds, we need isClipboardPaste and isClipboardCopy which could be customizable
      • Customization discarded. What would it be needed for?
  • Try to unify path handling on widgetFind and widgetNextFocusable
    • This is cancelled fo the moment. I can't find a good reason for doing it.
    • WidgetEnv was added as a parameter for completeness sake
    • This is also needed for widgetUpdateSizeReq and widgetResize
    • Generalize the "startFrom" concept of widgetFind (and also validate it's actually well/fully implemented)
  • Should Resize be restored? -> Restored
  • Make sure enabled/visible attributes are being used
    • This needs modifying WidgetContext (former PathContext) to include visible and enabled attributes
  • Move widgetPath into WidgetInstance (do it in init/merge)
    • Move currentPath into WidgetInstance
    • Move focusedPath and targetPath to WidgetEnv
    • Visible and enabled would get updated on init/merge
  • Format code!
  • Use newtypes whenever possible
  • Make types Lens friendly
    • Use lenses whenever they make the code clearer
    • Use Lenses for Main/Core.hs' updateInputStatus
    • Create Lenses for Graphics/Types.hs
  • Make BaseWidget and BaseContainer use a custom type instead of just Widget. Maybe also rename them?
  • Improve styling options. Handle cases for Normal, Hover, Focused with independent background and border
  • Add support for dashed borders
    • NanoVG does not seem to support this
    • If we ever move to Skia, reconsider
  • Fix ListView keyboard navigation
  • Handle mouse entering/leaving the window
  • Rename policy... to policyW/H
  • Create Checkbox
  • Create Radio
  • Reorganize Drawing (move helpers to bottom)
  • Create Image
  • Add config for Label to choose from: Overflow | Cut (better name?) | Ellipsis
  • DrawStyledBackground should draw borders after widget content
  • Request text input when text field gets focus (required for mobile)
    • Also set TextInputRect
  • Improve textField
    • Add text selection/editing to textField
    • Find non visible character that returns correct height if input is empty
  • Can we generalize widgetFind?
    • To find widgetInstances that need a specific kind of event (entities that need timeStep)
    • Instead of passing Point, pass WidgetQuery ADT. Currently it would support... PointQuery
    • Do we need this?
    • It is implemented in chore/unify-query. I honestly don't think it's an improvement
  • Further textField improvements
    • Handle long text and cursor position
      • Scissor needed?
    • Add support for changing cursor position with mouse click
  • Rethink Image handling
    • Should image component keep a copy around?
    • Should it be provided to renderer every time and, if removed, put back in the list?
    • Otherwise, when graphics memory is exhausted new images will not be added (until the widget is disposed)
  • Rethink the idea of global theme in WidgetEnv
    • Add option to render inner rounded borders with normal outer ones
  • Further textField improvements
    • Add support for validation
    • Add max length limit
    • Add range limit
    • Initialize validators (maybe input is invalid and that needs to be signaled)
  • Think widget config in a similar way to style config (combinator functions)
  • textField should support textFieldV and validInputV
    • Add mandatory event parameter for V constructors
  • Why does the model update when trying to input a char in FloatingInput?
  • Focus event not received after clicking and gaining focus
  • Rethink focus handling. Maybe return a list of all focusable elements? Currently shift-tab is not possible
    • Added a direction parameter to widgetFindNextFocus
  • Think about argument position for widgets, in particular listview/radio
    • Should value come before items/option?
    • Should we use a list of configs instead of <> operator?
  • Add options to label/button (ellipsis/cut)
  • Add support for urls to image widget
  • Add options to image widget (stretch/crop/etc)
    • Check if re-adding image on render should be inside lock
  • Improve spacer
  • Remove Tree
  • Check why image dissapears when model changes (missing merge)
  • Reorganize modules.
    • Common and Widget merged into new Core?
    • Widget.Widgets moved to Widget?
    • WidgetCombinators and StyleCombinators merged into a single Combinators?
    • Create Lens package. BasicTypes lenses should also be there
    • Create separate Util/WidgetUtil (rename Types to WidgetTypes)
    • Simplify imports
    • Create Lens.hs in each module instead of directory
    • Clean up checkbox/radio (fgcolor, etc)
  • Simplify Main.hs by abstracting SDL initialization
  • Add center, right components based on box
  • Validate font exists before using it in NanoVG (crashes otherwise)
    • Also added default font
  • Check if textBounds is enough, or we're missing descending part of font
    • getFullTextSize should be used?
  • Make label use fixed height by default
  • Do not draw non visible items in grid/stack (outside viewport)
    • Apply scissor
  • WidgetRequest for error messages? Probably not worth it
    • Maybe provide a config where a notification/lens can be sent?
  • Fix dropdown issues
    • Show listview in appropriate location (if dropdown is at the bottom, the listView should be up)
    • Implement OnChange/OnChangeReq for listView and dropdown (currently they only implement the Idx versions)
  • Fix issue on scroll. If moved and later expanded, content remains displaced
  • Fix text size/cursor position issue
  • Create Layer widget
  • Add clickOutsideChild in box
  • Create Dialog
    • Receive Title + Message
      • Receive Confirm and Cancel actions
      • Receive Actions and Labels
    • Receive title, body and buttons (actions and labels)
  • Check if there's a 1px error in click handling
    • Seems ok
  • Is overlay not being cleared up? Fixed
  • Review all uses of viewport
  • Add cursor handling
    • Most likely handled as part of style. Discard margins, but consider border + padding
    • Maybe also add an option like SetOverlay
  • Handle findNextFocus in zstack (only consider top layer, unless configured otherwise)
  • Keyboard not working on dropdown
  • Make sure that focus change requests do not leave overlay if active (most likely an if clause is needed in handleFocusChange)
  • Return list of actions instead of Monoid in eventHandler
  • Add way of requesting findNextFocus (needed on Dropdown)
  • Add way of ignoring unassigned events in stack (or return nothing from findByPoint)
  • Update style when merging to avoid recalculating/merging theme every time
  • Use theme for all components
  • Replace uses of Seq.zip with foldlWithIndex
  • Check provided renderArea is used correctly
  • Provided viewport should consider parent viewport
  • Check scroll styling works correctly (contentRect being applied, etc)
    • Also handle hover so scrollbars get correct cursor

• Pending

  • Multiline label
  • Check 1px difference on right side of labels/buttons
  • Check displaced textField when adding characters on right align
    • Also, when right is reached from left, everything is pushed out of screen
  • Add testing
    • Delayed until this point to try to settle down interfaces
    • Validate stack assigns space correctly
    • Use weight to control allocations
    • Refactor modules where consistency is lacking
  • Add header in all files, indicating license and documenting what the module does
  • Add examples
    • Basic event handling (maybe a form with input and button?)
    • Fetch content from url, show rows of data with embedded images
    • Composite example
    • Something of generative art (OpenGL example)
  • Add user documentation

Maybe postponed after release?

• Move combinators out of exported Core (but still export from Monomer)
• Button should receive focus
• Handle window title, maximize, etc
  • Also handle as requests?
• Handle onBlur/onFocus in all focusable widgets
• Maybe unify criteria on zstack? Top layer config for both focus/click?
• Avoid findNextFocus on unfocusable children (listView items)
• Restore focus to previous widget when zstack changes (dialog situation)
  • Also think about not losing focus because of click (when onlyTopFocusable is active)
• Find way of avoiding hover effects when widget is not in the top layer
  • Hover should only be active for top level item
    • I need to think a way of setting a layer state for zstack
• Further textField improvements
  • Double clicking on empty puts the cursor at the end of ghost character
  • Right aligned version has cusor overlaid
  • Handle mouse selection
  • Handle undo history
  • Create numeric wrapper that allows increasing/decreasing with mouse
• Add Maps on Theme to handle user widget settings
• Create Keystroke component (shortcuts and general key handling like Esc for dialog)
• Create Tooltip component. It just wraps a given component and draws the tooltip with renderOverlay
• Create Theme widget to override global theme
• Image widget could also have a ByteString version
• Compare Cairo/Skia interfaces to make Renderer able to handle future implementations
• Can _wiChildren be removed from Widget and only be kept in Container?
• Create Slider
• Create Dial
• Create Split
• Create self rendered version of dropdown and list
• Create File Selector
• Create Color Selector
• Create Layout with width/heights specified in percents
• Consider https://eugenkiss.github.io/7guis/tasks/
• Drag & drop for user (add attribute indicating if component supports being source/target)
  • Add new request types (drag started, drag stopped, drag cancelled)
  • Add new events (drag hover)
  • SDL supports Drag and Drop integration with OS
• Should StyleState be a phantom type?
  • A branch was created and got it working
  • Getting the types working for meant extending that idea to Widget was logical
  • Interfaces got ugly quickly. Need to revisit
• Look for opportunities to reduce code duplication (CompositeWidget and BaseContainer)
• Check if using lifted-async is worth it
• Implement SDL_Surface + Cairo backend
  • Can we cache some drawing operations?
  • Add new request types (drag started, drag stopped, drag cancelled)
  • Add new events (drag hover)
  • SDL supports Drag and Drop integration with OS