return this.el.select('.panel-heading',true).first()
},
+ bodyEl : function()
+ {
+ if(!this.el || !this.panel.length){
+ return;
+ }
+
+ return this.el.select('.panel-body',true).first()
+ },
+
titleEl : function()
{
if(!this.el || !this.panel.length || !this.header.length){
* The raw btnclick event for the button
* @param {Roo.EventObject} e
*/
- "btnclick" : true
+ "btnclick" : true,
+ /**
+ * @event resize
+ * Fire when dialog resize
+ * @param {Roo.bootstrap.Modal} this
+ * @param {Roo.EventObject} e
+ */
+ "resize" : true
});
this.buttons = this.buttons || [];
this.bodyEl.setHeight(h-this.diff);
+ this.fireEvent('resize', this);
},
setContentSize : function(w, h)
//collapsible : false,
//shim:true,
//modal: true,
- // width:400,
+ // width: 'auto',
// height:100,
//buttonAlign:"center",
closeClick : function(){
}
*/
-
-
- this.el.unmask(this.removeMask);
+ (function() { this.el.unmask(this.removeMask); }).defer(50, this);
},
// private
onLoad : function()
{
- this.el.unmask(this.removeMask);
+ (function() { this.el.unmask(this.removeMask); }).defer(50, this);
},
// private
onBeforeLoad : function(){
if(!this.disabled){
- this.el.mask(this.msg, this.msgCls);
+ (function() { this.el.mask(this.msg, this.msgCls); }).defer(50, this);
}
},
Roo.bootstrap.Form = function(config){
Roo.bootstrap.Form.superclass.constructor.call(this, config);
+
+ Roo.bootstrap.Form.popover.apply();
+
this.addEvents({
/**
* @event clientvalidation
loadMask : true,
/**
- * @cfg {Boolean} errPopover (true|false) default false
+ * @cfg {Boolean} errorMask (true|false) default false
*/
- errPopover : false,
+ errorMask : false,
getAutoCreate : function(){
if(f.validate()){
return;
}
-
valid = false;
- if(!target){
+ if(!target && f.el.isVisible(true)){
target = f;
}
});
- if(this.errPopover && !valid){
- this.showErrPopover(target);
+ if(this.errorMask && !valid){
+ Roo.bootstrap.Form.popover.mask(this, target);
}
return valid;
},
- showErrPopover : function(target)
- {
- if(!this.errPopover){
- return;
- }
-
- var oIndex = target.el.getStyle('z-index');
-
- target.el.setStyle('z-index', Roo.bootstrap.Modal.zIndex++);
-
- target.el.addClass('roo-invalid-outline');
-
- target.inputEl().focus();
-
- var fadeout = function(){
-
- target.inputEl().un('blur', fadeout);
- target.inputEl().un('keyup', fadeout);
-
- target.el.setStyle('z-index', oIndex);
-
- target.el.removeClass('roo-invalid-outline');
-
- }
-
- target.inputEl().on('blur', fadeout, target);
- target.inputEl().on('keyup', fadeout, target);
-
-
- },
-
/**
* Returns true if any fields in this form have changed since their original load.
* @return Boolean
v = f.getRawValue() ; // dates..
}
// combo boxes where name != hiddenName...
- if (f.name != f.getName()) {
+ if (f.name !== false && f.name != '' && f.name != f.getName()) {
ret[f.name] = f.getRawValue();
}
ret[f.getName()] = v;
}
});
+
+Roo.apply(Roo.bootstrap.Form, {
+
+ popover : {
+
+ padding : 5,
+
+ isApplied : false,
+
+ isMasked : false,
+
+ form : false,
+
+ target : false,
+
+ toolTip : false,
+
+ intervalID : false,
+
+ maskEl : false,
+
+ apply : function()
+ {
+ if(this.isApplied){
+ return;
+ }
+
+ this.maskEl = {
+ top : Roo.DomHelper.append(Roo.get(document.body), { tag: "div", cls:"x-dlg-mask roo-form-top-mask" }, true),
+ left : Roo.DomHelper.append(Roo.get(document.body), { tag: "div", cls:"x-dlg-mask roo-form-left-mask" }, true),
+ bottom : Roo.DomHelper.append(Roo.get(document.body), { tag: "div", cls:"x-dlg-mask roo-form-bottom-mask" }, true),
+ right : Roo.DomHelper.append(Roo.get(document.body), { tag: "div", cls:"x-dlg-mask roo-form-right-mask" }, true)
+ };
+
+ this.maskEl.top.enableDisplayMode("block");
+ this.maskEl.left.enableDisplayMode("block");
+ this.maskEl.bottom.enableDisplayMode("block");
+ this.maskEl.right.enableDisplayMode("block");
+
+ this.toolTip = new Roo.bootstrap.Tooltip({
+ cls : 'roo-form-error-popover',
+ alignment : {
+ 'left' : ['r-l', [-2,0], 'right'],
+ 'right' : ['l-r', [2,0], 'left'],
+ 'bottom' : ['tl-bl', [0,2], 'top'],
+ 'top' : [ 'bl-tl', [0,-2], 'bottom']
+ }
+ });
+
+ this.toolTip.render(Roo.get(document.body));
+
+ this.toolTip.el.enableDisplayMode("block");
+
+ Roo.get(document.body).on('click', function(){
+ this.unmask();
+ }, this);
+
+ this.isApplied = true
+ },
+
+ mask : function(form, target)
+ {
+ this.form = form;
+
+ this.target = target;
+
+ if(!this.form.errorMask || !target.el){
+ return;
+ }
+
+ var scrollable = this.target.el.findScrollableParent() || this.target.el.findParent('div.modal', 100, true) || Roo.get(document.body);
+
+ var scrolled = scrollable.getScroll();
+
+ var ot = this.target.el.calcOffsetsTo(scrollable);
+
+ scrollTo = ot[1] - 100;
+
+ scrollable.scrollTo('top', scrollTo);
+
+ var box = this.target.el.getBox();
+
+ var zIndex = Roo.bootstrap.Modal.zIndex++;
+
+ this.maskEl.top.setStyle('position', 'fixed');
+ this.maskEl.top.setStyle('z-index', zIndex);
+ this.maskEl.top.setSize(Roo.lib.Dom.getDocumentWidth(), box.y - this.padding);
+ this.maskEl.top.setXY([0, 0]);
+ this.maskEl.top.show();
+
+ this.maskEl.left.setStyle('position', 'fixed');
+ this.maskEl.left.setStyle('z-index', zIndex);
+ this.maskEl.left.setSize(Roo.lib.Dom.getDocumentWidth() - box.right - this.padding, box.height + this.padding * 2);
+ this.maskEl.left.setXY([box.right + this.padding, box.y - this.padding]);
+ this.maskEl.left.show();
+
+ this.maskEl.bottom.setStyle('position', 'fixed');
+ this.maskEl.bottom.setStyle('z-index', zIndex);
+ this.maskEl.bottom.setSize(Roo.lib.Dom.getDocumentWidth(), Roo.lib.Dom.getDocumentHeight() - box.bottom - this.padding);
+ this.maskEl.bottom.setXY([0, box.bottom + this.padding]);
+ this.maskEl.bottom.show();
+
+ this.maskEl.right.setStyle('position', 'fixed');
+ this.maskEl.right.setStyle('z-index', zIndex);
+ this.maskEl.right.setSize(box.x - this.padding, box.height + this.padding * 2);
+ this.maskEl.right.setXY([0, box.y - this.padding]);
+ this.maskEl.right.show();
+
+
+ this.toolTip.bindEl = this.target.el;
+
+ this.toolTip.el.setStyle('z-index', Roo.bootstrap.Modal.zIndex++);
+
+ var tip = this.target.blankText;
+
+ if(this.target.getValue() !== '' && this.target.regexText.length){
+ tip = this.target.regexText;
+ }
+
+ this.toolTip.show(tip);
+
+ this.intervalID = window.setInterval(function() {
+ Roo.bootstrap.Form.popover.unmask();
+ }, 10000);
+
+ window.onwheel = function(){ return false;};
+
+ (function(){ this.isMasked = true; }).defer(500, this);
+
+
+
+ },
+
+ unmask : function()
+ {
+ if(!this.isApplied || !this.isMasked || !this.form || !this.target || !this.form.errorMask){
+ return;
+ }
+
+ this.maskEl.top.setStyle('position', 'absolute');
+ this.maskEl.top.setSize(0, 0).setXY([0, 0]);
+ this.maskEl.top.hide();
+
+ this.maskEl.left.setStyle('position', 'absolute');
+ this.maskEl.left.setSize(0, 0).setXY([0, 0]);
+ this.maskEl.left.hide();
+
+ this.maskEl.bottom.setStyle('position', 'absolute');
+ this.maskEl.bottom.setSize(0, 0).setXY([0, 0]);
+ this.maskEl.bottom.hide();
+
+ this.maskEl.right.setStyle('position', 'absolute');
+ this.maskEl.right.setSize(0, 0).setXY([0, 0]);
+ this.maskEl.right.hide();
+
+ this.toolTip.hide();
+
+ this.toolTip.el.hide();
+
+ window.onwheel = function(){ return true;};
+
+ if(this.intervalID){
+ window.clearInterval(this.intervalID);
+ this.intervalID = false;
+ }
+
+ this.isMasked = false;
+
+ }
+
+ }
+
+});
+
/*
* Based on:
* Ext JS Library 1.1.1
* @cfg {Number} md colspan out of 12 for computer-sized screens
* @cfg {Number} lg colspan out of 12 for large computer-sized screens
* @cfg {string} value default value of the input
- * @cfg {Number} labelWidth set the width of label (0-12)
+ * @cfg {Number} labelWidth set the width of label
+ * @cfg {Number} labellg set the width of label (1-12)
+ * @cfg {Number} labelmd set the width of label (1-12)
+ * @cfg {Number} labelsm set the width of label (1-12)
+ * @cfg {Number} labelxs set the width of label (1-12)
* @cfg {String} labelAlign (top|left)
* @cfg {Boolean} readOnly Specifies that the field should be read-only
* @cfg {String} autocomplete - default is new-password see: https://developers.google.com/web/fundamentals/input/form/label-and-name-inputs?hl=en
*/
Roo.bootstrap.Input = function(config){
+
Roo.bootstrap.Input.superclass.constructor.call(this, config);
-
- this.addEvents({
- /**
- * @event focus
- * Fires when this field receives input focus.
- * @param {Roo.form.Field} this
- */
- focus : true,
- /**
- * @event blur
- * Fires when this field loses input focus.
- * @param {Roo.form.Field} this
- */
- blur : true,
- /**
- * @event specialkey
- * Fires when any key related to navigation (arrows, tab, enter, esc, etc.) is pressed. You can check
- * {@link Roo.EventObject#getKey} to determine which key was pressed.
- * @param {Roo.form.Field} this
- * @param {Roo.EventObject} e The event object
- */
- specialkey : true,
- /**
- * @event change
- * Fires just before the field blurs if the field value has changed.
- * @param {Roo.form.Field} this
- * @param {Mixed} newValue The new value
- * @param {Mixed} oldValue The original value
- */
- change : true,
- /**
- * @event invalid
- * Fires after the field has been marked as invalid.
- * @param {Roo.form.Field} this
- * @param {String} msg The validation message
- */
- invalid : true,
- /**
- * @event valid
- * Fires after the field has been validated with no errors.
- * @param {Roo.form.Field} this
- */
- valid : true,
- /**
- * @event keyup
- * Fires after the key up
- * @param {Roo.form.Field} this
- * @param {Roo.EventObject} e The event Object
- */
- keyup : true
- });
+
+ this.addEvents({
+ /**
+ * @event focus
+ * Fires when this field receives input focus.
+ * @param {Roo.form.Field} this
+ */
+ focus : true,
+ /**
+ * @event blur
+ * Fires when this field loses input focus.
+ * @param {Roo.form.Field} this
+ */
+ blur : true,
+ /**
+ * @event specialkey
+ * Fires when any key related to navigation (arrows, tab, enter, esc, etc.) is pressed. You can check
+ * {@link Roo.EventObject#getKey} to determine which key was pressed.
+ * @param {Roo.form.Field} this
+ * @param {Roo.EventObject} e The event object
+ */
+ specialkey : true,
+ /**
+ * @event change
+ * Fires just before the field blurs if the field value has changed.
+ * @param {Roo.form.Field} this
+ * @param {Mixed} newValue The new value
+ * @param {Mixed} oldValue The original value
+ */
+ change : true,
+ /**
+ * @event invalid
+ * Fires after the field has been marked as invalid.
+ * @param {Roo.form.Field} this
+ * @param {String} msg The validation message
+ */
+ invalid : true,
+ /**
+ * @event valid
+ * Fires after the field has been validated with no errors.
+ * @param {Roo.form.Field} this
+ */
+ valid : true,
+ /**
+ * @event keyup
+ * Fires after the key up
+ * @param {Roo.form.Field} this
+ * @param {Roo.EventObject} e The event Object
+ */
+ keyup : true
+ });
};
Roo.extend(Roo.bootstrap.Input, Roo.bootstrap.Component, {
/**
* @cfg {String} blankText Error text to display if the allow blank validation fails (defaults to "This field is required")
*/
- blankText : "This field is required",
+ blankText : "Please complete this mandatory field",
/**
* @cfg {Number} minLength Minimum input field length required (defaults to 0)
indicatorpos : 'left',
+ labellg : 0,
+ labelmd : 0,
+ labelsm : 0,
+ labelxs : 0,
+
parentLabelAlign : function()
{
var parent = this;
if (align ==='left' && this.fieldLabel.length) {
+ cfg.cls += ' roo-form-group-label-left';
+
cfg.cn = [
{
tag : 'i',
{
tag: 'label',
'for' : id,
- cls : 'control-label col-sm-' + this.labelWidth,
+ cls : 'control-label',
html : this.fieldLabel
},
{
- cls : "col-sm-" + (12 - this.labelWidth),
+ cls : "",
cn: [
inputblock
]
}
-
];
+ var labelCfg = cfg.cn[1];
+ var contentCfg = cfg.cn[2];
+
if(this.indicatorpos == 'right'){
cfg.cn = [
{
tag: 'label',
'for' : id,
- cls : 'control-label col-sm-' + this.labelWidth,
+ cls : 'control-label',
html : this.fieldLabel
},
tooltip : 'This field is required'
},
{
- cls : "col-sm-" + (12 - this.labelWidth),
+ cls : "",
cn: [
inputblock
]
}
];
+
+ labelCfg = cfg.cn[0];
+ contentCfg = cfg.cn[2];
+
+ }
+
+ if(this.labelWidth > 12){
+ labelCfg.style = "width: " + this.labelWidth + 'px';
+ }
+
+ if(this.labelWidth < 13 && this.labelmd == 0){
+ this.labelmd = this.labelWidth;
+ }
+
+ if(this.labellg > 0){
+ labelCfg.cls += ' col-lg-' + this.labellg;
+ contentCfg.cls += ' col-lg-' + (12 - this.labellg);
+ }
+
+ if(this.labelmd > 0){
+ labelCfg.cls += ' col-md-' + this.labelmd;
+ contentCfg.cls += ' col-md-' + (12 - this.labelmd);
+ }
+
+ if(this.labelsm > 0){
+ labelCfg.cls += ' col-sm-' + this.labelsm;
+ contentCfg.cls += ' col-sm-' + (12 - this.labelsm);
+ }
+
+ if(this.labelxs > 0){
+ labelCfg.cls += ' col-xs-' + this.labelxs;
+ contentCfg.cls += ' col-xs-' + (12 - this.labelxs);
}
+
} else if ( this.fieldLabel.length) {
cfg.cn = [
*/
markValid : function()
{
- if(!this.el || this.preventMark){ // not rendered
+ if(!this.el || this.preventMark){ // not rendered...
return;
}
}
if (align ==='left' && this.fieldLabel.length) {
-// Roo.log("left and has label");
- cfg.cn = [
-
- {
- tag: 'label',
- 'for' : id,
- cls : 'control-label col-sm-' + this.labelWidth,
- html : this.fieldLabel
-
- },
- {
- cls : "col-sm-" + (12 - this.labelWidth),
- cn: [
- inputblock
- ]
- }
-
- ];
+ cfg.cn = [
+ {
+ tag: 'label',
+ 'for' : id,
+ cls : 'control-label',
+ html : this.fieldLabel
+ },
+ {
+ cls : "",
+ cn: [
+ inputblock
+ ]
+ }
+
+ ];
+
+ if(this.labelWidth > 12){
+ cfg.cn[0].style = "width: " + this.labelWidth + 'px';
+ }
+
+ if(this.labelWidth < 13 && this.labelmd == 0){
+ this.labelmd = this.labelWidth;
+ }
+
+ if(this.labellg > 0){
+ cfg.cn[0].cls += ' col-lg-' + this.labellg;
+ cfg.cn[1].cls += ' col-lg-' + (12 - this.labellg);
+ }
+
+ if(this.labelmd > 0){
+ cfg.cn[0].cls += ' col-md-' + this.labelmd;
+ cfg.cn[1].cls += ' col-md-' + (12 - this.labelmd);
+ }
+
+ if(this.labelsm > 0){
+ cfg.cn[0].cls += ' col-sm-' + this.labelsm;
+ cfg.cn[1].cls += ' col-sm-' + (12 - this.labelsm);
+ }
+
+ if(this.labelxs > 0){
+ cfg.cn[0].cls += ' col-xs-' + this.labelxs;
+ cfg.cn[1].cls += ' col-xs-' + (12 - this.labelxs);
+ }
+
} else if ( this.fieldLabel.length) {
-// Roo.log(" label");
- cfg.cn = [
-
- {
- tag: 'label',
- //cls : 'input-group-addon',
- html : this.fieldLabel
-
- },
-
- inputblock
-
- ];
+ cfg.cn = [
+
+ {
+ tag: 'label',
+ //cls : 'input-group-addon',
+ html : this.fieldLabel
+
+ },
+
+ inputblock
+
+ ];
} else {
-
-// Roo.log(" no label && no align");
- cfg.cn = [
-
- inputblock
-
- ];
-
+
+ cfg.cn = [
+
+ inputblock
+
+ ];
}
combobox.cls += ' roo-select2-container-multi';
}
- if (align ==='left' && this.fieldLabel.length && this.labelWidth) {
+ if (align ==='left' && this.fieldLabel.length) {
-// Roo.log("left and has label");
+ cfg.cls += ' roo-form-group-label-left';
+
cfg.cn = [
{
tag : 'i',
{
tag: 'label',
'for' : id,
- cls : 'control-label col-sm-' + this.labelWidth,
+ cls : 'control-label',
html : this.fieldLabel
},
{
- cls : "col-sm-" + (12 - this.labelWidth),
+ cls : "",
cn: [
combobox
]
];
+ var labelCfg = cfg.cn[1];
+ var contentCfg = cfg.cn[2];
+
if(this.indicatorpos == 'right'){
cfg.cn = [
{
tag: 'label',
'for' : id,
- cls : 'control-label col-sm-' + this.labelWidth,
- html : this.fieldLabel
-
- },
- {
- tag : 'i',
- cls : 'roo-required-indicator right-indicator text-danger fa fa-lg fa-star',
- tooltip : 'This field is required'
+ cls : 'control-label',
+ cn : [
+ {
+ tag : 'span',
+ html : this.fieldLabel
+ },
+ {
+ tag : 'i',
+ cls : 'roo-required-indicator right-indicator text-danger fa fa-lg fa-star',
+ tooltip : 'This field is required'
+ }
+ ]
},
{
- cls : "col-sm-" + (12 - this.labelWidth),
+ cls : "",
cn: [
combobox
]
}
];
+
+ labelCfg = cfg.cn[0];
+ contentCfg = cfg.cn[1];
+ }
+
+ if(this.labelWidth > 12){
+ labelCfg.style = "width: " + this.labelWidth + 'px';
+ }
+
+ if(this.labelWidth < 13 && this.labelmd == 0){
+ this.labelmd = this.labelWidth;
+ }
+
+ if(this.labellg > 0){
+ labelCfg.cls += ' col-lg-' + this.labellg;
+ contentCfg.cls += ' col-lg-' + (12 - this.labellg);
+ }
+
+ if(this.labelmd > 0){
+ labelCfg.cls += ' col-md-' + this.labelmd;
+ contentCfg.cls += ' col-md-' + (12 - this.labelmd);
+ }
+
+ if(this.labelsm > 0){
+ labelCfg.cls += ' col-sm-' + this.labelsm;
+ contentCfg.cls += ' col-sm-' + (12 - this.labelsm);
+ }
+
+ if(this.labelxs > 0){
+ labelCfg.cls += ' col-xs-' + this.labelxs;
+ contentCfg.cls += ' col-xs-' + (12 - this.labelxs);
}
} else if ( this.fieldLabel.length) {
cfg.cn = [
{
tag: 'label',
- //cls : 'input-group-addon',
- html : this.fieldLabel
+ cn : [
+ {
+ tag : 'span',
+ html : this.fieldLabel
+ },
+ {
+ tag : 'i',
+ cls : 'roo-required-indicator right-indicator text-danger fa fa-lg fa-star',
+ tooltip : 'This field is required'
+ }
+ ]
},
- {
- tag : 'i',
- cls : 'roo-required-indicator right-indicator text-danger fa fa-lg fa-star',
- tooltip : 'This field is required'
- },
-
combobox
];
}
-
+
var settings=this;
['xs','sm','md','lg'].map(function(size){
if (settings[size]) {
// element that contains real text value.. (when hidden is used..)
getAutoCreate : function()
- {
+ {
var cfg = false;
-
+ //render
/*
* Render classic select for iso
*/
*/
if(!this.tickable){
cfg = Roo.bootstrap.ComboBox.superclass.getAutoCreate.call(this);
+ if(this.name == 'info_year_invest_id_display_name'){
+ Roo.log('cfg.................................................');
+ Roo.log(cfg);
+ }
return cfg;
}
tag: 'li',
cls: 'roo-select2-search-field',
cn: [
-
buttons
]
}
combobox.cn.push(feedback);
}
- if (align ==='left' && this.fieldLabel.length && this.labelWidth) {
+
+ if (align ==='left' && this.fieldLabel.length) {
+
+ cfg.cls += ' roo-form-group-label-left';
-// Roo.log("left and has label");
cfg.cn = [
{
tag : 'i',
{
tag: 'label',
'for' : id,
- cls : 'control-label col-sm-' + this.labelWidth,
+ cls : 'control-label',
html : this.fieldLabel
},
{
- cls : "col-sm-" + (12 - this.labelWidth),
+ cls : "",
cn: [
combobox
]
}
];
+
+ var labelCfg = cfg.cn[1];
+ var contentCfg = cfg.cn[2];
+
if(this.indicatorpos == 'right'){
{
tag: 'label',
'for' : id,
- cls : 'control-label col-sm-' + this.labelWidth,
- html : this.fieldLabel
-
- },
- {
- tag : 'i',
- cls : 'roo-required-indicator right-indicator text-danger fa fa-lg fa-star',
- tooltip : 'This field is required'
+ cls : 'control-label',
+ cn : [
+ {
+ tag : 'span',
+ html : this.fieldLabel
+ },
+ {
+ tag : 'i',
+ cls : 'roo-required-indicator right-indicator text-danger fa fa-lg fa-star',
+ tooltip : 'This field is required'
+ }
+ ]
},
{
- cls : "col-sm-" + (12 - this.labelWidth),
+ cls : "",
cn: [
combobox
]
}
];
+
+
+
+ labelCfg = cfg.cn[0];
+ contentCfg = cfg.cn[1];
+
+ }
+
+ if(this.labelWidth > 12){
+ labelCfg.style = "width: " + this.labelWidth + 'px';
+ }
+
+ if(this.labelWidth < 13 && this.labelmd == 0){
+ this.labelmd = this.labelWidth;
+ }
+
+ if(this.labellg > 0){
+ labelCfg.cls += ' col-lg-' + this.labellg;
+ contentCfg.cls += ' col-lg-' + (12 - this.labellg);
+ }
+
+ if(this.labelmd > 0){
+ labelCfg.cls += ' col-md-' + this.labelmd;
+ contentCfg.cls += ' col-md-' + (12 - this.labelmd);
+ }
+
+ if(this.labelsm > 0){
+ labelCfg.cls += ' col-sm-' + this.labelsm;
+ contentCfg.cls += ' col-sm-' + (12 - this.labelsm);
+ }
+ if(this.labelxs > 0){
+ labelCfg.cls += ' col-xs-' + this.labelxs;
+ contentCfg.cls += ' col-xs-' + (12 - this.labelxs);
}
{
tag: 'label',
//cls : 'input-group-addon',
- html : this.fieldLabel
-
+ cn : [
+ {
+ tag : 'span',
+ html : this.fieldLabel
+ },
+ {
+ tag : 'i',
+ cls : 'roo-required-indicator right-indicator text-danger fa fa-lg fa-star',
+ tooltip : 'This field is required'
+ }
+ ]
},
- {
- tag : 'i',
- cls : 'roo-required-indicator right-indicator text-danger fa fa-lg fa-star',
- tooltip : 'This field is required'
- },
+
combobox
this.list.on('scroll', this.onViewScroll, this);
if(!this.tpl){
- this.tpl = '<li class="roo-select2-result"><div class="checkbox"><input id="{roo-id}" type="checkbox" {roo-data-checked}><label for="{roo-id}"><b>{' + this.displayField + '}</b></label></li>';
+ this.tpl = '<li class="roo-select2-result"><div class="checkbox"><input id="{roo-id}" type="checkbox" {roo-data-checked}><label for="{roo-id}"><b>{' + this.displayField + '}</b></label></div></li>';
}
this.view = new Roo.View(this.list, this.tpl, {
this.tickableInputEl().on("keyup", this.onKeyUp, this);
}
+ this.indicator = this.indicatorEl();
+
+ if(this.indicator){
+ this.indicator.setVisibilityMode(Roo.Element.DISPLAY);
+ this.indicator.hide();
+ }
+
},
onDestroy : function(){
var align = this.labelAlign || this.parentLabelAlign();
- cfg.cn = combobox;
-
- if(this.fieldLabel.length && this.labelWidth){
-
- var lw = align === 'left' ? ('col-sm' + this.labelWidth) : '';
- var cw = align === 'left' ? ('col-sm' + (12 - this.labelWidth)) : '';
-
+ if (align ==='left' && this.fieldLabel.length) {
+
cfg.cn = [
{
tag : 'i',
},
{
tag: 'label',
- cls : 'control-label ' + lw,
+ cls : 'control-label',
html : this.fieldLabel
},
{
- cls : cw,
+ cls : '',
cn: [
combobox
]
}
];
+ var labelCfg = cfg.cn[1];
+ var contentCfg = cfg.cn[2];
+
+
if(this.indicatorpos == 'right'){
cfg.cn = [
{
tag: 'label',
- cls : 'control-label ' + lw,
- html : this.fieldLabel
-
+ cls : 'control-label',
+ html : this.fieldLabel,
+ cn : [
+ {
+ tag : 'i',
+ cls : 'roo-required-indicator right-indicator text-danger fa fa-lg fa-star',
+ tooltip : 'This field is required'
+ }
+ ]
},
{
- tag : 'i',
- cls : 'roo-required-indicator right-indicator text-danger fa fa-lg fa-star',
- tooltip : 'This field is required'
+ cls : '',
+ cn: [
+ combobox
+ ]
+ }
+ ];
+ }
+
+ labelCfg = cfg.cn[0];
+ contentCfg = cfg.cn[2];
+
+ if(this.labelWidth > 12){
+ labelCfg.style = "width: " + this.labelWidth + 'px';
+ }
+
+ if(this.labelWidth < 13 && this.labelmd == 0){
+ this.labelmd = this.labelWidth;
+ }
+
+ if(this.labellg > 0){
+ labelCfg.cls += ' col-lg-' + this.labellg;
+ contentCfg.cls += ' col-lg-' + (12 - this.labellg);
+ }
+
+ if(this.labelmd > 0){
+ labelCfg.cls += ' col-md-' + this.labelmd;
+ contentCfg.cls += ' col-md-' + (12 - this.labelmd);
+ }
+
+ if(this.labelsm > 0){
+ labelCfg.cls += ' col-sm-' + this.labelsm;
+ contentCfg.cls += ' col-sm-' + (12 - this.labelsm);
+ }
+
+ if(this.labelxs > 0){
+ labelCfg.cls += ' col-xs-' + this.labelxs;
+ contentCfg.cls += ' col-xs-' + (12 - this.labelxs);
+ }
+
+
+ } else if ( this.fieldLabel.length) {
+ cfg.cn = [
+ {
+ tag : 'i',
+ cls : 'roo-required-indicator left-indicator text-danger fa fa-lg fa-star',
+ tooltip : 'This field is required'
+ },
+ {
+ tag: 'label',
+ cls : 'control-label',
+ html : this.fieldLabel
+
+ },
+ {
+ cls : '',
+ cn: [
+ combobox
+ ]
+ }
+ ];
+
+ if(this.indicatorpos == 'right'){
+ cfg.cn = [
+ {
+ tag: 'label',
+ cls : 'control-label',
+ html : this.fieldLabel,
+ cn : [
+ {
+ tag : 'i',
+ cls : 'roo-required-indicator right-indicator text-danger fa fa-lg fa-star',
+ tooltip : 'This field is required'
+ }
+ ]
},
{
- cls : cw,
+ cls : '',
cn: [
combobox
]
}
];
}
+ } else {
+ cfg.cn = combobox;
}
+
var settings = this;
['xs','sm','md','lg'].map(function(size){
if (align ==='left' && this.fieldLabel.length) {
// Roo.log("left and has label");
- cfg.cn = [
-
- {
- tag: 'label',
- 'for' : id,
- cls : 'control-label col-md-' + this.labelWidth,
- html : this.fieldLabel
-
- },
- {
- cls : "col-md-" + (12 - this.labelWidth),
- cn: [
- inputblock
- ]
- }
-
- ];
+ cfg.cn = [
+ {
+ tag: 'label',
+ 'for' : id,
+ cls : 'control-label',
+ html : this.fieldLabel
+
+ },
+ {
+ cls : "",
+ cn: [
+ inputblock
+ ]
+ }
+ ];
+
+ if(this.labelWidth > 12){
+ cfg.cn[0].style = "width: " + this.labelWidth + 'px';
+ }
+
+ if(this.labelWidth < 13 && this.labelmd == 0){
+ this.labelmd = this.labelWidth;
+ }
+
+ if(this.labellg > 0){
+ cfg.cn[0].cls += ' col-lg-' + this.labellg;
+ cfg.cn[1].cls += ' col-lg-' + (12 - this.labellg);
+ }
+
+ if(this.labelmd > 0){
+ cfg.cn[0].cls += ' col-md-' + this.labelmd;
+ cfg.cn[1].cls += ' col-md-' + (12 - this.labelmd);
+ }
+
+ if(this.labelsm > 0){
+ cfg.cn[0].cls += ' col-sm-' + this.labelsm;
+ cfg.cn[1].cls += ' col-sm-' + (12 - this.labelsm);
+ }
+
+ if(this.labelxs > 0){
+ cfg.cn[0].cls += ' col-xs-' + this.labelxs;
+ cfg.cn[1].cls += ' col-xs-' + (12 - this.labelxs);
+ }
+
} else if ( this.fieldLabel.length) {
// Roo.log(" label");
cfg.cn = [
{
if(!this.groupId){
return (this.getValue() == this.inputValue || this.allowBlank) ? true : false;
+ //return (this.getValue() == this.inputValue) ? true : false;
}
var group = Roo.bootstrap.CheckBox.get(this.groupId);
return;
}
-
+
if(!this.groupId){
this.el.findParent('.form-group', false, true).removeClass([this.invalidClass, this.validClass]);
this.el.findParent('.form-group', false, true).addClass(this.validClass);
}
var group = Roo.bootstrap.CheckBox.get(this.groupId);
-
+
if(!group){
return;
}
{
Roo.bootstrap.Input.prototype.clearInvalid.call(this);
+ // this.el.findParent('.form-group', false, true).removeClass([this.invalidClass, this.validClass]);
+
var label = Roo.bootstrap.FieldLabel.get(this.name + '-group');
if (label) {
});
- //<script type="text/javascript">
+ /*
+ * - LGPL
+ *
+ * Input
+ *
+ */
+
+/**
+ * @class Roo.bootstrap.SecurePass
+ * @extends Roo.bootstrap.Input
+ * Bootstrap SecurePass class
+ *
+ *
+ * @constructor
+ * Create a new SecurePass
+ * @param {Object} config The config object
+ */
+
+Roo.bootstrap.SecurePass = function (config) {
+ // these go here, so the translation tool can replace them..
+ this.errors = {
+ PwdEmpty: "Please type a password, and then retype it to confirm.",
+ PwdShort: "Your password must be at least 6 characters long. Please type a different password.",
+ PwdLong: "Your password can't contain more than 16 characters. Please type a different password.",
+ PwdBadChar: "The password contains characters that aren't allowed. Please type a different password.",
+ IDInPwd: "Your password can't include the part of your ID. Please type a different password.",
+ FNInPwd: "Your password can't contain your first name. Please type a different password.",
+ LNInPwd: "Your password can't contain your last name. Please type a different password.",
+ TooWeak: "Your password is Too Weak."
+ },
+ this.meterLabel = "Password strength:";
+ this.pwdStrengths = ["Too Weak", "Weak", "Medium", "Strong"];
+ this.meterClass = ["roo-password-meter-tooweak",
+ "roo-password-meter-weak",
+ "roo-password-meter-medium",
+ "roo-password-meter-strong",
+ "roo-password-meter-grey"],
+ Roo.bootstrap.SecurePass.superclass.constructor.call(this, config);
+}
+
+Roo.extend(Roo.bootstrap.SecurePass, Roo.bootstrap.Input, {
+ /**
+ * @cfg {String/Object} errors A Error spec, or true for a default spec (defaults to
+ * {
+ * PwdEmpty: "Please type a password, and then retype it to confirm.",
+ * PwdShort: "Your password must be at least 6 characters long. Please type a different password.",
+ * PwdLong: "Your password can't contain more than 16 characters. Please type a different password.",
+ * PwdBadChar: "The password contains characters that aren't allowed. Please type a different password.",
+ * IDInPwd: "Your password can't include the part of your ID. Please type a different password.",
+ * FNInPwd: "Your password can't contain your first name. Please type a different password.",
+ * LNInPwd: "Your password can't contain your last name. Please type a different password."
+ * })
+ */
+ // private
+
+ meterWidth: 300,
+ errorMsg :'',
+ errors: {},
+ imageRoot: '/',
+ /**
+ * @cfg {String/Object} Label for the strength meter (defaults to
+ * 'Password strength:')
+ */
+ // private
+ meterLabel: '',
+ /**
+ * @cfg {String/Object} pwdStrengths A pwdStrengths spec, or true for a default spec (defaults to
+ * ['Weak', 'Medium', 'Strong'])
+ */
+ // private
+ pwdStrengths: [],
+ // private
+ strength: 0,
+ // private
+ _lastPwd: null,
+ // private
+ kCapitalLetter: 0,
+ kSmallLetter: 1,
+ kDigit: 2,
+ kPunctuation: 3,
+
+ insecure: false,
+ // private
+ initEvents: function () {
+ Roo.bootstrap.SecurePass.superclass.initEvents.call(this);
+
+ if (this.el.is('input[type=password]') && Roo.isSafari) {
+ this.el.on('keydown', this.SafariOnKeyDown, this);
+ }
+
+ this.el.on('keyup', this.checkStrength, this, {buffer: 50});
+ },
+ // private
+ onRender: function (ct, position) {
+ Roo.bootstrap.SecurePass.superclass.onRender.call(this, ct, position);
+ this.wrap = this.el.wrap({cls: 'x-form-field-wrap'});
+ this.trigger = this.wrap.createChild({tag: 'div', cls: 'StrengthMeter ' + this.triggerClass});
+
+ this.trigger.createChild({
+ cn: [
+ {
+ //id: 'PwdMeter',
+ tag: 'div',
+ cls: 'roo-password-meter-grey col-xs-12',
+ style: {
+ //width: 0,
+ //width: this.meterWidth + 'px'
+ }
+ },
+ {
+ cls: 'roo-password-meter-text'
+ }
+ ]
+ });
+
+ /*
+ this.trigger.createChild({
+ tag: 'div',
+ cls: 'roo-password-meter-container col-xs-12',
+ style: {
+ //width: this.meterWidth + 'px'
+ },
+ cn: {
+ tag: 'div',
+ cls: 'roo-password-meter-grey',
+ style: {
+ //width: this.meterWidth + 'px'
+ },
+ cn: [
+ {
+ //id: 'PwdMeter',
+ tag: 'div',
+ cls: 'roo-password-meter-grey col-xs-12',
+ style: {
+ //width: 0,
+ //width: this.meterWidth + 'px'
+ }
+ },
+ {
+ cls: 'roo-password-meter-text'
+ }
+ ]
+ }
+ });
+ */
+ if (this.hideTrigger) {
+ this.trigger.setDisplayed(false);
+ }
+ this.setSize(this.width || '', this.height || '');
+ },
+ // private
+ onDestroy: function () {
+ if (this.trigger) {
+ this.trigger.removeAllListeners();
+ this.trigger.remove();
+ }
+ if (this.wrap) {
+ this.wrap.remove();
+ }
+ Roo.bootstrap.TriggerField.superclass.onDestroy.call(this);
+ },
+ // private
+ checkStrength: function () {
+ var pwd = this.inputEl().getValue();
+ if (pwd == this._lastPwd) {
+ return;
+ }
+
+ var strength;
+ if (this.ClientSideStrongPassword(pwd)) {
+ strength = 3;
+ } else if (this.ClientSideMediumPassword(pwd)) {
+ strength = 2;
+ } else if (this.ClientSideWeakPassword(pwd)) {
+ strength = 1;
+ } else {
+ strength = 0;
+ }
+
+ console.log('strength1: ' + strength);
+
+ //var pm = this.trigger.child('div/div/div').dom;
+ var pm = this.trigger.child('div/div');
+ pm.removeClass(this.meterClass);
+ pm.addClass(this.meterClass[strength]);
+
+
+ var pt = this.trigger.child('/div').child('>*[class=roo-password-meter-text]').dom;
+
+ pt.innerHTML = this.meterLabel + ' ' + this.pwdStrengths[strength];
+
+ this._lastPwd = pwd;
+ },
+ reset: function () {
+ Roo.bootstrap.SecurePass.superclass.reset.call(this);
+
+ this._lastPwd = '';
+
+ var pm = this.trigger.child('div/div');
+ pm.removeClass(this.meterClass);
+ pm.addClass('roo-password-meter-grey');
+
+
+ var pt = this.trigger.child('/div').child('>*[class=roo-password-meter-text]').dom;
+
+ pt.innerHTML = '';
+ this.inputEl().dom.type='password';
+ },
+ // private
+ validateValue: function (value) {
+
+ if (!Roo.bootstrap.SecurePass.superclass.validateValue.call(this, value)) {
+ return false;
+ }
+ if (value.length == 0) {
+ if (this.allowBlank) {
+ this.clearInvalid();
+ return true;
+ }
+
+ this.markInvalid(this.errors.PwdEmpty);
+ this.errorMsg = this.errors.PwdEmpty;
+ return false;
+ }
+
+ if(this.insecure){
+ return true;
+ }
+
+ if ('[\x21-\x7e]*'.match(value)) {
+ this.markInvalid(this.errors.PwdBadChar);
+ this.errorMsg = this.errors.PwdBadChar;
+ return false;
+ }
+ if (value.length < 6) {
+ this.markInvalid(this.errors.PwdShort);
+ this.errorMsg = this.errors.PwdShort;
+ return false;
+ }
+ if (value.length > 16) {
+ this.markInvalid(this.errors.PwdLong);
+ this.errorMsg = this.errors.PwdLong;
+ return false;
+ }
+ var strength;
+ if (this.ClientSideStrongPassword(value)) {
+ strength = 3;
+ } else if (this.ClientSideMediumPassword(value)) {
+ strength = 2;
+ } else if (this.ClientSideWeakPassword(value)) {
+ strength = 1;
+ } else {
+ strength = 0;
+ }
+
+
+ if (strength < 2) {
+ //this.markInvalid(this.errors.TooWeak);
+ this.errorMsg = this.errors.TooWeak;
+ //return false;
+ }
+
+
+ console.log('strength2: ' + strength);
+
+ //var pm = this.trigger.child('div/div/div').dom;
+
+ var pm = this.trigger.child('div/div');
+ pm.removeClass(this.meterClass);
+ pm.addClass(this.meterClass[strength]);
+
+ var pt = this.trigger.child('/div').child('>*[class=roo-password-meter-text]').dom;
+
+ pt.innerHTML = this.meterLabel + ' ' + this.pwdStrengths[strength];
+
+ this.errorMsg = '';
+ return true;
+ },
+ // private
+ CharacterSetChecks: function (type) {
+ this.type = type;
+ this.fResult = false;
+ },
+ // private
+ isctype: function (character, type) {
+ switch (type) { //why needed break after return in js ? very odd bug
+ case this.kCapitalLetter:
+ if (character >= 'A' && character <= 'Z') {
+ return true;
+ }
+ break;
+ case this.kSmallLetter:
+ if (character >= 'a' && character <= 'z') {
+ return true;
+ }
+ break;
+ case this.kDigit:
+ if (character >= '0' && character <= '9') {
+ return true;
+ }
+ break;
+ case this.kPunctuation:
+ if ('!@#$%^&*()_+-=\'";:[{]}|.>,</?`~'.indexOf(character) >= 0) {
+ return true;
+ }
+ break;
+ default:
+ return false;
+ }
+
+ },
+ // private
+ IsLongEnough: function (pwd, size) {
+ return !(pwd == null || isNaN(size) || pwd.length < size);
+ },
+ // private
+ SpansEnoughCharacterSets: function (word, nb) {
+ if (!this.IsLongEnough(word, nb))
+ {
+ return false;
+ }
+
+ var characterSetChecks = new Array(
+ new this.CharacterSetChecks(this.kCapitalLetter), new this.CharacterSetChecks(this.kSmallLetter),
+ new this.CharacterSetChecks(this.kDigit), new this.CharacterSetChecks(this.kPunctuation));
+ for (var index = 0; index < word.length; ++index) {
+ for (var nCharSet = 0; nCharSet < characterSetChecks.length; ++nCharSet) {
+ if (!characterSetChecks[nCharSet].fResult && this.isctype(word.charAt(index), characterSetChecks[nCharSet].type)) {
+ characterSetChecks[nCharSet].fResult = true;
+ break;
+ }
+ }
+ }
+
+ var nCharSets = 0;
+ for (var nCharSet = 0; nCharSet < characterSetChecks.length; ++nCharSet) {
+ if (characterSetChecks[nCharSet].fResult) {
+ ++nCharSets;
+ }
+ }
+
+ if (nCharSets < nb) {
+ return false;
+ }
+ return true;
+ },
+ // private
+ ClientSideStrongPassword: function (pwd) {
+ return this.IsLongEnough(pwd, 8) && this.SpansEnoughCharacterSets(pwd, 3);
+ },
+ // private
+ ClientSideMediumPassword: function (pwd) {
+ return this.IsLongEnough(pwd, 7) && this.SpansEnoughCharacterSets(pwd, 2);
+ },
+ // private
+ ClientSideWeakPassword: function (pwd) {
+ return this.IsLongEnough(pwd, 6) || !this.IsLongEnough(pwd, 0);
+ }
+
+})//<script type="text/javascript">
/*
* Based Ext JS Library 1.1.1
Roo.bootstrap.Tooltip = function(config){
Roo.bootstrap.Tooltip.superclass.constructor.call(this, config);
+
+ this.alignment = Roo.bootstrap.Tooltip.alignment;
+
+ if(typeof(config) != 'undefined' && typeof(config.alignment) != 'undefined'){
+ this.alignment = config.alignment;
+ }
+
};
Roo.apply(Roo.bootstrap.Tooltip, {
placement : 'bottom',
+ alignment : false,
+
getAutoCreate : function(){
var cfg = {
}, delay);
},
- show : function ()
+ show : function (msg)
{
if (!this.el) {
this.render(document.body);
// set content.
//Roo.log([this.bindEl, this.bindEl.attr('tooltip')]);
- var tip = this.bindEl.attr('tooltip') || this.bindEl.select("[tooltip]").first().attr('tooltip');
+ var tip = msg || this.bindEl.attr('tooltip') || this.bindEl.select("[tooltip]").first().attr('tooltip');
this.el.select('.tooltip-inner',true).first().dom.innerHTML = tip;
// fixme..
}
- var align = Roo.bootstrap.Tooltip.alignment[placement];
+ var align = this.alignment[placement];
var xy = this.el.getAlignToXY(this.bindEl, align[0], align[1]);
}
- align = Roo.bootstrap.Tooltip.alignment[placement];
-
this.el.alignTo(this.bindEl, align[0],align[1]);
//var arrow = this.el.select('.arrow',true).first();
//arrow.set(align[2],
* @cfg {Number} labelWidth default 4
* @cfg {String} labelAlign (left|top) default left
* @cfg {Boolean} editable (true|false) allow edit when upload a image default true
+* @cfg {Number} labellg set the width of label (1-12)
+ * @cfg {Number} labelmd set the width of label (1-12)
+ * @cfg {Number} labelsm set the width of label (1-12)
+ * @cfg {Number} labelxs set the width of label (1-12)
*
* @constructor
* Create a new DocumentManager
delegates : false,
xhr : false,
+ labellg : 0,
+ labelmd : 0,
+ labelsm : 0,
+ labelxs : 0,
+
getAutoCreate : function()
{
var managerWidget = {
content = [
{
tag : 'div',
- cls : 'column col-md-' + this.labelWidth,
+ cls : 'column',
html : this.fieldLabel
},
{
tag : 'div',
- cls : 'column col-md-' + (12 - this.labelWidth),
+ cls : 'column',
cn : managerWidget
}
];
+ if(this.labelWidth > 12){
+ content[0].style = "width: " + this.labelWidth + 'px';
+ }
+
+ if(this.labelWidth < 13 && this.labelmd == 0){
+ this.labelmd = this.labelWidth;
+ }
+
+ if(this.labellg > 0){
+ content[0].cls += ' col-lg-' + this.labellg;
+ content[1].cls += ' col-lg-' + (12 - this.labellg);
+ }
+
+ if(this.labelmd > 0){
+ content[0].cls += ' col-md-' + this.labelmd;
+ content[1].cls += ' col-md-' + (12 - this.labelmd);
+ }
+
+ if(this.labelsm > 0){
+ content[0].cls += ' col-sm-' + this.labelsm;
+ content[1].cls += ' col-sm-' + (12 - this.labelsm);
+ }
+
+ if(this.labelxs > 0){
+ content[0].cls += ' col-xs-' + this.labelxs;
+ content[1].cls += ' col-xs-' + (12 - this.labelxs);
+ }
+
}
}
formData.append('mimetype', file.mimetype);
}
+ Roo.log(formData);
+
if(this.fireEvent('prepare', this, formData) != false){
this.xhr.send(formData);
};
* @cfg {string} dayFormat default 'd'
* @cfg {string} monthFormat default 'm'
* @cfg {string} yearFormat default 'Y'
+ * @cfg {Number} labellg set the width of label (1-12)
+ * @cfg {Number} labelmd set the width of label (1-12)
+ * @cfg {Number} labelsm set the width of label (1-12)
+ * @cfg {Number} labelxs set the width of label (1-12)
*
* @constructor
monthFormat : 'm',
yearFormat : 'Y',
isFormField : true,
+ labellg : 0,
+ labelmd : 0,
+ labelsm : 0,
+ labelxs : 0,
getAutoCreate : function()
{
]
};
+ var labelCls = 'col-md-12';
+ var contentCls = 'col-md-4';
+
if(this.fieldLabel){
- cfg.cn.push({
+
+ var label = {
tag : 'div',
cls : 'column roo-date-split-field-label col-md-' + ((this.labelAlign == 'top') ? '12' : this.labelWidth),
cn : [
html : this.fieldLabel
}
]
- });
+ };
+
+ if(this.labelAlign == 'left'){
+
+ if(this.labelWidth > 12){
+ label.style = "width: " + this.labelWidth + 'px';
+ }
+
+ if(this.labelWidth < 13 && this.labelmd == 0){
+ this.labelmd = this.labelWidth;
+ }
+
+ if(this.labellg > 0){
+ labelCls = ' col-lg-' + this.labellg;
+ contentCls = ' col-lg-' + ((12 - this.labellg) / 3);
+ }
+
+ if(this.labelmd > 0){
+ labelCls = ' col-md-' + this.labelmd;
+ contentCls = ' col-md-' + ((12 - this.labelmd) / 3);
+ }
+
+ if(this.labelsm > 0){
+ labelCls = ' col-sm-' + this.labelsm;
+ contentCls = ' col-sm-' + ((12 - this.labelsm) / 3);
+ }
+
+ if(this.labelxs > 0){
+ labelCls = ' col-xs-' + this.labelxs;
+ contentCls = ' col-xs-' + ((12 - this.labelxs) / 3);
+ }
+ }
+
+ label.cls += ' ' + labelCls;
+
+ cfg.cn.push(label);
}
Roo.each(['day', 'month', 'year'], function(t){
cfg.cn.push({
tag : 'div',
- cls : 'column roo-date-split-field-' + t + ' col-md-' + ((this.labelAlign == 'top') ? '4' : ((12 - this.labelWidth) / 3))
+ cls : 'column roo-date-split-field-' + t + ' ' + contentCls
});
}, this);
this.bricks = [];
+ this.addEvents({
+ // raw events
+ /**
+ * @event layout
+ * Fire after layout the items
+ * @param {Roo.bootstrap.LayoutMasonry} this
+ * @param {Roo.EventObject} e
+ */
+ "layout" : true
+ });
+
};
Roo.extend(Roo.bootstrap.LayoutMasonry, Roo.bootstrap.Component, {
resize : function()
{
- Roo.log('resize');
-
var cs = this.el.getBox(true);
- if (this.currentSize.width == cs.width && this.currentSize.x == cs.x ) {
- Roo.log("no change in with or X");
+ if (
+ this.currentSize.width == cs.width &&
+ this.currentSize.x == cs.x &&
+ this.currentSize.height == cs.height &&
+ this.currentSize.y == cs.y
+ ) {
+ Roo.log("no change in with or X or Y");
return;
}
this._isLayoutInited = true;
+ this.fireEvent('layout', this);
+
},
_resetLayout : function()
layoutItems : function( isInstant )
{
+ Roo.log(this.bricks);
+
var items = Roo.apply([], this.bricks);
if(this.isHorizontal){
return pos;
+ },
+
+ /**
+ * adds a Masonry Brick
+ * @param {Roo.bootstrap.MasonryBrick} the masonry brick to add
+ */
+ addItem : function(cfg)
+ {
+ var cn = new Roo.bootstrap.MasonryBrick(cfg);
+ //this.register(cn);
+ cn.parentId = this.id;
+ cn.onRender(this.el, null);
+ return cn;
+ },
+
+ /**
+ * register a Masonry Brick
+ * @param {Roo.bootstrap.MasonryBrick} the masonry brick to add
+ */
+ register : function(brick)
+ {
+ this.bricks.push(brick);
+ brick.masonryId = this.id;
+ },
+
+ /**
+ * clear all the Masonry Brick
+ */
+ clearAll : function()
+ {
+ this.bricks = [];
+ //this.getChildContainer().dom.innerHTML = "";
+ this.el.dom.innerHTML = '';
}
});
*/
href : '',
/**
- * @cfg {String} (xs|sm|md|md-left|md-right|tall|wide) size
+ * @cfg {String} size (xs|sm|md|md-left|md-right|tall|wide)
*/
size : 'xs',
/**
- * @cfg {String} (center|bottom) placetitle
+ * @cfg {String} placetitle (center|bottom)
*/
placetitle : '',
*/
preventDefault : false,
+ /**
+ * @cfg {Boolean} inverse defalut false
+ */
+ maskInverse : false,
+
getAutoCreate : function()
{
if(!this.isFitContainer){
cls += ' masonry-brick-image';
}
- if(!this.html.length){
+ if(this.maskInverse){
+ cls += ' mask-inverse';
+ }
+
+ if(!this.html.length && !this.maskInverse){
cls += ' enable-mask';
}
{
e.preventDefault();
- if(!this.isFitContainer){
+ if(!this.isFitContainer || this.maskInverse){
return;
}
{
e.preventDefault();
- if(!this.isFitContainer){
+ if(!this.isFitContainer || this.maskInverse){
return;
}
Roo.bootstrap.RadioSet = function(config){
Roo.bootstrap.RadioSet.superclass.constructor.call(this, config);
-
+
this.radioes = [];
Roo.bootstrap.RadioSet.register(this);
weight : '',
- fieldLabel : '',
-
indicatorpos : 'left',
getAutoCreate : function()
if (align === 'left' && this.fieldLabel.length) {
- label.cls += ' col-md-' + this.labelWidth;
-
items = {
- cls : "col-md-" + (12 - this.labelWidth),
+ cls : "roo-radio-set-right",
cn: [
items
]
};
+
+ if(this.labelWidth > 12){
+ label.style = "width: " + this.labelWidth + 'px';
+ }
+
+ if(this.labelWidth < 13 && this.labelmd == 0){
+ this.labelmd = this.labelWidth;
+ }
+
+ if(this.labellg > 0){
+ label.cls += ' col-lg-' + this.labellg;
+ items.cls += ' col-lg-' + (12 - this.labellg);
+ }
+
+ if(this.labelmd > 0){
+ label.cls += ' col-md-' + this.labelmd;
+ items.cls += ' col-md-' + (12 - this.labelmd);
+ }
+
+ if(this.labelsm > 0){
+ label.cls += ' col-sm-' + this.labelsm;
+ items.cls += ' col-sm-' + (12 - this.labelsm);
+ }
+
+ if(this.labelxs > 0){
+ label.cls += ' col-xs-' + this.labelxs;
+ items.cls += ' col-xs-' + (12 - this.labelxs);
+ }
}
var cfg = {
{
tag : 'input',
cls : 'roo-radio-set-input',
- type : 'text',
+ type : 'hidden',
name : this.name,
value : this.value ? this.value : ''
},
return false;
});
- if(this.disabled || this.allowBlank || valid){
+ if(this.allowBlank) {
+ return true;
+ }
+
+ if(this.disabled || valid){
this.markValid();
return true;
}
this.indicatorEl().hide();
}
- this.el.removeClass([this.invalidClass, this.validClass]);
+ this.el.removeClass([this.invalidClass]);
this.fireEvent('valid', this);
}
}
if(this.toolbar){
var te = this.toolbar.getEl();
- height -= te.getHeight();
te.setWidth(width);
+ height -= te.getHeight();
}
if(this.footer){
var te = this.footer.getEl();
- Roo.log("footer:" + te.getHeight());
-
- height -= te.getHeight();
te.setWidth(width);
+ height -= te.getHeight();
}
* @return {String}
*/
getTitle : function(){
- return this.title;
+
+ if (typeof(this.title) != 'object') {
+ return this.title;
+ }
+
+ var t = '';
+ for (var k in this.title) {
+ if (!this.title.hasOwnProperty(k)) {
+ continue;
+ }
+
+ if (k.indexOf('-') >= 0) {
+ var s = k.split('-');
+ for (var i = 0; i<s.length; i++) {
+ t += "<span class='visible-"+s[i]+"'>"+this.title[k]+"</span>";
+ }
+ } else {
+ t += "<span class='visible-"+k+"'>"+this.title[k]+"</span>";
+ }
+ }
+ return t;
},
/**
projects / roojs1 / blobdiff