Implements a filmstrip-only mode for the toolbox

css/_toolbars.scss

     vertical-align: middle;
 }
 
-/**
-* Toolbar button styles.
-*/
+ /**
+  * Toolbar button styles.
+  */
 .button {
     color: #FFFFFF;
     cursor: pointer;
 }
 
 /**
-* Common toolbar styles.
-*/
+ * Common toolbar styles.
+ */
 .toolbar {
     background-color: $toolbarBackground;
     height: 100%;
     }
 
     /**
-    * Primary toolbar styles.
-    */
+     * Primary toolbar styles.
+     */
     &_primary {
         position: absolute;
         left: 50%;
     }
 
     /**
-    * Secondary toolbar styles.
-    */
+     * Secondary toolbar styles.
+     */
     &_secondary {
         position: absolute;
         align-items: center;
         }
     }
 
+    /**
+     * Styles the toolbar in filmstrip-only mode.
+     */
+    &_filmstrip-only {
+        border-radius: 3px;
+        bottom: 0;
+        display: inline-block;
+        height: auto;
+        position: absolute;
+        right: 0;
+        width: $defaultToolbarSize;
+
+        .button:first-child {
+            border-top-left-radius: 3px;
+            border-top-right-radius: 3px;
+        }
+        .button:last-child {
+            border-bottom-right-radius: 3px;
+            border-bottom-left-radius: 3px;
+        }
+    }
+
     /**
      * Toolbar specific round badge.
      */

react/features/toolbox/actions.web.js

  */
 export function showToolbox(timeout: number = 0): Object {
     return (dispatch: Dispatch<*>, getState: Function) => {
-        if (interfaceConfig.filmStripOnly) {
-            return;
-        }
-
         const state = getState();
-        const { timeoutMS, visible } = state['features/toolbox'];
+        const { alwaysVisible, timeoutMS, visible } = state['features/toolbox'];
 
         if (!visible) {
             dispatch(setToolboxVisible(true));
             dispatch(setSubjectSlideIn(true));
-            dispatch(
-                setToolboxTimeout(
-                    () => dispatch(hideToolbox()),
-                    timeout || timeoutMS));
-            dispatch(setToolboxTimeoutMS(interfaceConfig.TOOLBAR_TIMEOUT));
+
+            // If the Toolbox is always visible, there's no need for a timeout
+            // to toggle its visibility.
+            if (!alwaysVisible) {
+                dispatch(
+                    setToolboxTimeout(
+                        () => dispatch(hideToolbox()),
+                        timeout || timeoutMS));
+                dispatch(setToolboxTimeoutMS(interfaceConfig.TOOLBAR_TIMEOUT));
+            }
         }
     };
 }

react/features/toolbox/components/PrimaryToolbar.web.js

      *
      * @returns {ReactElement}
      */
