[TIMOB-5818] Ti API: View proxies should behave like real JS objects - or they should be wrapped

   var view = Ti.UI.createView({height:50});
   view.foo = {};
   view.foo.bar = 'hello';
   view.foo.bar = 'goodbye';
   

   function View(options) {
     this.Element = Ti.UI.createView(options);
   }
   
   View.prototype.add = function(TiObject) {
     this.Element.add(TiObject);
   };
   
   
   var myView = new View({ height: 50 });
   myView.add(Ti.UI.createButton({ title: 'Click me' });
   
   //now you can do this without a problem
   myView.foo = {};
   myView.foo.bar = 'hello';
   myView.foo.bar = 'goodbye';
   

 
   var w = Ti.UI.createWindow({
   	backgroundColor:'#fff'
   });
   
   var l = Ti.UI.createLabel({
   	text:'click me',
   	font: {
   		fontWeight:'bold',
   		fontSize:24
   	}
   });
   w.add(l);
   
   l.addEventListener('click', function(e) {
   	l.text = 'clicked!'; // yep!
   	l.font.fontSize = 12; // nope.
   });
   
   w.open();
   

   var db = Ti.Database.open('test');
   
   db.execute('CREATE TABLE IF NOT EXISTS test(id INTEGER PRIMARY KEY, foo TEXT);');
   
   var args = [
   	'INSERT INTO test(foo) VALUES (?)',
   	'bar'
   ];
   
   // This used to not work, but does in 3.0 for iOS!
   db.execute.apply(db, args);
   
   Ti.API.info('looping...');
   var results = db.execute('SELECT * FROM test;');
   
   while(results.isValidRow()) {
   	Ti.API.info(results.fieldByName('foo'));
   	results.next();
   }
   
   results.close();
   db.close();
   

    var button = Ti.UI.createButton();
    console.log(button instanceof Ti.UI.Button); // logs "true"
    

    function myControl(){};
    myControl.prototype = new Ti.UI.Button();
    // Add custom control stuff
    

    var view = new Ti.UI.View();
    
    view.add = function(arguments) {
        alert('test');
    
        Ti.UI.View.add.apply(this, arguments);
    }
    

    var w = Ti.UI.createWindow({
        backgroundColor:'#fff'
    });
     
    var l = Ti.UI.createLabel({
        text:'click me',
        customVarName: 'bla bla bla',
        font: {
            fontWeight:'bold',
            fontSize:24
        }
    });
    w.add(l);
     
    w.open();
    

    var controller = Alloy.createController('someController', args);
    

    var controller = new (require('alloy/controllers/someController'))(args);
    
    // or more verbosely, but easier to read
    var Controller = require('alloy/controllers/someController');
    var controller = new Controller(args);
    

    function foo() {
        // constructor stuff
    }
    var x = new foo();
    

    var foo = function(){
        // constructor stuff
        return this;
    }.bind({});
    var x = foo();
    

    var win = Ti.UI.createWindow({
        open: function() {
            alert('test');
        }
    });
    win.open(); // an alert is opened with test displayed on Android, on iOS nothing happens
    
    {code)
    
    However this still does not mean it supports prototype as:
    
    

    
    var obj = {};
    var label = Ti.UI.createLabel({ text: 'Some text' });
    
    printPropertyDescriptor(label, 'text');
    printPropertyDescriptor(label, 'idontexist');
    printPropertyDescriptor(obj, 'idontexist');
    
    function printPropertyDescriptor(obj, name) {
    	var descriptor = Object.getOwnPropertyDescriptor(obj, 'clearTimeout');
    	var formatted = JSON.stringify(descriptor, null, 2);
    	console.log(name + " = " + formatted);
    }
    

    [INFO] :   text = {
    [INFO] :     "writable": false,
    [INFO] :     "enumerable": false,
    [INFO] :     "configurable": true
    [INFO] :   }
    [INFO] :   idontexist = {
    [INFO] :     "writable": false,
    [INFO] :     "enumerable": false,
    [INFO] :     "configurable": true
    [INFO] :   }
    [INFO] :   idontexist = undefined
    

    [INFO] :   text = {
    [INFO] :     "writable": false,
    [INFO] :     "enumerable": false,
    [INFO] :     "configurable": true,
    [INFO] :     "value": 'Some text',
    [INFO] :   }
    [INFO] :   idontexist = undefined
    [INFO] :   idontexist = undefined