git.roojs.org Git - roojs1/blob - Roo/bootstrap/Popover.js

   1 /*
   2  * - LGPL
   3  *
   4  * element
   5  *
   6  */
   7
   8 /**
   9  * @class Roo.bootstrap.Popover
  10  * @extends Roo.bootstrap.Component
  11  * Bootstrap Popover class
  12  * @cfg {String} html contents of the popover   (or false to use children..)
  13  * @cfg {String} title of popover (or false to hide)
  14  * @cfg {String|function} (right|top|bottom|left|auto) placement how it is placed
  15  * @cfg {String} trigger click || hover (or false to trigger manually)
  16  * @cfg {Boolean} modal - popovers that are modal will mask the screen, and must be closed with another event.
  17  * @cfg {String|Boolean|Roo.Element} add click hander to trigger show over what element
  18  *      - if false and it has a 'parent' then it will be automatically added to that element
  19  *      - if string - Roo.get  will be called
  20  * @cfg {Number} delay - delay before showing
  21
  22  * @constructor
  23  * Create a new Popover
  24  * @param {Object} config The config object
  25  */
  26
  27 Roo.bootstrap.Popover = function(config){
  28     Roo.bootstrap.Popover.superclass.constructor.call(this, config);
  29
  30     this.addEvents({
  31         // raw events
  32          /**
  33          * @event show
  34          * After the popover show
  35          *
  36          * @param {Roo.bootstrap.Popover} this
  37          */
  38         "show" : true,
  39         /**
  40          * @event hide
  41          * After the popover hide
  42          *
  43          * @param {Roo.bootstrap.Popover} this
  44          */
  45         "hide" : true
  46     });
  47 };
  48
  49 Roo.extend(Roo.bootstrap.Popover, Roo.bootstrap.Component,  {
  50
  51     title: false,
  52     html: false,
  53
  54     placement : 'right',
  55     trigger : 'hover', // hover
  56     modal : false,
  57     delay : 0,
  58
  59     over: false,
  60
  61     can_build_overlaid : false,
  62
  63     maskEl : false, // the mask element
  64     headerEl : false,
  65     contentEl : false,
  66     alignEl : false, // when show is called with an element - this get's stored.
  67
  68     getChildContainer : function()
  69     {
  70         return this.contentEl;
  71
  72     },
  73     getPopoverHeader : function()
  74     {
  75         this.title = true; // flag not to hide it..
  76         this.headerEl.addClass('p-0');
  77         return this.headerEl
  78     },
  79
  80
  81     getAutoCreate : function(){
  82
  83         var cfg = {
  84            cls : 'popover roo-dynamic shadow roo-popover' + (this.modal ? '-modal' : ''),
  85            style: 'display:block',
  86            cn : [
  87                 {
  88                     cls : 'arrow'
  89                 },
  90                 {
  91                     cls : 'popover-inner ',
  92                     cn : [
  93                         {
  94                             tag: 'h3',
  95                             cls: 'popover-title popover-header',
  96                             html : this.title === false ? '' : this.title
  97                         },
  98                         {
  99                             cls : 'popover-content popover-body '  + (this.cls || ''),
 100                             html : this.html || ''
 101                         }
 102                     ]
 103
 104                 }
 105            ]
 106         };
 107
 108         return cfg;
 109     },
 110     /**
 111      * @param {string} the title
 112      */
 113     setTitle: function(str)
 114     {
 115         this.title = str;
 116         if (this.el) {
 117             this.headerEl.dom.innerHTML = str;
 118         }
 119
 120     },
 121     /**
 122      * @param {string} the body content
 123      */
 124     setContent: function(str)
 125     {
 126         this.html = str;
 127         if (this.contentEl) {
 128             this.contentEl.dom.innerHTML = str;
 129         }
 130
 131     },
 132     // as it get's added to the bottom of the page.
 133     onRender : function(ct, position)
 134     {
 135         Roo.bootstrap.Component.superclass.onRender.call(this, ct, position);
 136
 137
 138
 139         if(!this.el){
 140             var cfg = Roo.apply({},  this.getAutoCreate());
 141             cfg.id = Roo.id();
 142
 143             if (this.cls) {
 144                 cfg.cls += ' ' + this.cls;
 145             }
 146             if (this.style) {
 147                 cfg.style = this.style;
 148             }
 149             //Roo.log("adding to ");
 150             this.el = Roo.get(document.body).createChild(cfg, position);
 151 //            Roo.log(this.el);
 152         }
 153
 154         this.contentEl = this.el.select('.popover-content',true).first();
 155         this.headerEl =  this.el.select('.popover-title',true).first();
 156
 157         var nitems = [];
 158         if(typeof(this.items) != 'undefined'){
 159             var items = this.items;
 160             delete this.items;
 161
 162             for(var i =0;i < items.length;i++) {
 163                 nitems.push(this.addxtype(Roo.apply({}, items[i])));
 164             }
 165         }
 166
 167         this.items = nitems;
 168
 169         this.maskEl = Roo.DomHelper.append(document.body, {tag: "div", cls:"x-dlg-mask"}, true);
 170         Roo.EventManager.onWindowResize(this.resizeMask, this, true);
 171
 172
 173
 174         this.initEvents();
 175     },
 176
 177     resizeMask : function()
 178     {
 179         this.maskEl.setSize(
 180             Roo.lib.Dom.getViewWidth(true),
 181             Roo.lib.Dom.getViewHeight(true)
 182         );
 183     },
 184
 185     initEvents : function()
 186     {
 187
 188         if (!this.modal) {
 189             Roo.bootstrap.Popover.register(this);
 190         }
 191
 192         this.arrowEl = this.el.select('.arrow',true).first();
 193         this.headerEl.setVisibilityMode(Roo.Element.DISPLAY); // probably not needed as it's default in BS4
 194         this.el.enableDisplayMode('block');
 195         this.el.hide();
 196
 197
 198         if (this.over === false && !this.parent()) {
 199             return;
 200         }
 201         if (this.triggers === false) {
 202             return;
 203         }
 204
 205         // support parent
 206         var on_el = (this.over == 'parent' || this.over === false) ? this.parent().el : Roo.get(this.over);
 207         var triggers = this.trigger ? this.trigger.split(' ') : [];
 208         Roo.each(triggers, function(trigger) {
 209
 210             if (trigger == 'click') {
 211                 on_el.on('click', this.toggle, this);
 212             } else if (trigger != 'manual') {
 213                 var eventIn  = trigger == 'hover' ? 'mouseenter' : 'focusin';
 214                 var eventOut = trigger == 'hover' ? 'mouseleave' : 'focusout';
 215
 216                 on_el.on(eventIn  ,this.enter, this);
 217                 on_el.on(eventOut, this.leave, this);
 218             }
 219         }, this);
 220     },
 221
 222
 223     // private
 224     timeout : null,
 225     hoverState : null,
 226
 227     toggle : function () {
 228         this.hoverState == 'in' ? this.leave() : this.enter();
 229     },
 230
 231     enter : function () {
 232
 233         clearTimeout(this.timeout);
 234
 235         this.hoverState = 'in';
 236
 237         if (!this.delay || !this.delay.show) {
 238             this.show();
 239             return;
 240         }
 241         var _t = this;
 242         this.timeout = setTimeout(function () {
 243             if (_t.hoverState == 'in') {
 244                 _t.show();
 245             }
 246         }, this.delay.show)
 247     },
 248
 249     leave : function() {
 250         clearTimeout(this.timeout);
 251
 252         this.hoverState = 'out';
 253
 254         if (!this.delay || !this.delay.hide) {
 255             this.hide();
 256             return;
 257         }
 258         var _t = this;
 259         this.timeout = setTimeout(function () {
 260             if (_t.hoverState == 'out') {
 261                 _t.hide();
 262             }
 263         }, this.delay.hide)
 264     },
 265     /**
 266      * Show the popover
 267      * @param {Roo.Element|string|Boolean} - element to align and point to. (set align to [ pos, offset ])
 268      * @param {string} (left|right|top|bottom) position
 269      */
 270     show : function (on_el, placement)
 271     {
 272         this.placement = typeof(placement) == 'undefined' ?  this.placement   : placement;
 273         on_el = on_el || false; // default to false
 274
 275         if (!on_el) {
 276             if (this.parent() && (this.over == 'parent' || (this.over === false))) {
 277                 on_el = this.parent().el;
 278             } else if (this.over) {
 279                 on_el = Roo.get(this.over);
 280             }
 281
 282         }
 283
 284         this.alignEl = Roo.get( on_el );
 285
 286         if (!this.el) {
 287             this.render(document.body);
 288         }
 289
 290
 291
 292
 293         if (this.title === false) {
 294             this.headerEl.hide();
 295         }
 296
 297
 298         this.el.show();
 299         this.el.dom.style.display = 'block';
 300
 301
 302         if (this.alignEl) {
 303             this.updatePosition(this.placement, true);
 304
 305         } else {
 306             // this is usually just done by the builder = to show the popoup in the middle of the scren.
 307             var es = this.el.getSize();
 308             var x = Roo.lib.Dom.getViewWidth()/2;
 309             var y = Roo.lib.Dom.getViewHeight()/2;
 310             this.el.setXY([ x-(es.width/2),  y-(es.height/2)] );
 311
 312         }
 313
 314
 315         //var arrow = this.el.select('.arrow',true).first();
 316         //arrow.set(align[2],
 317
 318         this.el.addClass('in');
 319
 320
 321
 322         this.hoverState = 'in';
 323
 324         if (this.modal) {
 325             this.maskEl.setSize(Roo.lib.Dom.getViewWidth(true),   Roo.lib.Dom.getViewHeight(true));
 326             this.maskEl.setStyle('z-index', Roo.bootstrap.Popover.zIndex++);
 327             this.maskEl.dom.style.display = 'block';
 328             this.maskEl.addClass('show');
 329         }
 330         this.el.setStyle('z-index', Roo.bootstrap.Popover.zIndex++);
 331
 332         this.fireEvent('show', this);
 333
 334     },
 335     /**
 336      * fire this manually after loading a grid in the table for example
 337      * @param {string} (left|right|top|bottom) where to try and put it (use false to use the last one)
 338      * @param {Boolean} try and move it if we cant get right position.
 339      */
 340     updatePosition : function(placement, try_move)
 341     {
 342         // allow for calling with no parameters
 343         placement = placement   ? placement :  this.placement;
 344         try_move = typeof(try_move) == 'undefined' ? true : try_move;
 345
 346         this.el.removeClass([
 347             'fade','top','bottom', 'left', 'right','in',
 348             'bs-popover-top','bs-popover-bottom', 'bs-popover-left', 'bs-popover-right'
 349         ]);
 350         this.el.addClass(placement + ' bs-popover-' + placement);
 351
 352         if (!this.alignEl ) {
 353             return false;
 354         }
 355
 356         switch (placement) {
 357             case 'right':
 358                 var exact = this.el.getAlignToXY(this.alignEl, 'tl-tr', [10,0]);
 359                 var offset = this.el.getAlignToXY(this.alignEl, 'tl-tr?',[10,0]);
 360                 if (!try_move || exact.equals(offset) || exact[0] == offset[0] ) {
 361                     //normal display... or moved up/down.
 362                     this.el.setXY(offset);
 363                     var xy = this.alignEl.getAnchorXY('tr', false);
 364                     xy[0]+=2;xy[1]+=5;
 365                     this.arrowEl.setXY(xy);
 366                     return true;
 367                 }
 368                 // continue through...
 369                 return this.updatePosition('left', false);
 370
 371
 372             case 'left':
 373                 var exact = this.el.getAlignToXY(this.alignEl, 'tr-tl', [-10,0]);
 374                 var offset = this.el.getAlignToXY(this.alignEl, 'tr-tl?',[-10,0]);
 375                 if (!try_move || exact.equals(offset) || exact[0] == offset[0] ) {
 376                     //normal display... or moved up/down.
 377                     this.el.setXY(offset);
 378                     var xy = this.alignEl.getAnchorXY('tl', false);
 379                     xy[0]-=10;xy[1]+=5; // << fix me
 380                     this.arrowEl.setXY(xy);
 381                     return true;
 382                 }
 383                 // call self...
 384                 return this.updatePosition('right', false);
 385
 386             case 'top':
 387                 var exact = this.el.getAlignToXY(this.alignEl, 'b-t', [0,-10]);
 388                 var offset = this.el.getAlignToXY(this.alignEl, 'b-t?',[0,-10]);
 389                 if (!try_move || exact.equals(offset) || exact[1] == offset[1] ) {
 390                     //normal display... or moved up/down.
 391                     this.el.setXY(offset);
 392                     var xy = this.alignEl.getAnchorXY('t', false);
 393                     xy[1]-=10; // << fix me
 394                     this.arrowEl.setXY(xy);
 395                     return true;
 396                 }
 397                 // fall through
 398                return this.updatePosition('bottom', false);
 399
 400             case 'bottom':
 401                  var exact = this.el.getAlignToXY(this.alignEl, 't-b', [0,10]);
 402                 var offset = this.el.getAlignToXY(this.alignEl, 't-b?',[0,10]);
 403                 if (!try_move || exact.equals(offset) || exact[1] == offset[1] ) {
 404                     //normal display... or moved up/down.
 405                     this.el.setXY(offset);
 406                     var xy = this.alignEl.getAnchorXY('b', false);
 407                      xy[1]+=2; // << fix me
 408                     this.arrowEl.setXY(xy);
 409                     return true;
 410                 }
 411                 // fall through
 412                 return this.updatePosition('top', false);
 413
 414
 415         }
 416
 417
 418         return false;
 419     },
 420
 421     hide : function()
 422     {
 423         this.el.setXY([0,0]);
 424         this.el.removeClass('in');
 425         this.el.hide();
 426         this.hoverState = null;
 427         this.maskEl.hide(); // always..
 428         this.fireEvent('hide', this);
 429     }
 430
 431 });
 432
 433
 434 Roo.apply(Roo.bootstrap.Popover, {
 435
 436     alignment : {
 437         'left' : ['r-l', [-10,0], 'left bs-popover-left'],
 438         'right' : ['l-br', [10,0], 'right bs-popover-right'],
 439         'bottom' : ['t-b', [0,10], 'top bs-popover-top'],
 440         'top' : [ 'b-t', [0,-10], 'bottom bs-popover-bottom']
 441     },
 442
 443     zIndex : 20001,
 444
 445     clickHander : false,
 446
 447
 448
 449     onMouseDown : function(e)
 450     {
 451         if (this.popups.length &&  !e.getTarget(".roo-popover")) {
 452             /// what is nothing is showing..
 453             this.hideAll();
 454         }
 455
 456     },
 457
 458
 459     popups : [],
 460
 461     register : function(popup)
 462     {
 463         if (!Roo.bootstrap.Popover.clickHandler) {
 464             Roo.bootstrap.Popover.clickHandler = Roo.get(document).on("mousedown", Roo.bootstrap.Popover.onMouseDown, Roo.bootstrap.Popover);
 465         }
 466         // hide other popups.
 467         popup.on('show', Roo.bootstrap.Popover.onShow,  popup);
 468         popup.on('hide', Roo.bootstrap.Popover.onHide,  popup);
 469         this.hideAll(); //<< why?
 470         //this.popups.push(popup);
 471     },
 472     hideAll : function()
 473     {
 474         this.popups.forEach(function(p) {
 475             p.hide();
 476         });
 477     },
 478     onShow : function() {
 479         Roo.bootstrap.Popover.popups.push(this);
 480     },
 481     onHide : function() {
 482         Roo.bootstrap.Popover.popups.remove(this);
 483     }
 484
 485 });