-    render() {
-        const { buttonHandlers, splitterIndex } = this.state;
+    render(): ReactElement<*> | null {
         const { _primaryToolbarButtons } = this.props;
+
+        // The number of buttons to show in the toolbar isn't fixed, it depends
+        // on availability of features and configuration parameters, so if we
+        // don't have anything to render we exit here.
+        if (_primaryToolbarButtons.size === 0) {
+            return null;
+        }
+
+        const { buttonHandlers, splitterIndex } = this.state;
         const { primaryToolbarClassName } = getToolbarClassNames(this.props);
 
         return (

react/features/toolbox/components/SecondaryToolbar.web.js

      *
      * @returns {ReactElement}
      */
-    render(): ReactElement<*> {
-        const { buttonHandlers } = this.state;
+    render(): ReactElement<*> | null {
         const { _secondaryToolbarButtons } = this.props;
+
+        // The number of buttons to show in the toolbar isn't fixed, it depends
+        // on availability of features and configuration parameters, so if we
+        // don't have anything to render we exit here.
+        if (_secondaryToolbarButtons.size === 0) {
+            return null;
+        }
+
+        const { buttonHandlers } = this.state;
         const { secondaryToolbarClassName } = getToolbarClassNames(this.props);
 
         return (

react/features/toolbox/components/Toolbar.web.js

 } from '../actions';
 import ToolbarButton from './ToolbarButton';
 
-declare var APP: Object;
-declare var config: Object;
-declare var interfaceConfig: Object;
-
 /**
  * Implements a toolbar in React/Web. It is a strip that contains a set of
  * toolbar items such as buttons. Toolbar is commonly placed inside of a
             toolbarButtons
         } = this.props;
 
+        // Only a few buttons have custom button handlers defined, so this
+        // list may be undefined or empty depending on the buttons we're
+        // rendering.
+        // TODO: merge the buttonHandlers and onClick properties and come up
+        // with a consistent event handling property.
+        if (!buttonHandlers) {
+            return;
+        }
+
         Object.keys(buttonHandlers).forEach(key => {
             let button = toolbarButtons.get(key);
 

react/features/toolbox/components/Toolbox.web.js

      * @static
      */
     static propTypes = {
+        /**
+         * Indicates if the toolbox should always be visible.
+         */
+        _alwaysVisible: React.PropTypes.bool,
+
         /**
          * Handler dispatching setting default buttons action.
          */
      * @private
      */
     _renderToolbars(): ReactElement<*> | null {
-        // The toolbars should not be shown until timeoutID is initialized.
-        if (this.props._timeoutID === null) {
+        // In case we're not in alwaysVisible mode the toolbox should not be
+        // shown until timeoutID is initialized.
+        if (!this.props._alwaysVisible && this.props._timeoutID === null) {
             return null;
         }
 
          * @returns {Object} Dispatched action.
          */
         _setToolboxAlwaysVisible() {
-            dispatch(
-                setToolboxAlwaysVisible(config.alwaysVisibleToolbar === true));
+            dispatch(setToolboxAlwaysVisible(
+                config.alwaysVisibleToolbar === true
+                    || interfaceConfig.filmStripOnly));
         }
     };
 }
  * @param {Object} state - Redux state.
  * @private
  * @returns {{
+ *     _alwaysVisible: boolean,
  *     _audioMuted: boolean,
  *     _locked: boolean,
  *     _subjectSlideIn: boolean,
  */
 function _mapStateToProps(state: Object): Object {
     const {
+        alwaysVisible,
         subject,
         subjectSlideIn,
         timeoutID
     return {
         ...abstractMapStateToProps(state),
 
+        /**
+         * Indicates if the toolbox should always be visible.
+         *
+         * @private
+         * @type {boolean}
+         */
+        _alwaysVisible: alwaysVisible,
+
         /**
          * Property containing conference subject.
          *
-         * @protected
+         * @private
          * @type {string}
          */
         _subject: subject,
         /**
          * Flag showing whether to set subject slide in animation.
          *
-         * @protected
+         * @private
          * @type {boolean}
          */
         _subjectSlideIn: subjectSlideIn,
         /**
          * Property containing toolbox timeout id.
          *
-         * @protected
+         * @private
          * @type {number}
          */
         _timeoutID: timeoutID

react/features/toolbox/defaultToolbarButtons.js

     camera: {
         classNames: [ 'button', 'icon-camera' ],
         enabled: true,
+        filmstripOnlyEnabled: true,
         id: 'toolbar_button_camera',
         onClick() {
             if (APP.conference.videoMuted) {
     hangup: {
         classNames: [ 'button', 'icon-hangup', 'button_hangup' ],
         enabled: true,
+        filmstripOnlyEnabled: true,
         id: 'toolbar_button_hangup',
         onClick() {
             JitsiMeetJS.analytics.sendEvent('toolbar.hangup');
     microphone: {
         classNames: [ 'button', 'icon-microphone' ],
         enabled: true,
+        filmstripOnlyEnabled: true,
         id: 'toolbar_button_mute',
         onClick() {
             const sharedVideoManager = APP.UI.getSharedVideoManager();

react/features/toolbox/functions.js

 
     if (typeof interfaceConfig !== 'undefined'
             && interfaceConfig.TOOLBAR_BUTTONS) {
+        const { filmStripOnly } = interfaceConfig;
+
         toolbarButtons
             = interfaceConfig.TOOLBAR_BUTTONS.reduce(
                 (acc, buttonName) => {
                         const place = _getToolbarButtonPlace(buttonName);
 
                         button.buttonName = buttonName;
-                        acc[place].set(buttonName, button);
+
+                        // In filmstrip-only mode we only add a button if it's
+                        // filmstrip-only enabled.
+                        if (!filmStripOnly || button.filmstripOnlyEnabled) {
+                            acc[place].set(buttonName, button);
+                        }
                     }
 
                     return acc;
  * @private
  */
 export function getToolbarClassNames(props: Object) {
-    const primaryToolbarClassNames = [ 'toolbar_primary' ];
+    const primaryToolbarClassNames = [
+        interfaceConfig.filmStripOnly
+            ? 'toolbar_filmstrip-only'
+            : 'toolbar_primary'
+    ];
     const secondaryToolbarClassNames = [ 'toolbar_secondary' ];
 
     if (props._visible) {

react/features/toolbox/reducer.js

         ...button
     };
 
+    // In filmstrip-only mode we only show buttons if they're filmstrip-only
+    // enabled, so we don't need to update if this isn't the case.
+    // FIXME A reducer should be a pure function of the current state and the
+    // specified action so it should not use the global variable
+    // interfaceConfig. Anyway, we'll move interfaceConfig into the (redux)
+    // store so we'll surely revisit the source code bellow.
+    if (interfaceConfig.filmStripOnly && !selectedButton.filmstripOnlyEnabled) {
+        return {
+            ...state
+        };
+    }
+
     const updatedToolbar = state[place].set(buttonName, selectedButton);
 
     return {