Changeset 54436 in webkit


Ignore:
Timestamp:
Feb 5, 2010 11:30:19 AM (14 years ago)
Author:
pfeldman@chromium.org
Message:

2010-02-05 Pavel Feldman <​pfeldman@chromium.org>

Reviewed by Timothy Hatcher.

Web Inspector: simplify cookies view, introduce DataGrid::autoSizeColumns.

​https://bugs.webkit.org/show_bug.cgi?id=34646

  • inspector/front-end/CookieItemsView.js: (WebInspector.CookieItemsView): (WebInspector.CookieItemsView.prototype.show): (WebInspector.CookieItemsView.prototype._update): (WebInspector.CookieItemsView.prototype._updateWithCookies): (WebInspector.CookieItemsView.prototype._filterCookiesForDomain): (WebInspector.CookieItemsView.prototype._createDataGrid): (WebInspector.CookieItemsView.prototype._populateDataGrid.expiresCompare): (WebInspector.CookieItemsView.prototype._populateDataGrid): (WebInspector.CookieItemsView.prototype._createSimpleDataGrid): (WebInspector.CookieItemsView.prototype._populateSimpleDataGrid): (WebInspector.CookieItemsView.prototype._deleteCookieCallback): (WebInspector.CookieItemsView.prototype._refreshButtonClicked):
  • inspector/front-end/DOMStorageItemsView.js: (WebInspector.DOMStorageItemsView.prototype._showDOMStorageEntries): (WebInspector.DOMStorageItemsView.prototype._dataGridForDOMStorageEntries):
  • inspector/front-end/DataGrid.js: (WebInspector.DataGrid): (WebInspector.DataGrid.prototype.autoSizeColumns):
  • inspector/front-end/DatabaseQueryView.js: (WebInspector.DatabaseQueryView.prototype._queryFinished):
  • inspector/front-end/DatabaseTableView.js: (WebInspector.DatabaseTableView.prototype._queryFinished):
  • inspector/front-end/StoragePanel.js: (WebInspector.StoragePanel.prototype.dataGridForResult):
Location:
trunk/WebCore
Files:
7 edited

Legend:

