Changeset 96591 in webkit


Ignore:
Timestamp:
Oct 4, 2011 7:23:24 AM (13 years ago)
Author:
pfeldman@chromium.org
Message:

Web Inspector: make DataGrid compile
​https://bugs.webkit.org/show_bug.cgi?id=69334

Patch by Pavel Feldman <​pfeldman@chromium.org> on 2011-10-04
Reviewed by Yury Semikhatsky.

  • inspector/compile-front-end.sh:
  • inspector/front-end/DataGrid.js:

(WebInspector.DataGrid):
(WebInspector.DataGrid.prototype._startEditingColumnOfDataGridNode):
(WebInspector.DataGrid.prototype._startEditing):
(WebInspector.DataGrid.prototype._startEditingConfig):
(WebInspector.DataGrid.prototype._editingCommitted.moveToNextIfNeeded):
(WebInspector.DataGrid.prototype._editingCommitted):
(WebInspector.DataGrid.prototype._editingCancelled):
(WebInspector.DataGrid.prototype.removeChildrenRecursive):
(WebInspector.DataGrid.prototype._keyDown):
(WebInspector.DataGrid.prototype._startResizerDragging):
(WebInspector.DataGrid.prototype._resizerDragging):
(WebInspector.DataGrid.prototype._endResizerDragging):
(WebInspector.DataGridNode.prototype._attach):

  • inspector/front-end/UIUtils.js:

(WebInspector.isBeingEdited):
(WebInspector.markBeingEdited):
(WebInspector.isEditingAnyField):
(WebInspector.EditingConfig):
(WebInspector.startEditing.blurEventListener):
(WebInspector.startEditing.getContent):
(WebInspector.startEditing.cleanUpAfterEditing):
(WebInspector.startEditing.editingCancelled):
(WebInspector.startEditing.editingCommitted):
(WebInspector.startEditing.defaultFinishHandler):
(WebInspector.startEditing):
(WebInspector.startEditing.pasteEventListener):
(WebInspector.startEditing.keyDownEventListener):

  • inspector/front-end/externs.js:

(Array.prototype.remove):
(window.getComputedStyle):

  • inspector/front-end/inspector.js:
