all files / ui/ Toolbox.js

0% Statements 0/30
0% Branches 0/8
0% Functions 0/12
0% Lines 0/29
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130                                                                                                                                                                                                                                                                   
import Component from './Component'
 
class Toolbox extends Component {
 
  getInitialState() {
    return {
      activeToolGroups: this.getActiveToolGroups()
    }
  }
 
  // NOTE: We disable this, as its premature optimization and can cause
  // side effects. Rendering the toolbox always is not a big performance
  // issue atm.
  // shouldRerender(newProps, newState) {
  //   // poor-man's immutable style
  //   let hasChanged = !isEqual(this.props, newProps) || !isEqual(this.state.activeToolGroups, newState.activeToolGroups)
  //
  //   if (!hasChanged) {
  //     this.hide()
  //     return false
  //   }
  //   return true
  // }
 
  didMount() {
    // rerender the context menu after anything else has been updated
    this.context.editorSession.onRender(this._onCommandStatesChanged, this)
  }
 
  dispose() {
    this.context.editorSession.off(this)
  }
 
  _onCommandStatesChanged(editorSession) {
    if (editorSession.hasChanged('commandStates')) {
      this.setState({
        activeToolGroups: this.getActiveToolGroups()
      })
    }
  }
 
  /*
    Returns A map of tooltargets, the value being an array of tool objects
    containing Class and toolProps for rendering
  */
  getActiveToolGroups() {
    this._hasActiveTools = false
 
    let toolGroups = this.context.toolGroups
    let activeToolGroupNames = this.getActiveToolGroupNames()
    let activeToolGroups = new Map()
 
    activeToolGroupNames.forEach((toolGroupName) => {
      let toolGroup = toolGroups.get(toolGroupName)
      if (!toolGroup) return
      let tools = toolGroup.tools
      let activeTools = this.getActiveTools(tools, toolGroupName)
      activeToolGroups.set(toolGroupName, {
        name: toolGroupName,
        Class: toolGroup.Class,
        tools: activeTools
      })
    })
    return activeToolGroups
  }
 
  /*
    For a given Map of tools and a toolGroupName determine
    a set of activeTools, based on the current commandStates
  */
  getActiveTools(tools, toolGroupName) { // eslint-disable-line
    let activeTools = new Map()
    let commandStates = this._getCommandStates()
 
    tools.forEach((tool, toolName) => {
      let toolProps = Object.assign(
        { disabled: true },
        commandStates[toolName],
        {
          name: toolName,
          label: toolName,
          // style hint only interprerted by generic Tool class
          style: this.getToolStyle(toolName)
        }
      )
 
      if (!toolProps.disabled || this.showDisabled()) {
        activeTools.set(tool.name, {
          name: tool.name,
          Class: tool.Class,
          toolProps: toolProps
        })
        this._hasActiveTools = true
      }
    })
 
    return activeTools
  }
 
  hasActiveTools() {
    return Boolean(this._hasActiveTools)
  }
 
  getActiveToolGroupNames() {
    throw new Error('Abstract method')
  }
 
  showDisabled() {
    return false
  }
 
  hide() {
    // Optional hook for hiding the toolbox component
  }
 
  /*
    Override if you just want to use a different style
  */
  getToolStyle() {
    throw new Error('Abstract method')
  }
 
  _getCommandStates() {
    return this.context.commandManager.getCommandStates()
  }
 
}
 
export default Toolbox