Unmodified
Added
Removed

  • trunk/WebCore/ChangeLog

    r54435 r54436  
     12010-02-05  Pavel Feldman  <pfeldman@chromium.org>
     2
     3        Reviewed by Timothy Hatcher.
     4
     5        Web Inspector: simplify cookies view, introduce DataGrid::autoSizeColumns.
     6
     7        https://bugs.webkit.org/show_bug.cgi?id=34646
     8
     9        * inspector/front-end/CookieItemsView.js:
     10        (WebInspector.CookieItemsView):
     11        (WebInspector.CookieItemsView.prototype.show):
     12        (WebInspector.CookieItemsView.prototype._update):
     13        (WebInspector.CookieItemsView.prototype._updateWithCookies):
     14        (WebInspector.CookieItemsView.prototype._filterCookiesForDomain):
     15        (WebInspector.CookieItemsView.prototype._createDataGrid):
     16        (WebInspector.CookieItemsView.prototype._populateDataGrid.expiresCompare):
     17        (WebInspector.CookieItemsView.prototype._populateDataGrid):
     18        (WebInspector.CookieItemsView.prototype._createSimpleDataGrid):
     19        (WebInspector.CookieItemsView.prototype._populateSimpleDataGrid):
     20        (WebInspector.CookieItemsView.prototype._deleteCookieCallback):
     21        (WebInspector.CookieItemsView.prototype._refreshButtonClicked):
     22        * inspector/front-end/DOMStorageItemsView.js:
     23        (WebInspector.DOMStorageItemsView.prototype._showDOMStorageEntries):
     24        (WebInspector.DOMStorageItemsView.prototype._dataGridForDOMStorageEntries):
     25        * inspector/front-end/DataGrid.js:
     26        (WebInspector.DataGrid):
     27        (WebInspector.DataGrid.prototype.autoSizeColumns):
     28        * inspector/front-end/DatabaseQueryView.js:
     29        (WebInspector.DatabaseQueryView.prototype._queryFinished):
     30        * inspector/front-end/DatabaseTableView.js:
     31        (WebInspector.DatabaseTableView.prototype._queryFinished):
     32        * inspector/front-end/StoragePanel.js:
     33        (WebInspector.StoragePanel.prototype.dataGridForResult):
     34
    1352010-02-04  Pavel Feldman  <pfeldman@chromium.org>
    236

  • trunk/WebCore/inspector/front-end/CookieItemsView.js

    r54435 r54436  
    4444    this._treeElement = treeElement;
    4545    this._cookieDomain = cookieDomain;
     46
     47    this._emptyMsgElement = document.createElement("div");
     48    this._emptyMsgElement.className = "storage-table-empty";
     49    this._emptyMsgElement.textContent = WebInspector.UIString("This site has no cookies.");
     50    this.element.appendChild(this._emptyMsgElement);
    4651}
    4752
    … …  
    5560    {
    5661        WebInspector.View.prototype.show.call(this, parentElement);
    57         this.update();
     62        this._update();
    5863    },
    5964
    … …  
    6469    },
    6570
    66     update: function()
    67     {
    68         this.element.removeChildren();
     71    _update: function()
     72    {
    6973        WebInspector.Cookies.getCookiesAsync(this._updateWithCookies.bind(this));
    7074    },
    … …  
    7276    _updateWithCookies: function(allCookies, isAdvanced)
    7377    {
    74         var cookies = this._cookiesForDomain(allCookies, isAdvanced);
    75         var dataGrid = (isAdvanced ? this.dataGridForCookies(cookies) : this.simpleDataGridForCookies(cookies));
    76         if (dataGrid) {
    77             this._dataGrid = dataGrid;
    78             this.element.appendChild(dataGrid.element);
    79             this._dataGrid.updateWidths();
     78        if (isAdvanced)
     79            this._filterCookiesForDomain(allCookies);
     80        else
     81            this._cookies = allCookies;
     82
     83        if (!this._cookies.length) {
     84            // Nothing to show.
     85            this._emptyMsgElement.removeStyleClass("hidden");
     86            this.deleteButton.visible = false;
     87            if (this._dataGrid)
     88                this._dataGrid.element.addStyleClass("hidden");
     89            return;
     90        }
     91
     92        if (!this._dataGrid) {
     93            if (isAdvanced) {
     94                this._createDataGrid();
     95                this._populateDataGrid();
     96                this._dataGrid.autoSizeColumns(6, 33);
     97                this._treeElement.subtitle = String.sprintf(WebInspector.UIString("%d cookies (%s)"), this._cookies.length,
     98                    Number.bytesToString(this._totalSize, WebInspector.UIString));
     99            } else {
     100                this._createSimpleDataGrid();
     101                this._populateSimpleDataGrid();
     102                this._dataGrid.autoSizeColumns(20, 80);
     103            }
     104        } else {
    80105            if (isAdvanced)
    81                 this.deleteButton.visible = true;
    82         } else {
    83             var emptyMsgElement = document.createElement("div");
    84             emptyMsgElement.className = "storage-table-empty";
    85             emptyMsgElement.textContent = WebInspector.UIString("This site has no cookies.");
    86             this.element.appendChild(emptyMsgElement);
    87             this._dataGrid = null;
    88             this.deleteButton.visible = false;
    89         }
    90     },
    91 
    92     _cookiesForDomain: function(allCookies, isAdvanced)
    93     {
    94         var cookiesForDomain = [];
     106                this._populateDataGrid();
     107            else
     108                this._populateSimpleDataGrid();
     109        }
     110
     111        this._dataGrid.element.removeStyleClass("hidden");
     112        this._emptyMsgElement.addStyleClass("hidden");
     113        if (isAdvanced)
     114            this.deleteButton.visible = true;
     115    },
     116
     117    _filterCookiesForDomain: function(allCookies)
     118    {
     119        this._cookies = [];
    95120        var resourceURLsForDocumentURL = [];
    96         var totalSize = 0;
     121        this._totalSize = 0;
    97122
    98123        for (var id in WebInspector.resources) {
    … …  
    109134                var resourceURL = resourceURLsForDocumentURL[j];
    110135                if (WebInspector.Cookies.cookieMatchesResourceURL(allCookies[i], resourceURL)) {
    111                     totalSize += size;
     136                    this._totalSize += size;
    112137                    if (!pushed) {
    113138                        pushed = true;
    114                         cookiesForDomain.push(allCookies[i]);
     139                        this._cookies.push(allCookies[i]);
    115140                    }
    116141                }
    117142            }
    118143        }
    119 
    120         if (isAdvanced) {
    121             this._treeElement.subtitle = String.sprintf(WebInspector.UIString("%d cookies (%s)"), cookiesForDomain.length,
    122                 Number.bytesToString(totalSize, WebInspector.UIString));
    123         }
    124         return cookiesForDomain;
    125     },
    126 
    127     dataGridForCookies: function(cookies)
    128     {
    129         if (!cookies.length)
    130             return null;
    131 
    132         for (var i = 0; i < cookies.length; ++i)
    133             cookies[i].expires = new Date(cookies[i].expires);
    134 
     144    },
     145
     146    _createDataGrid: function()
     147    {
    135148        var columns = { 0: {}, 1: {}, 2: {}, 3: {}, 4: {}, 5: {}, 6: {}, 7: {} };
    136149        columns[0].title = WebInspector.UIString("Name");
    137         columns[0].width = columns[0].title.length;
    138150        columns[0].sortable = true;
    139151        columns[1].title = WebInspector.UIString("Value");
    140         columns[1].width = columns[1].title.length;
    141152        columns[1].sortable = true;
    142153        columns[2].title = WebInspector.UIString("Domain");
    143         columns[2].width = columns[2].title.length;
    144154        columns[2].sortable = true;
    145155        columns[3].title = WebInspector.UIString("Path");
    146         columns[3].width = columns[3].title.length;
    147156        columns[3].sortable = true;
    148157        columns[4].title = WebInspector.UIString("Expires");
    149         columns[4].width = columns[4].title.length;
    150158        columns[4].sortable = true;
    151159        columns[5].title = WebInspector.UIString("Size");
    152         columns[5].width = columns[5].title.length;
    153160        columns[5].aligned = "right";
    154161        columns[5].sortable = true;
    155162        columns[6].title = WebInspector.UIString("HTTP");
    156         columns[6].width = columns[6].title.length;
    157163        columns[6].aligned = "centered";
    158164        columns[6].sortable = true;
    159165        columns[7].title = WebInspector.UIString("Secure");
    160         columns[7].width = columns[7].title.length;
    161166        columns[7].aligned = "centered";
    162167        columns[7].sortable = true;
    163168
    164         var totalColumnWidths = 0;
    165         for (var columnIdentifier in columns)
    166             totalColumnWidths += columns[columnIdentifier].width;
    167 
    168         // Enforce the Value column (the 2nd column) to be a max of 33%
    169         // tweaking the raw total width because may massively outshadow the others
    170         var valueColumnWidth = columns[1].width;
    171         if (valueColumnWidth / totalColumnWidths > 0.33) {
    172             totalColumnWidths -= valueColumnWidth;
    173             totalColumnWidths *= 1.33;
    174             columns[1].width = totalColumnWidths * 0.33;
    175         }
    176 
    177         // Calculate the percentage width for the columns.
    178         const minimumPrecent = 6;
    179         var recoupPercent = 0;
    180         for (var columnIdentifier in columns) {
    181             var width = columns[columnIdentifier].width;
    182             width = Math.round((width / totalColumnWidths) * 100);
    183             if (width < minimumPrecent) {
    184                 recoupPercent += (minimumPrecent - width);
    185                 width = minimumPrecent;
    186             }
    187             columns[columnIdentifier].width = width;
    188         }
    189 
    190         // Enforce the minimum percentage width. (need to narrow total percentage due to earlier additions)
    191         while (recoupPercent > 0) {
    192             for (var columnIdentifier in columns) {
    193                 if (columns[columnIdentifier].width > minimumPrecent) {
    194                     --columns[columnIdentifier].width;
    195                     --recoupPercent;
    196                     if (!recoupPercent)
    197                         break;
    198                 }
    199             }
    200         }
    201 
    202         for (var columnIdentifier in columns)
    203             columns[columnIdentifier].width += "%";
    204 
    205         var dataGrid = new WebInspector.DataGrid(columns, null, this._deleteCookieCallback.bind(this));
    206         var nodes = this._createNodes(dataGrid, cookies);
    207         for (var i = 0; i < nodes.length; ++i)
    208             dataGrid.appendChild(nodes[i]);
    209         if (nodes.length)
    210             nodes[0].selected = true;
    211         dataGrid.addEventListener("sorting changed", this._sortData.bind(this, dataGrid, cookies));
    212 
    213         return dataGrid;
    214     },
    215 
    216     _createNodes: function(dataGrid, cookies)
    217     {
    218         function updateDataAndColumn(data, index, value) {
    219             data[index] = value;
    220             if (value.length > dataGrid.columns[index].width)
    221                 dataGrid.columns[index].width = value.length;
    222         }
    223 
    224         var nodes = [];
    225         for (var i = 0; i < cookies.length; ++i) {
    226             var data = {};
    227             var cookie = cookies[i];
    228 
    229             updateDataAndColumn(data, 0, cookie.name);
    230             updateDataAndColumn(data, 1, cookie.value);
    231             updateDataAndColumn(data, 2, cookie.domain);
    232             updateDataAndColumn(data, 3, cookie.path);
    233             updateDataAndColumn(data, 4, (cookie.session ? WebInspector.UIString("Session") : cookie.expires.toGMTString()));
    234             updateDataAndColumn(data, 5, Number.bytesToString(cookie.size, WebInspector.UIString));
    235             updateDataAndColumn(data, 6, (cookie.httpOnly ? "\u2713" : "")); // Checkmark
    236             updateDataAndColumn(data, 7, (cookie.secure ? "\u2713" : "")); // Checkmark
    237 
    238             var node = new WebInspector.DataGridNode(data);
    239             node.cookie = cookie;
    240             node.selectable = true;
    241             nodes.push(node);
    242         }
    243         return nodes;
    244     },
    245 
    246     _sortData: function(dataGrid, cookies)
    247     {
    248         var sortDirection = dataGrid.sortOrder === "ascending" ? 1 : -1;
     169        this._dataGrid = new WebInspector.DataGrid(columns, null, this._deleteCookieCallback.bind(this));
     170        this._dataGrid.addEventListener("sorting changed", this._populateDataGrid, this);
     171        this.element.appendChild(this._dataGrid.element);
     172        this._dataGrid.updateWidths();
     173    },
     174
     175    _populateDataGrid: function()
     176    {
     177        var selectedCookie = this._dataGrid.selectedNode ? this._dataGrid.selectedNode.cookie : null;
     178        var sortDirection = this._dataGrid.sortOrder === "ascending" ? 1 : -1;
    249179
    250180        function localeCompare(field, cookie1, cookie2)
    … …  
    266196                return 0;
    267197
    268             return sortDirection * (cookie1.expires.getTime() - cookie2.expires.getTime());
     198            return sortDirection * (cookie1.expires - cookie2.expires);
    269199        }
    270200
    271201        var comparator;
    272         switch (parseInt(dataGrid.sortColumnIdentifier)) {
     202        switch (parseInt(this._dataGrid.sortColumnIdentifier)) {
    273203            case 0: comparator = localeCompare.bind(this, "name"); break;
    274204            case 1: comparator = localeCompare.bind(this, "value"); break;
    … …  
    282212        }
    283213
    284         cookies.sort(comparator);
    285         var nodes = this._createNodes(dataGrid, cookies);
    286 
    287         dataGrid.removeChildren();
    288         for (var i = 0; i < nodes.length; ++i)
    289             dataGrid.appendChild(nodes[i]);
    290 
    291         if (nodes.length)
    292             nodes[0].selected = true;
    293     },
    294 
    295     simpleDataGridForCookies: function(cookies)
    296     {
    297         if (!cookies.length)
    298             return null;
    299 
     214        this._cookies.sort(comparator);
     215
     216        this._dataGrid.removeChildren();
     217        var nodeToSelect;
     218        for (var i = 0; i < this._cookies.length; ++i) {
     219            var data = {};
     220            var cookie = this._cookies[i];
     221            data[0] = cookie.name;
     222            data[1] = cookie.value;
     223            data[2] = cookie.domain;
     224            data[3] = cookie.path;
     225            data[4] = (cookie.session ? WebInspector.UIString("Session") : new Date(cookie.expires).toGMTString());
     226            data[5] = Number.bytesToString(cookie.size, WebInspector.UIString);
     227            data[6] = (cookie.httpOnly ? "\u2713" : ""); // Checkmark
     228            data[7] = (cookie.secure ? "\u2713" : ""); // Checkmark
     229
     230            var node = new WebInspector.DataGridNode(data);
     231            node.cookie = cookie;
     232            node.selectable = true;
     233            this._dataGrid.appendChild(node);
     234            if (cookie === selectedCookie)
     235                nodeToSelect = node;
     236        }
     237        if (nodeToSelect)
     238            nodeToSelect.selected = true;
     239        else
     240            this._dataGrid.children[0].selected = true;
     241    },
     242
     243    _createSimpleDataGrid: function()
     244    {
    300245        var columns = {};
    301246        columns[0] = {};
    302247        columns[1] = {};
    303248        columns[0].title = WebInspector.UIString("Name");
    304         columns[0].width = columns[0].title.length;
    305249        columns[1].title = WebInspector.UIString("Value");
    306         columns[1].width = columns[1].title.length;
    307 
    308         var nodes = [];
     250
     251        this._dataGrid = new WebInspector.DataGrid(columns);
     252        this.element.appendChild(this._dataGrid.element);
     253        this._dataGrid.updateWidths();
     254    },
     255
     256    _populateSimpleDataGrid: function()
     257    {
     258        var cookies = this._cookies;
     259        this._dataGrid.removeChildren();
     260        var addedCookies = {};
    309261        for (var i = 0; i < cookies.length; ++i) {
    310             var cookie = cookies[i];
     262            if (addedCookies[cookies[i].name])
     263                continue;
     264            addedCookies[cookies[i].name] = true;
    311265            var data = {};
    312 
    313             var name = cookie.name;
    314             data[0] = name;
    315             if (name.length > columns[0].width)
    316                 columns[0].width = name.length;
    317 
    318             var value = cookie.value;
    319             data[1] = value;
    320             if (value.length > columns[1].width)
    321                 columns[1].width = value.length;
     266            data[0] = cookies[i].name;
     267            data[1] = cookies[i].value;
    322268
    323269            var node = new WebInspector.DataGridNode(data, false);
    324270            node.selectable = true;
    325             nodes.push(node);
    326         }
    327 
    328         var totalColumnWidths = columns[0].width + columns[1].width;
    329         var width = Math.round((columns[0].width * 100) / totalColumnWidths);
    330         const minimumPrecent = 20;
    331         if (width < minimumPrecent)
    332             width = minimumPrecent;
    333         if (width > 100 - minimumPrecent)
    334             width = 100 - minimumPrecent;
    335         columns[0].width = width;
    336         columns[1].width = 100 - width;
    337         columns[0].width += "%";
    338         columns[1].width += "%";
    339 
    340         var dataGrid = new WebInspector.DataGrid(columns);
    341         var length = nodes.length;
    342         for (var i = 0; i < length; ++i)
    343             dataGrid.appendChild(nodes[i]);
    344         if (length > 0)
    345             nodes[0].selected = true;
    346 
    347         return dataGrid;
    348     },
    349    
     271            this._dataGrid.appendChild(node);
     272        }
     273        this._dataGrid.children[0].selected = true;
     274    },
     275
    350276    resize: function()
    351277    {
    … …  
    361287        this._deleteCookieCallback(this._dataGrid.selectedNode);
    362288    },
    363    
     289
    364290    _deleteCookieCallback: function(node)
    365291    {
    366292        var cookie = node.cookie;
    367293        InspectorBackend.deleteCookie(cookie.name, this._cookieDomain);
    368         this.update();
     294        this._update();
    369295    },
    370296
    371297    _refreshButtonClicked: function(event)
    372298    {
    373         this.update();
     299        this._update();
    374300    }
    375301}

  • trunk/WebCore/inspector/front-end/DOMStorageItemsView.js

    r50613 r54436  
    7070        this._dataGrid = this._dataGridForDOMStorageEntries(entries);
    7171        this.element.appendChild(this._dataGrid.element);
    72         this._dataGrid.updateWidths();
     72        this._dataGrid.autoSizeColumns(10);
    7373        this.deleteButton.visible = true;
    7474    },
    … …  
    8686        columns[1] = {};
    8787        columns[0].title = WebInspector.UIString("Key");
    88         columns[0].width = columns[0].title.length;
    8988        columns[1].title = WebInspector.UIString("Value");
    90         columns[1].width = columns[1].title.length;
    9189
    9290        var nodes = [];
    … …  
    9997            var key = entries[i][0];
    10098            data[0] = key;
    101             if (key.length > columns[0].width)
    102                 columns[0].width = key.length;
    103 
    10499            var value = entries[i][1];
    105100            data[1] = value;
    106             if (value.length > columns[1].width)
    107                 columns[1].width = value.length;
    108101            var node = new WebInspector.DataGridNode(data, false);
    109102            node.selectable = true;
    … …  
    111104            keys.push(key);
    112105        }
    113 
    114         var totalColumnWidths = columns[0].width + columns[1].width;
    115         var width = Math.round((columns[0].width * 100) / totalColumnWidths);
    116         const minimumPrecent = 10;
    117         if (width < minimumPrecent)
    118             width = minimumPrecent;
    119         if (width > 100 - minimumPrecent)
    120             width = 100 - minimumPrecent;
    121         columns[0].width = width;
    122         columns[1].width = 100 - width;
    123         columns[0].width += "%";
    124         columns[1].width += "%";
    125106
    126107        var dataGrid = new WebInspector.DataGrid(columns, this._editingCallback.bind(this), this._deleteCallback.bind(this));

  • trunk/WebCore/inspector/front-end/DataGrid.js

    r52165 r54436  
    6262    var headerRow = document.createElement("tr");
    6363    var columnGroup = document.createElement("colgroup");
    64     var columnCount = 0;
     64    this._columnCount = 0;
    6565
    6666    for (var columnIdentifier in columns) {
    … …  
    7272        if (column.width)
    7373            col.style.width = column.width;
     74        column.element = col;
    7475        columnGroup.appendChild(col);
    7576
    … …  
    99100        headerRow.appendChild(cell);
    100101
    101         ++columnCount;
     102        ++this._columnCount;
    102103    }
    103104
    104     columnGroup.span = columnCount;
     105    columnGroup.span = this._columnCount;
    105106
    106107    var cell = document.createElement("th");
    … …  
    115116    fillerRow.className = "filler";
    116117
    117     for (var i = 0; i < columnCount; ++i) {
     118    for (var i = 0; i < this._columnCount; ++i) {
    118119        var cell = document.createElement("td");
    119120        fillerRow.appendChild(cell);
    … …  
    293294        return this._dataTableBody;
    294295    },
    295  
     296
     297    autoSizeColumns: function(minPercent, maxPercent)
     298    {
     299        if (minPercent)
     300            minPercent = Math.min(minPercent, Math.floor(100 / this._columnCount));
     301        var widths = {};
     302        var columns = this.columns;
     303        for (var columnIdentifier in columns)
     304            widths[columnIdentifier] = (columns[columnIdentifier].title || "").length;
     305
     306        for (var i = 0; i < this.children.length; ++i) {
     307            var node = this.children[i];
     308            for (var columnIdentifier in columns) {
     309                var text = node.data[columnIdentifier] || "";
     310                if (text.length > widths[columnIdentifier])
     311                    widths[columnIdentifier] = text.length;
     312            }
     313        }
     314
     315        var totalColumnWidths = 0;
     316        for (var columnIdentifier in columns)
     317            totalColumnWidths += widths[columnIdentifier];
     318
     319        var recoupPercent = 0;
     320        for (var columnIdentifier in columns) {
     321            var width = Math.round(100 * widths[columnIdentifier] / totalColumnWidths);
     322            if (minPercent && width < minPercent) {
     323                recoupPercent += (minPercent - width);
     324                width = minPercent;
     325            } else if (maxPercent && width > maxPercent) {
     326                recoupPercent -= (width - maxPercent);
     327                width = maxPercent;
     328            }
     329            widths[columnIdentifier] = width;
     330        }
     331
     332        while (minPercent && recoupPercent > 0) {
     333            for (var columnIdentifier in columns) {
     334                if (widths[columnIdentifier] > minPercent) {
     335                    --widths[columnIdentifier];
     336                    --recoupPercent;
     337                    if (!recoupPercent)
     338                        break;
     339                }
     340            }
     341        }
     342
     343        while (maxPercent && recoupPercent < 0) {
     344            for (var columnIdentifier in columns) {
     345                if (widths[columnIdentifier] < maxPercent) {
     346                    ++widths[columnIdentifier];
     347                    ++recoupPercent;
     348                    if (!recoupPercent)
     349                        break;
     350                }
     351            }
     352        }
     353
     354        for (var columnIdentifier in columns)
     355            columns[columnIdentifier].element.style.width = widths[columnIdentifier] + "%";
     356        this.columnWidthsInitialized = false;
     357        this.updateWidths();
     358    },
     359
    296360    // Updates the widths of the table, including the positions of the column
    297361    // resizers.

  • trunk/WebCore/inspector/front-end/DatabaseQueryView.js

    r54001 r54436  
    145145        dataGrid.element.addStyleClass("inline");
    146146        this._appendQueryResult(query, dataGrid.element);
     147        dataGrid.autoSizeColumns(5);
    147148
    148149        if (query.match(/^create /i) || query.match(/^drop table /i))

  • trunk/WebCore/inspector/front-end/DatabaseTableView.js

    r47960 r54436  
    6969
    7070        this.element.appendChild(dataGrid.element);
     71        dataGrid.autoSizeColumns(5);
    7172    },
    7273

  • trunk/WebCore/inspector/front-end/StoragePanel.js

    r54435 r54436  
    301301
    302302            var row = rows[i];
    303             for (var columnIdentifier in row) {
    304                 var text = row[columnIdentifier];
    305                 data[columnIdentifier] = text;
    306                 if (text.length > columns[columnIdentifier].width)
    307                     columns[columnIdentifier].width = text.length;
    308             }
     303            for (var columnIdentifier in row)
     304                data[columnIdentifier] = row[columnIdentifier];
    309305
    310306            var node = new WebInspector.DataGridNode(data, false);
    … …  
    312308            nodes.push(node);
    313309        }
    314 
    315         var totalColumnWidths = 0;
    316         for (var columnIdentifier in columns)
    317             totalColumnWidths += columns[columnIdentifier].width;
    318 
    319         // Calculate the percentage width for the columns.
    320         const minimumPrecent = Math.min(5, Math.floor(100/numColumns));
    321         var recoupPercent = 0;
    322         for (var columnIdentifier in columns) {
    323             var width = columns[columnIdentifier].width;
    324             width = Math.round((width / totalColumnWidths) * 100);
    325             if (width < minimumPrecent) {
    326                 recoupPercent += (minimumPrecent - width);
    327                 width = minimumPrecent;
    328             }
    329 
    330             columns[columnIdentifier].width = width;
    331         }
    332 
    333         // Enforce the minimum percentage width.
    334         while (recoupPercent > 0) {
    335             for (var columnIdentifier in columns) {
    336                 if (columns[columnIdentifier].width > minimumPrecent) {
    337                     --columns[columnIdentifier].width;
    338                     --recoupPercent;
    339                     if (!recoupPercent)
    340                         break;
    341                 }
    342             }
    343         }
    344 
    345         // Change the width property to a string suitable for a style width.
    346         for (var columnIdentifier in columns)
    347             columns[columnIdentifier].width += "%";
    348310
    349311        var dataGrid = new WebInspector.DataGrid(columns);
Note: See TracChangeset for help on using the changeset viewer.