Q:

binding html events to an instance of a controller class _within_ the constructor

Sorry, probably bit of a noob JS question regarding binding handlers to instances.  
I am creating a controller instance with some data that will subsequently be used to process incoming events (the actual use case is composing complex d3 handlers with varying ajax urls and into which I compose the function(s) doing the actual tree update).
RequireJS and jquery are involved, but I suspect my issue has more to do with my specific binding code.  I guess I could forego the use of 'this' since I have only one controller per page which can be a global.  But this feels like it should be doable, if only I knew how to.
This is how I bind the controller to its target, from within the constructor (doing it outside the constructor seems to work):
function BtnMgr(msg, tgt_id) {
    this.msg = msg;
    this.tgt_id = tgt_id;
    var selector = "#" + tgt_id;
    $(selector).on("click", this.handleClick);
}

What is going wrong?
When I click on the button, 'this', in the handleClick refers to the html button, not to the controller instance.
If I call the controller instance method directly, 'this' is correct.
I've tried call or creating a wrapper function, as suggested in 
How can I bind an event handler to an instance in JQuery? 
$(selector).click(function(e) { BtnMgr.prototype.handleClick.call(this, e); });

My button click keeps seeing 'this' as the button, not the controller:
output
global var controller:BtnMgr.I am a button
this:[object HTMLButtonElement],type:
e:[object Object],type:Object
BtnMgr.handleClick:this.msg:undefined

Simplified version:
HTML
page4.html
<!DOCTYPE html>
<html>
<head>
    <title>Page 4</title>
    <script type="text/javascript" src="http://cdnjs.cloudflare.com/ajax/libs/require.js/2.1.15/require.min.js"></script>
    <script type="text/javascript">
    requirejs.config({
        baseUrl: '.',
        paths: {
            "jquery": "//ajax.googleapis.com/ajax/libs/jquery/2.0.0/jquery.min"
        }
    });
    var controller;
    require(["main4"], function(BtnMgr) {
        controller = new BtnMgr("I am a button", "btn_click");
        //this simulated call works - 'this' refers to the BtnMgr instance
        controller.handleClick("dummy_btn");
    });
    </script>
</head>
<body>
    <button id="btn_click">click me!</button>
</body>
</html>

RequireJS
main4.js
define(["jquery"], function($) {

    function BtnMgr(msg, tgt_id) {
        this.msg = msg;
        this.tgt_id = tgt_id;
        var selector = "#" + tgt_id;

        $(selector).on("click", this.handleClick);

    }

    BtnMgr.prototype.toString = function(){
        return "BtnMgr." + this.msg;
    };

    BtnMgr.prototype.handleClick = function(e) {
        //I want 'this' to refer to the BtnMgr instance
        //and e to the html element that got clicked...

        console.log("global var controller:" + controller);
        console.log("this:" +  this + ",type:" + this.constructor.name);
        console.log("e:" +  e + ",type:" + e.constructor.name);
        console.log("BtnMgr.handleClick:this.msg:" + this.msg);
    };

    //define is returning the constructor method for the object 
    return BtnMgr;

});

A:

You could achieve (nearly) what you want with :
$(selector).on("click", this.handleClick.bind(this));

this will be the instance of BtnMgr and e.target will, as always, be the button.
However, that would fly in the face of convention and confuse anyone trying to understand your code, including yourself in 6 months time. In a click handler, this should always refer to the clicked element, as is natural.
If you really must have a reference from the handler back to the instance of BtnMgr that attached the click, then I might opt for "e-augmentation" like this :
function BtnMgr(msg, tgt_id) {
    var that = this;
    this.msg = msg;
    this.tgt_id = tgt_id;
    var selector = "#" + tgt_id;
    $(selector).on("click", function(e) {
        e.clickAttacher = that;
        that.handleClick(e);
    });
}

BtnMgr.prototype.toString = function(){
    return "BtnMgr." + this.msg;
};

BtnMgr.prototype.handleClick = function(e) {
    console.log("click attacher was instance of : " + e.clickAttacher.constructor.name); // BtnMgr
    console.log("button id: " +  e.target.id); // xxx
    console.log("msg: " + e.clickAttacher.msg); // Hello World!
};

var b = new BtnMgr('Hello World!', 'xxx');

DEMO
Having done that, you have to ask whether it's really worthwhile defining handleClick in that way. Sure, if it's a monster function then yes, define it with BtnMgr.prototype...., but if it's only small, then define it in the constructor itself and take direct advantage of that being in the scope chain (as does the augmenter function above).