Location:
trunk/Source/WebCore
Files:
6 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r96589 r96591  
     12011-10-04  Pavel Feldman  <pfeldman@chromium.org>
     2
     3        Web Inspector: make DataGrid compile
     4        https://bugs.webkit.org/show_bug.cgi?id=69334
     5
     6        Reviewed by Yury Semikhatsky.
     7
     8        * inspector/compile-front-end.sh:
     9        * inspector/front-end/DataGrid.js:
     10        (WebInspector.DataGrid):
     11        (WebInspector.DataGrid.prototype._startEditingColumnOfDataGridNode):
     12        (WebInspector.DataGrid.prototype._startEditing):
     13        (WebInspector.DataGrid.prototype._startEditingConfig):
     14        (WebInspector.DataGrid.prototype._editingCommitted.moveToNextIfNeeded):
     15        (WebInspector.DataGrid.prototype._editingCommitted):
     16        (WebInspector.DataGrid.prototype._editingCancelled):
     17        (WebInspector.DataGrid.prototype.removeChildrenRecursive):
     18        (WebInspector.DataGrid.prototype._keyDown):
     19        (WebInspector.DataGrid.prototype._startResizerDragging):
     20        (WebInspector.DataGrid.prototype._resizerDragging):
     21        (WebInspector.DataGrid.prototype._endResizerDragging):
     22        (WebInspector.DataGridNode.prototype._attach):
     23        * inspector/front-end/UIUtils.js:
     24        (WebInspector.isBeingEdited):
     25        (WebInspector.markBeingEdited):
     26        (WebInspector.isEditingAnyField):
     27        (WebInspector.EditingConfig):
     28        (WebInspector.startEditing.blurEventListener):
     29        (WebInspector.startEditing.getContent):
     30        (WebInspector.startEditing.cleanUpAfterEditing):
     31        (WebInspector.startEditing.editingCancelled):
     32        (WebInspector.startEditing.editingCommitted):
     33        (WebInspector.startEditing.defaultFinishHandler):
     34        (WebInspector.startEditing):
     35        (WebInspector.startEditing.pasteEventListener):
     36        (WebInspector.startEditing.keyDownEventListener):
     37        * inspector/front-end/externs.js:
     38        (Array.prototype.remove):
     39        (window.getComputedStyle):
     40        * inspector/front-end/inspector.js:
     41
    1422011-10-04  Andrey Kosyakov  <caseq@chromium.org>
    243

  • trunk/Source/WebCore/inspector/compile-front-end.sh

    r96588 r96591  
    6464        --js Source/WebCore/inspector/front-end/NetworkManager.js \
    6565        --js Source/WebCore/inspector/front-end/UISourceCode.js \
    66     --module jsmodule_ui:21:jsmodule_common \
     66    --module jsmodule_ui:22:jsmodule_common \
    6767        --js Source/WebCore/inspector/front-end/Checkbox.js \
    6868        --js Source/WebCore/inspector/front-end/ContextMenu.js \
     69        --js Source/WebCore/inspector/front-end/DataGrid.js \
    6970        --js Source/WebCore/inspector/front-end/Drawer.js \
    7071        --js Source/WebCore/inspector/front-end/EmptyView.js \

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

    r94754 r96591  
    2424 */
    2525
     26/**
     27 * @constructor
     28 * @extends {WebInspector.Object}
     29 */
    2630WebInspector.DataGrid = function(columns, editCallback, deleteCallback)
    2731{
    … …  
    121125    for (var columnIdentifier in columns) {
    122126        var column = columns[columnIdentifier];
    123         var cell = document.createElement("td");
    124         cell.className = columnIdentifier + "-column";
    125         fillerRow.appendChild(cell);
     127        var td = document.createElement("td");
     128        td.className = columnIdentifier + "-column";
     129        fillerRow.appendChild(td);
    126130    }
    127131
    … …  
    181185
    182186        var element = this._editingNode._element.children[column];
    183         WebInspector.startEditing(element, {
    184             context: element.textContent,
    185             commitHandler: this._editingCommitted.bind(this),
    186             cancelHandler: this._editingCancelled.bind(this)
    187         });
     187        WebInspector.startEditing(element, this._startEditingConfig(element));
    188188        window.getSelection().setBaseAndExtent(element, 0, element, 1);
    189189    },
    … …  
    207207
    208208        this._editing = true;
    209         WebInspector.startEditing(element, {
    210             context: element.textContent,
    211             commitHandler: this._editingCommitted.bind(this),
    212             cancelHandler: this._editingCancelled.bind(this)
    213         });
     209        WebInspector.startEditing(element, this._startEditingConfig(element));
     210
    214211        window.getSelection().setBaseAndExtent(element, 0, element, 1);
     212    },
     213
     214
     215    _startEditingConfig: function(element)
     216    {
     217        var config = new WebInspector.EditingConfig();
     218        config.setContext(element.textContent);
     219        config.setCommitHandler(this._editingCommitted.bind(this));
     220        config.setCancelHandler(this._editingCancelled.bind(this));
     221        return config;
    215222    },
    216223
    … …  
    221228
    222229        // FIXME: Better way to do this than regular expressions?
    223         var columnIdentifier = parseInt(element.className.match(/\b(\d+)-column\b/)[1]);
     230        var columnIdentifier = parseInt(element.className.match(/\b(\d+)-column\b/)[1], 10);
    224231
    225232        var textBeforeEditing = this._editingNode.data[columnIdentifier];
    … …  
    241248                    return this._startEditingColumnOfDataGridNode(nextDataGridNode, 0);
    242249                if (currentEditingNode.isCreationNode && wasChange) {
    243                     addCreationNode(false);
     250                    this.addCreationNode(false);
    244251                    return this._startEditingColumnOfDataGridNode(this.creationNode, 0);
    245252                }
    … …  
    278285    },
    279286
    280     _editingCancelled: function(element, context)
     287    _editingCancelled: function(element)
    281288    {
    282289        delete this._editing;
    … …  
    673680
    674681        for (var i = 0; i < childrenToRemove.length; ++i) {
    675             var child = childrenToRemove[i];
     682            child = childrenToRemove[i];
    676683            child.deselect();
    677684            child._detach();
    … …  
    740747            nextSelectedNode = this.selectedNode.traversePreviousNode(true);
    741748            while (nextSelectedNode && !nextSelectedNode.selectable)
    742                 nextSelectedNode = nextSelectedNode.traversePreviousNode(!this.expandTreeNodesWhenArrowing);
     749                nextSelectedNode = nextSelectedNode.traversePreviousNode(true);
    743750            handled = nextSelectedNode ? true : false;
    744751        } else if (event.keyIdentifier === "Down" && !event.altKey) {
    745752            nextSelectedNode = this.selectedNode.traverseNextNode(true);
    746753            while (nextSelectedNode && !nextSelectedNode.selectable)
    747                 nextSelectedNode = nextSelectedNode.traverseNextNode(!this.expandTreeNodesWhenArrowing);
     754                nextSelectedNode = nextSelectedNode.traverseNextNode(true);
    748755            handled = nextSelectedNode ? true : false;
    749756        } else if (event.keyIdentifier === "Left") {
    … …  
    951958    _startResizerDragging: function(event)
    952959    {
    953         this.currentResizer = event.target;
    954         if (!this.currentResizer.rightNeighboringColumnID)
    955             return;
    956         WebInspector.elementDragStart(this.lastResizer, this._resizerDragging.bind(this),
     960        this._currentResizer = event.target;
     961        if (!this._currentResizer.rightNeighboringColumnID)
     962            return;
     963        WebInspector.elementDragStart(this._currentResizer, this._resizerDragging.bind(this),
    957964            this._endResizerDragging.bind(this), event, "col-resize");
    958965    },
    … …  
    960967    _resizerDragging: function(event)
    961968    {
    962         var resizer = this.currentResizer;
     969        var resizer = this._currentResizer;
    963970        if (!resizer)
    964971            return;
    … …  
    10101017    {
    10111018        WebInspector.elementDragEnd(event);
    1012         this.currentResizer = null;
     1019        this._currentResizer = null;
    10131020        this.dispatchEventToListeners("width changed");
    10141021    },
    … …  
    10271034WebInspector.DataGrid.prototype.__proto__ = WebInspector.Object.prototype;
    10281035
     1036/**
     1037 * @constructor
     1038 * @extends {WebInspector.Object}
     1039 */
    10291040WebInspector.DataGridNode = function(data, hasChildren)
    10301041{
    … …  
    13431354    },
    13441355
     1356    /**
     1357     * @param {boolean=} supressSelectedEvent
     1358     */
    13451359    select: function(supressSelectedEvent)
    13461360    {
    … …  
    13671381    },
    13681382
     1383    /**
     1384     * @param {boolean=} supressDeselectedEvent
     1385     */
    13691386    deselect: function(supressDeselectedEvent)
    13701387    {
    … …  
    14601477        var previousNode = this.traversePreviousNode(true, true);
    14611478        if (previousNode && previousNode.element.parentNode && previousNode.element.nextSibling)
    1462             var nextNode = previousNode.element.nextSibling;
     1479            nextNode = previousNode.element.nextSibling;
    14631480        if (!nextNode)
    14641481            nextNode = this.dataGrid.dataTableBody.lastChild;
    … …  
    15111528WebInspector.DataGridNode.prototype.__proto__ = WebInspector.Object.prototype;
    15121529
     1530/**
     1531 * @constructor
     1532 * @extends {WebInspector.DataGridNode}
     1533 */
    15131534WebInspector.CreationDataGridNode = function(data, hasChildren)
    15141535{

  • trunk/Source/WebCore/inspector/front-end/UIUtils.js

    r96584 r96591  
    166166}
    167167
     168WebInspector.isBeingEdited = function(element)
     169{
     170    return element.__editing;
     171}
     172
     173WebInspector.markBeingEdited = function(element, value)
     174{
     175    if (value) {
     176        if (element.__editing)
     177            return false;
     178        element.__editing = true;
     179        WebInspector.__editingCount = (WebInspector.__editingCount || 0) + 1;
     180    } else {
     181        if (!element.__editing)
     182            return false;
     183        delete element.__editing;
     184        --WebInspector.__editingCount;
     185    }
     186    return true;
     187}
     188
     189WebInspector.isEditingAnyField = function()
     190{
     191    return !!WebInspector.__editingCount;
     192}
     193
     194/**
     195 * @constructor
     196 */
     197WebInspector.EditingConfig = function()
     198{
     199    /**
     200     * Handles editing "commit" outcome
     201     * @type {function(Element,string,string,*,string)|undefined}
     202     */
     203    this.commitHandler;
     204
     205    /**
     206     * Handles editing "cancel" outcome
     207     * @type {function(Element,*)|undefined}
     208     */
     209    this.cancelHandler;
     210
     211    /**
     212     * Handles the "paste" event, return values are the same as those for customFinishHandler
     213     * @type {function(Element)|undefined}
     214     */
     215    this.pasteHandler;
     216
     217    /**
     218     * An arbitrary context object to be passed to the commit and cancel handlers
     219     * @type {Object|undefined}
     220     */
     221    this.context;
     222
     223    /**
     224     * Whether the edited element is multiline
     225     * @type {boolean|undefined}
     226     */
     227    this.multiline;
     228
     229    /**
     230     * Custom finish handler for the editing session (invoked on keydown)
     231     * @type {function(Element,*)|undefined}
     232     */
     233    this.customFinishHandler;
     234}
     235
     236WebInspector.EditingConfig.prototype = {
     237    setCommitHandler: function(commitHandler)
     238    {
     239        this.commitHandler = commitHandler;
     240    },
     241
     242    setCancelHandler: function(cancelHandler)
     243    {
     244        this.cancelHandler = cancelHandler;
     245    },
     246
     247    setPasteHandler: function(pasteHandler)
     248    {
     249        this.pasteHandler = pasteHandler;
     250    },
     251
     252    setContext: function(context)
     253    {
     254        this.context = context;
     255    },
     256
     257    setMultiline: function(multiline)
     258    {
     259        this.multiline = multiline;
     260    },
     261
     262    setCustomFinishHandler: function(customFinishHandler)
     263    {
     264        this.customFinishHandler = customFinishHandler;
     265    }
     266}
     267
     268/**
     269 * @param {Element} element
     270 * @param {WebInspector.EditingConfig=} config
     271 */
     272WebInspector.startEditing = function(element, config)
     273{
     274    if (!WebInspector.markBeingEdited(element, true))
     275        return;
     276
     277    config = config || new WebInspector.EditingConfig();
     278    var committedCallback = config.commitHandler;
     279    var cancelledCallback = config.cancelHandler;
     280    var pasteCallback = config.pasteHandler;
     281    var context = config.context;
     282    var oldText = getContent(element);
     283    var moveDirection = "";
     284
     285    element.addStyleClass("editing");
     286
     287    var oldTabIndex = element.tabIndex;
     288    if (element.tabIndex < 0)
     289        element.tabIndex = 0;
     290
     291    function blurEventListener() {
     292        editingCommitted.call(element);
     293    }
     294
     295    function getContent(element) {
     296        if (element.tagName === "INPUT" && element.type === "text")
     297            return element.value;
     298        else
     299            return element.textContent;
     300    }
     301
     302    /** @this {Element} */
     303    function cleanUpAfterEditing()
     304    {
     305        WebInspector.markBeingEdited(element, false);
     306
     307        this.removeStyleClass("editing");
     308        this.tabIndex = oldTabIndex;
     309        this.scrollTop = 0;
     310        this.scrollLeft = 0;
     311
     312        element.removeEventListener("blur", blurEventListener, false);
     313        element.removeEventListener("keydown", keyDownEventListener, true);
     314        if (pasteCallback)
     315            element.removeEventListener("paste", pasteEventListener, true);
     316
     317        if (element === WebInspector.currentFocusElement || element.isAncestor(WebInspector.currentFocusElement))
     318            WebInspector.currentFocusElement = WebInspector.previousFocusElement;
     319    }
     320
     321    /** @this {Element} */
     322    function editingCancelled()
     323    {
     324        if (this.tagName === "INPUT" && this.type === "text")
     325            this.value = oldText;
     326        else
     327            this.textContent = oldText;
     328
     329        cleanUpAfterEditing.call(this);
     330
     331        if (cancelledCallback)
     332            cancelledCallback(this, context);
     333    }
     334
     335    /** @this {Element} */
     336    function editingCommitted()
     337    {
     338        cleanUpAfterEditing.call(this);
     339
     340        if (committedCallback)
     341            committedCallback(this, getContent(this), oldText, context, moveDirection);
     342    }
     343
     344    function defaultFinishHandler(event)
     345    {
     346        var isMetaOrCtrl = WebInspector.isMac() ?
     347            event.metaKey && !event.shiftKey && !event.ctrlKey && !event.altKey :
     348            event.ctrlKey && !event.shiftKey && !event.metaKey && !event.altKey;
     349        if (isEnterKey(event) && (event.isMetaOrCtrlForTest || !config.multiline || isMetaOrCtrl))
     350            return "commit";
     351        else if (event.keyCode === WebInspector.KeyboardShortcut.Keys.Esc.code || event.keyIdentifier === "U+001B")
     352            return "cancel";
     353        else if (event.keyIdentifier === "U+0009") // Tab key
     354            return "move-" + (event.shiftKey ? "backward" : "forward");
     355    }
     356
     357    function handleEditingResult(result, event)
     358    {
     359        if (result === "commit") {
     360            editingCommitted.call(element);
     361            event.preventDefault();
     362            event.stopPropagation();
     363        } else if (result === "cancel") {
     364            editingCancelled.call(element);
     365            event.preventDefault();
     366            event.stopPropagation();
     367        } else if (result && result.indexOf("move-") === 0) {
     368            moveDirection = result.substring(5);
     369            if (event.keyIdentifier !== "U+0009")
     370                blurEventListener();
     371        }
     372    }
     373
     374    function pasteEventListener(event)
     375    {
     376        var result = pasteCallback(event);
     377        handleEditingResult(result, event);
     378    }
     379
     380    function keyDownEventListener(event)
     381    {
     382        var handler = config.customFinishHandler || defaultFinishHandler;
     383        var result = handler(event);
     384        handleEditingResult(result, event);
     385    }
     386
     387    element.addEventListener("blur", blurEventListener, false);
     388    element.addEventListener("keydown", keyDownEventListener, true);
     389    if (pasteCallback)
     390        element.addEventListener("paste", pasteEventListener, true);
     391
     392    WebInspector.currentFocusElement = element;
     393    return {
     394        cancel: editingCancelled.bind(element),
     395        commit: editingCommitted.bind(element)
     396    };
     397}
     398

  • trunk/Source/WebCore/inspector/front-end/externs.js

    r96588 r96591  
    7878Element.prototype.scrollIntoViewIfNeeded = function() {}
    7979
    80 Array.prototype.remove = function(obj) {}
     80/**
     81 * @param {boolean=} onlyFirst
     82 */
     83Array.prototype.remove = function(obj, onlyFirst) {}
    8184
    8285WebInspector.extensionServer = {}
    … …  
    179182 */
    180183WebInspector.platformFlavor = "";
     184
     185/** @param {Element} element */
     186window.getComputedStyle = function(element)
     187{
     188}
     189
     190/**
     191 * @type {boolean}
     192 */
     193Event.prototype.isMetaOrCtrlForTest = false;

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

    r96584 r96591  
    13571357}
    13581358
    1359 WebInspector.isBeingEdited = function(element)
    1360 {
    1361     return element.__editing;
    1362 }
    1363 
    1364 WebInspector.markBeingEdited = function(element, value)
    1365 {
    1366     if (value) {
    1367         if (element.__editing)
    1368             return false;
    1369         element.__editing = true;
    1370         WebInspector.__editingCount = (WebInspector.__editingCount || 0) + 1;
    1371     } else {
    1372         if (!element.__editing)
    1373             return false;
    1374         delete element.__editing;
    1375         --WebInspector.__editingCount;
    1376     }
    1377     return true;
    1378 }
    1379 
    1380 WebInspector.isEditingAnyField = function()
    1381 {
    1382     return !!WebInspector.__editingCount;
    1383 }
    1384 
    1385 // Available config fields (all optional):
    1386 // context: Object - an arbitrary context object to be passed to the commit and cancel handlers
    1387 // commitHandler: Function - handles editing "commit" outcome
    1388 // cancelHandler: Function - handles editing "cancel" outcome
    1389 // customFinishHandler: Function - custom finish handler for the editing session (invoked on keydown)
    1390 // pasteHandler: Function - handles the "paste" event, return values are the same as those for customFinishHandler
    1391 // multiline: Boolean - whether the edited element is multiline
    1392 WebInspector.startEditing = function(element, config)
    1393 {
    1394     if (!WebInspector.markBeingEdited(element, true))
    1395         return;
    1396 
    1397     config = config || {};
    1398     var committedCallback = config.commitHandler;
    1399     var cancelledCallback = config.cancelHandler;
    1400     var pasteCallback = config.pasteHandler;
    1401     var context = config.context;
    1402     var oldText = getContent(element);
    1403     var moveDirection = "";
    1404 
    1405     element.addStyleClass("editing");
    1406 
    1407     var oldTabIndex = element.tabIndex;
    1408     if (element.tabIndex < 0)
    1409         element.tabIndex = 0;
    1410 
    1411     function blurEventListener() {
    1412         editingCommitted.call(element);
    1413     }
    1414 
    1415     function getContent(element) {
    1416         if (element.tagName === "INPUT" && element.type === "text")
    1417             return element.value;
    1418         else
    1419             return element.textContent;
    1420     }
    1421 
    1422     function cleanUpAfterEditing() {
    1423         WebInspector.markBeingEdited(element, false);
    1424 
    1425         this.removeStyleClass("editing");
    1426         this.tabIndex = oldTabIndex;
    1427         this.scrollTop = 0;
    1428         this.scrollLeft = 0;
    1429 
    1430         element.removeEventListener("blur", blurEventListener, false);
    1431         element.removeEventListener("keydown", keyDownEventListener, true);
    1432         if (pasteCallback)
    1433             element.removeEventListener("paste", pasteEventListener, true);
    1434 
    1435         if (element === WebInspector.currentFocusElement || element.isAncestor(WebInspector.currentFocusElement))
    1436             WebInspector.currentFocusElement = WebInspector.previousFocusElement;
    1437     }
    1438 
    1439     function editingCancelled() {
    1440         if (this.tagName === "INPUT" && this.type === "text")
    1441             this.value = oldText;
    1442         else
    1443             this.textContent = oldText;
    1444 
    1445         cleanUpAfterEditing.call(this);
    1446 
    1447         if (cancelledCallback)
    1448             cancelledCallback(this, context);
    1449     }
    1450 
    1451     function editingCommitted() {
    1452         cleanUpAfterEditing.call(this);
    1453 
    1454         if (committedCallback)
    1455             committedCallback(this, getContent(this), oldText, context, moveDirection);
    1456     }
    1457 
    1458     function defaultFinishHandler(event)
    1459     {
    1460         var isMetaOrCtrl = WebInspector.isMac() ?
    1461             event.metaKey && !event.shiftKey && !event.ctrlKey && !event.altKey :
    1462             event.ctrlKey && !event.shiftKey && !event.metaKey && !event.altKey;
    1463         if (isEnterKey(event) && (event.isMetaOrCtrlForTest || !config.multiline || isMetaOrCtrl))
    1464             return "commit";
    1465         else if (event.keyCode === WebInspector.KeyboardShortcut.Keys.Esc.code || event.keyIdentifier === "U+001B")
    1466             return "cancel";
    1467         else if (event.keyIdentifier === "U+0009") // Tab key
    1468             return "move-" + (event.shiftKey ? "backward" : "forward");
    1469     }
    1470 
    1471     function handleEditingResult(result, event)
    1472     {
    1473         if (result === "commit") {
    1474             editingCommitted.call(element);
    1475             event.preventDefault();
    1476             event.stopPropagation();
    1477         } else if (result === "cancel") {
    1478             editingCancelled.call(element);
    1479             event.preventDefault();
    1480             event.stopPropagation();
    1481         } else if (result && result.indexOf("move-") === 0) {
    1482             moveDirection = result.substring(5);
    1483             if (event.keyIdentifier !== "U+0009")
    1484                 blurEventListener();
    1485         }
    1486     }
    1487 
    1488     function pasteEventListener(event)
    1489     {
    1490         var result = pasteCallback(event);
    1491         handleEditingResult(result, event);
    1492     }
    1493 
    1494     function keyDownEventListener(event)
    1495     {
    1496         var handler = config.customFinishHandler || defaultFinishHandler;
    1497         var result = handler(event);
    1498         handleEditingResult(result, event);
    1499     }
    1500 
    1501     element.addEventListener("blur", blurEventListener, false);
    1502     element.addEventListener("keydown", keyDownEventListener, true);
    1503     if (pasteCallback)
    1504         element.addEventListener("paste", pasteEventListener, true);
    1505 
    1506     WebInspector.currentFocusElement = element;
    1507     return {
    1508         cancel: editingCancelled.bind(element),
    1509         commit: editingCommitted.bind(element)
    1510     };
    1511 }
    1512 
    15131359WebInspector._toolbarItemClicked = function(event)
    15141360{
Note: See TracChangeset for help on using the changeset viewer.