home *** CD-ROM | disk | FTP | other *** search
/ Computer Active Guide 2009 July / CAG7.ISO / Internetas / SafariSetup.exe / AppleApplicationSupport.msi / WebKit.resources_inspector_WatchExpressionsSidebarPane.js < prev    next >
Encoding:
Text File  |  2010-06-03  |  10.7 KB  |  282 lines
  1. /*
  2.  * Copyright (C) IBM Corp. 2009  All rights reserved.
  3.  *
  4.  * Redistribution and use in source and binary forms, with or without
  5.  * modification, are permitted provided that the following conditions are
  6.  * met:
  7.  *
  8.  *     * Redistributions of source code must retain the above copyright
  9.  * notice, this list of conditions and the following disclaimer.
  10.  *     * Redistributions in binary form must reproduce the above
  11.  * copyright notice, this list of conditions and the following disclaimer
  12.  * in the documentation and/or other materials provided with the
  13.  * distribution.
  14.  *     * Neither the name of IBM Corp. nor the names of its
  15.  * contributors may be used to endorse or promote products derived from
  16.  * this software without specific prior written permission.
  17.  *
  18.  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  19.  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  20.  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  21.  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  22.  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  23.  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  24.  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  25.  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  26.  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  27.  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  28.  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  29.  */
  30.  
  31. WebInspector.WatchExpressionsSidebarPane = function()
  32. {
  33.     WebInspector.SidebarPane.call(this, WebInspector.UIString("Watch Expressions"));
  34.     WebInspector.settings.addEventListener("loaded", this._settingsLoaded, this);
  35. }
  36.  
  37. WebInspector.WatchExpressionsSidebarPane.prototype = {
  38.     _settingsLoaded: function()
  39.     {
  40.         this.bodyElement.removeChildren();
  41.  
  42.         this.expanded = WebInspector.settings.watchExpressions.length > 0;
  43.         this.section = new WebInspector.WatchExpressionsSection();
  44.         this.bodyElement.appendChild(this.section.element);
  45.  
  46.         var addElement = document.createElement("button");
  47.         addElement.setAttribute("type", "button");
  48.         addElement.textContent = WebInspector.UIString("Add");
  49.         addElement.addEventListener("click", this.section.addExpression.bind(this.section), false);
  50.  
  51.         var refreshElement = document.createElement("button");
  52.         refreshElement.setAttribute("type", "button");
  53.         refreshElement.textContent = WebInspector.UIString("Refresh");
  54.         refreshElement.addEventListener("click", this.section.update.bind(this.section), false);
  55.  
  56.         var centerElement = document.createElement("div");
  57.         centerElement.addStyleClass("watch-expressions-buttons-container");
  58.         centerElement.appendChild(addElement);
  59.         centerElement.appendChild(refreshElement);
  60.         this.bodyElement.appendChild(centerElement);
  61.  
  62.         this.onexpand = this.refreshExpressions.bind(this);
  63.     },
  64.  
  65.     refreshExpressions: function()
  66.     {
  67.         if (this.section)
  68.             this.section.update();
  69.     }
  70. }
  71.  
  72. WebInspector.WatchExpressionsSidebarPane.prototype.__proto__ = WebInspector.SidebarPane.prototype;
  73.  
  74. WebInspector.WatchExpressionsSection = function()
  75. {
  76.     this._watchObjectGroupId = "watch-group";
  77.  
  78.     WebInspector.ObjectPropertiesSection.call(this);
  79.  
  80.     this.watchExpressions = WebInspector.settings.watchExpressions;
  81.  
  82.     this.headerElement.className = "hidden";
  83.     this.editable = true;
  84.     this.expanded = true;
  85.     this.propertiesElement.addStyleClass("watch-expressions");
  86. }
  87.  
  88. WebInspector.WatchExpressionsSection.NewWatchExpression = "\xA0";
  89.  
  90. WebInspector.WatchExpressionsSection.prototype = {
  91.     update: function()
  92.     {
  93.         function appendResult(expression, watchIndex, result, exception)
  94.         {
  95.             if (exception) {
  96.                 // Exception results are not wrappers, but text messages.
  97.                 result = WebInspector.ObjectProxy.wrapPrimitiveValue(result);
  98.             } else if (result.type === "string") {
  99.                 // Evaluation result is intentionally not abbreviated. However, we'd like to distinguish between null and "null"
  100.                 result.description = "\"" + result.description + "\"";
  101.             }
  102.  
  103.             var property = new WebInspector.ObjectPropertyProxy(expression, result);
  104.             property.watchIndex = watchIndex;
  105.             property.isException = exception;
  106.  
  107.             // For newly added, empty expressions, set description to "",
  108.             // since otherwise you get DOMWindow
  109.             if (property.name === WebInspector.WatchExpressionsSection.NewWatchExpression) 
  110.                 property.value.description = "";
  111.  
  112.             // To clarify what's going on here: 
  113.             // In the outer function, we calculate the number of properties
  114.             // that we're going to be updating, and set that in the
  115.             // propertyCount variable.  
  116.             // In this function, we test to see when we are processing the 
  117.             // last property, and then call the superclass's updateProperties() 
  118.             // method to get all the properties refreshed at once.
  119.             properties.push(property);
  120.             
  121.             if (properties.length == propertyCount) {
  122.                 this.updateProperties(properties, WebInspector.WatchExpressionTreeElement, WebInspector.WatchExpressionsSection.CompareProperties);
  123.  
  124.                 // check to see if we just added a new watch expression,
  125.                 // which will always be the last property
  126.                 if (this._newExpressionAdded) {
  127.                     delete this._newExpressionAdded;
  128.  
  129.                     treeElement = this.findAddedTreeElement();
  130.                     if (treeElement)
  131.                         treeElement.startEditing();
  132.                 }
  133.             }
  134.         }
  135.  
  136.         // TODO: pass exact injected script id.
  137.         InspectorBackend.releaseWrapperObjectGroup(0, this._watchObjectGroupId)
  138.         var properties = [];
  139.  
  140.         // Count the properties, so we known when to call this.updateProperties()
  141.         // in appendResult()
  142.         var propertyCount = 0;
  143.         for (var i = 0; i < this.watchExpressions.length; ++i) {
  144.             if (!this.watchExpressions[i]) 
  145.                 continue;
  146.             ++propertyCount;
  147.         }
  148.  
  149.         // Now process all the expressions, since we have the actual count,
  150.         // which is checked in the appendResult inner function.
  151.         for (var i = 0; i < this.watchExpressions.length; ++i) {
  152.             var expression = this.watchExpressions[i];
  153.             if (!expression)
  154.                 continue;
  155.  
  156.             WebInspector.console.evalInInspectedWindow("(" + expression + ")", this._watchObjectGroupId, appendResult.bind(this, expression, i));
  157.         }
  158.  
  159.         // note this is setting the expansion of the tree, not the section;
  160.         // with no expressions, and expanded tree, we get some extra vertical
  161.         // white space
  162.         // FIXME: should change to use header buttons instead of the buttons
  163.         // at the bottom of the section, then we can add a "No Watch Expressions
  164.         // element when there are no watch expressions, and this issue should
  165.         // go away.
  166.         this.expanded = (propertyCount != 0);
  167.     },
  168.  
  169.     addExpression: function()
  170.     {
  171.         this._newExpressionAdded = true;
  172.         this.watchExpressions.push(WebInspector.WatchExpressionsSection.NewWatchExpression);
  173.         this.update();
  174.     },
  175.  
  176.     updateExpression: function(element, value)
  177.     {
  178.         this.watchExpressions[element.property.watchIndex] = value;
  179.         this.saveExpressions();
  180.         this.update();
  181.     },
  182.  
  183.     findAddedTreeElement: function()
  184.     {
  185.         var children = this.propertiesTreeOutline.children;
  186.         for (var i = 0; i < children.length; ++i)
  187.             if (children[i].property.name === WebInspector.WatchExpressionsSection.NewWatchExpression)
  188.                 return children[i];
  189.     },
  190.  
  191.     saveExpressions: function()
  192.     {
  193.         var toSave = [];
  194.         for (var i = 0; i < this.watchExpressions.length; i++)
  195.             if (this.watchExpressions[i])
  196.                 toSave.push(this.watchExpressions[i]);
  197.  
  198.         WebInspector.settings.watchExpressions = toSave;
  199.         return toSave.length;
  200.     }
  201. }
  202.  
  203. WebInspector.WatchExpressionsSection.prototype.__proto__ = WebInspector.ObjectPropertiesSection.prototype;
  204.  
  205. WebInspector.WatchExpressionsSection.CompareProperties = function(propertyA, propertyB) 
  206. {
  207.     if (propertyA.watchIndex == propertyB.watchIndex)
  208.         return 0;
  209.     else if (propertyA.watchIndex < propertyB.watchIndex)
  210.         return -1;
  211.     else
  212.         return 1;
  213. }
  214.  
  215. WebInspector.WatchExpressionTreeElement = function(property)
  216. {
  217.     WebInspector.ObjectPropertyTreeElement.call(this, property);
  218. }
  219.  
  220. WebInspector.WatchExpressionTreeElement.prototype = {
  221.     update: function()
  222.     {
  223.         WebInspector.ObjectPropertyTreeElement.prototype.update.call(this);
  224.  
  225.         if (this.property.isException)
  226.             this.valueElement.addStyleClass("watch-expressions-error-level");
  227.  
  228.         var deleteButton = document.createElement("input");
  229.         deleteButton.type = "button";
  230.         deleteButton.title = WebInspector.UIString("Delete watch expression.");
  231.         deleteButton.addStyleClass("enabled-button");
  232.         deleteButton.addStyleClass("delete-button");
  233.         deleteButton.addEventListener("click", this._deleteButtonClicked.bind(this), false);
  234.  
  235.         this.listItemElement.insertBefore(deleteButton, this.listItemElement.firstChild);
  236.     },
  237.  
  238.     _deleteButtonClicked: function()
  239.     {
  240.         this.treeOutline.section.updateExpression(this, null);
  241.     },
  242.  
  243.     startEditing: function()
  244.     {
  245.         if (WebInspector.isBeingEdited(this.nameElement) || !this.treeOutline.section.editable)
  246.             return;
  247.  
  248.         this.nameElement.textContent = this.property.name.trim();
  249.  
  250.         var context = { expanded: this.expanded };
  251.  
  252.         // collapse temporarily, if required
  253.         this.hasChildren = false;
  254.  
  255.         this.listItemElement.addStyleClass("editing-sub-part");
  256.  
  257.         WebInspector.startEditing(this.nameElement, this.editingCommitted.bind(this), this.editingCancelled.bind(this), context);
  258.     },
  259.  
  260.     editingCancelled: function(element, context)
  261.     {
  262.         if (!this.nameElement.textContent)
  263.             this.treeOutline.section.updateExpression(this, null);
  264.             
  265.         this.update();
  266.         this.editingEnded(context);
  267.     },
  268.  
  269.     applyExpression: function(expression, updateInterface)
  270.     {
  271.         expression = expression.trim();
  272.  
  273.         if (!expression)
  274.             expression = null;
  275.  
  276.         this.property.name = expression;
  277.         this.treeOutline.section.updateExpression(this, expression);
  278.     }
  279. }
  280.  
  281. WebInspector.WatchExpressionTreeElement.prototype.__proto__ = WebInspector.ObjectPropertyTreeElement.prototype;
  282.