summaryrefslogtreecommitdiffstats
path: root/devtools/client/shared/components/tree/TreeHeader.js
blob: 8c6340f0794d5d8dbcc94dd6c76298bdf5d572f7 (plain)
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
/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
"use strict";

// Make this available to both AMD and CJS environments
define(function(require, exports, module) {
  const { Component } = require("devtools/client/shared/vendor/react");
  const PropTypes = require("devtools/client/shared/vendor/react-prop-types");
  const dom = require("devtools/client/shared/vendor/react-dom-factories");
  const { thead, tr, td, div } = dom;

  /**
   * This component is responsible for rendering tree header.
   * It's based on <thead> element.
   */
  class TreeHeader extends Component {
    // See also TreeView component for detailed info about properties.
    static get propTypes() {
      return {
        // Custom tree decorator
        decorator: PropTypes.object,
        // True if the header should be visible
        header: PropTypes.bool,
        // Array with column definition
        columns: PropTypes.array,
      };
    }

    static get defaultProps() {
      return {
        columns: [
          {
            id: "default",
          },
        ],
      };
    }

    constructor(props) {
      super(props);
      this.getHeaderClass = this.getHeaderClass.bind(this);
    }

    getHeaderClass(colId) {
      const decorator = this.props.decorator;
      if (!decorator || !decorator.getHeaderClass) {
        return [];
      }

      // Decorator can return a simple string or array of strings.
      let classNames = decorator.getHeaderClass(colId);
      if (!classNames) {
        return [];
      }

      if (typeof classNames == "string") {
        classNames = [classNames];
      }

      return classNames;
    }

    render() {
      const cells = [];
      const visible = this.props.header;

      // Render the rest of the columns (if any)
      this.props.columns.forEach(col => {
        const cellStyle = {
          width: col.width ? col.width : "",
        };

        let classNames = [];

        if (visible) {
          classNames = this.getHeaderClass(col.id);
          classNames.push("treeHeaderCell");
        }

        cells.push(
          td(
            {
              className: classNames.join(" "),
              style: cellStyle,
              role: "presentation",
              id: col.id,
              key: col.id,
            },
            visible
              ? div(
                  {
                    className: "treeHeaderCellBox",
                    role: "presentation",
                  },
                  col.title
                )
              : null
          )
        );
      });

      return thead(
        {
          role: "presentation",
        },
        tr(
          {
            className: visible ? "treeHeaderRow" : "",
            role: "presentation",
          },
          cells
        )
      );
    }
  }

  // Exports from this module
  module.exports = TreeHeader;
});