时间控件，点击闪烁问题修改

src/main/webapp/webpage/modules/ProjectFollowReport/ProjectFollowReportList.jsp

@@ -35,11 +35,13 @@
 				elem: '#beginDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
 				event: 'focus', //响应事件。如果没有传入event，则按照默认的click
 				type : 'date'
+, trigger: 'click'
 			});
 			laydate.render({
 				elem: '#endDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
 				event: 'focus', //响应事件。如果没有传入event，则按照默认的click
 				type : 'date'
+, trigger: 'click'
 			});
 		});
 

src/main/webapp/webpage/modules/leaveapply/leaveApplyBackModifyApply.jsp

@@ -44,7 +44,8 @@
             laydate.render({
                 elem: '#backTime',
                 event: 'focus',
-                type : 'date',
+                type : 'date'
+, trigger: 'click',
                 done: function(value){//日期时间被切换后的回调
                     setContrast();
                 }

src/main/webapp/webpage/modules/leaveapply/leaveApplyExtendForm.jsp

@@ -38,7 +38,8 @@
                 laydate.render({
                     elem: this,
                     event: 'focus',
-                    type : 'date',
+                    type : 'date'
+, trigger: 'click',
                     done: function(value){//日期时间被切换后的回调
                         changeDate(this,1);
                     }
@@ -101,7 +102,8 @@
                 laydate.render({
                     elem: this,
                     event: 'focus',
-                    type : 'date',
+                    type : 'date'
+, trigger: 'click',
                     done: function(value){//日期时间被切换后的回调
                         changeDate(this,1);
                     }

src/main/webapp/webpage/modules/leaveapply/leaveApplyExtendModifyApply.jsp

@@ -38,7 +38,8 @@
                 laydate.render({
                     elem: this,
                     event: 'focus',
-                    type : 'date',
+                    type : 'date'
+, trigger: 'click',
                     done: function(value){//日期时间被切换后的回调
                         changeDate(this,1);
                     }
@@ -101,7 +102,8 @@
                 laydate.render({
                     elem: this,
                     event: 'focus',
-                    type : 'date',
+                    type : 'date'
+, trigger: 'click',
                     done: function(value){//日期时间被切换后的回调
                         changeDate(this,1);
                     }

src/main/webapp/webpage/modules/leaveapply/leaveApplyForm.jsp

@@ -43,7 +43,8 @@
                 laydate.render({
                     elem: this,
                     event: 'focus',
-                    type : 'date',
+                    type : 'date'
+, trigger: 'click',
                     done: function(value){//日期时间被切换后的回调
                         changeDate(this,1);
                     }
@@ -120,7 +121,8 @@
                 laydate.render({
                     elem: this,
                     event: 'focus',
-                    type : 'date',
+                    type : 'date'
+, trigger: 'click',
                     done: function(value){//日期时间被切换后的回调
                         changeDate(this,1);
                     }

src/main/webapp/webpage/modules/leaveapply/leaveApplyList.jsp

@@ -244,12 +244,14 @@
             elem: '#beginDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
             format: 'yyyy-MM-dd',
             type : 'date'
+, trigger: 'click'
         });
 
         laydate.render({
             elem: '#endDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
             format: 'yyyy-MM-dd',
             type : 'date'
+, trigger: 'click'
         });
 
     });

src/main/webapp/webpage/modules/leaveapply/leaveApplyModifyApply.jsp

@@ -41,7 +41,8 @@
                 laydate.render({
                     elem: this,
                     event: 'focus',
-                    type : 'date',
+                    type : 'date'
+, trigger: 'click',
                     done: function(value){//日期时间被切换后的回调
                         changeDate(this,1);
                     }
@@ -111,7 +112,8 @@
                 laydate.render({
                     elem: this,
                     event: 'focus',
-                    type : 'date',
+                    type : 'date'
+, trigger: 'click',
                     done: function(value){//日期时间被切换后的回调
                         changeDate(this,1);
                     }

src/main/webapp/webpage/modules/leaveapply/leaveApplyView.jsp

@@ -44,7 +44,8 @@
             laydate.render({
                 elem: '#backTime',
                 event: 'focus',
-                type : 'date',
+                type : 'date'
+, trigger: 'click',
                 done: function(value){//日期时间被切换后的回调
                     setContrast();
                     }

src/main/webapp/webpage/modules/leaveapply/leaveMangeList.jsp

@@ -169,12 +169,14 @@
             elem: '#beginDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
             format: 'yyyy-MM-dd',
             type : 'date'
+, trigger: 'click'
         });
 
         laydate.render({
             elem: '#endDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
             format: 'yyyy-MM-dd',
             type : 'date'
+, trigger: 'click'
         });
 
     });

src/main/webapp/webpage/modules/oa/manageCalendarDetailsAll.jsp

@@ -20,12 +20,14 @@
                 elem: '#beginDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 format: 'yyyy-MM-dd',
                 type : 'date'
+, trigger: 'click'
             });
 
             laydate.render({
                 elem: '#endDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 format: 'yyyy-MM-dd',
                 type : 'date'
+, trigger: 'click'
             });
         })
 

src/main/webapp/webpage/modules/oa/manageCalendarDetailsSelf.jsp

@@ -20,12 +20,14 @@
                 elem: '#beginDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 format: 'yyyy-MM-dd',
                 type : 'date'
+, trigger: 'click'
             });
 
             laydate.render({
                 elem: '#endDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 format: 'yyyy-MM-dd',
                 type : 'date'
+, trigger: 'click'
             });
         })
 

src/main/webapp/webpage/modules/projectAccessory/projectAccessoryRelation/projectAccessoryRelationList.jsp

@@ -34,11 +34,13 @@
 				elem: '#beginDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
 				event: 'focus', //响应事件。如果没有传入event，则按照默认的click
 				type : 'date'
+, trigger: 'click'
 			});
 			laydate.render({
 				elem: '#endDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
 				event: 'focus', //响应事件。如果没有传入event，则按照默认的click
 				type : 'date'
+, trigger: 'click'
 			});
 		});
 

src/main/webapp/webpage/modules/projectConstruction/contractList.jsp

@@ -35,11 +35,13 @@
                 elem: '#beginDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
             });
             laydate.render({
                 elem: '#endDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
             });
         });
 

src/main/webapp/webpage/modules/projectConstruction/projectConstructionList.jsp

@@ -35,11 +35,13 @@
 				elem: '#beginDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
 				event: 'focus', //响应事件。如果没有传入event，则按照默认的click
 				type : 'date'
+, trigger: 'click'
 			});
 			laydate.render({
 				elem: '#endDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
 				event: 'focus', //响应事件。如果没有传入event，则按照默认的click
 				type : 'date'
+, trigger: 'click'
 			});
 		});
 

src/main/webapp/webpage/modules/projectcontentinfo/basedDataForm.jsp

@@ -46,6 +46,7 @@
                 elem: '#provideDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
             });
             $("#attachment_btn").click(function () {
                 $("#attachment_file").click();

src/main/webapp/webpage/modules/projectcontentinfo/basedDataList.jsp

@@ -23,11 +23,13 @@
                 elem: '#beginDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
             });
             laydate.render({
                 elem: '#endDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
             });
         });
         function switchInput(obj){

src/main/webapp/webpage/modules/projectcontentinfo/basedDataView.jsp

@@ -34,11 +34,13 @@
                 elem: '#uploadDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
             });
             laydate.render({
                 elem: '#provideDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
             });
         });
 	</script>

src/main/webapp/webpage/modules/projectcontentinfo/projectReportDataList.jsp

@@ -23,21 +23,25 @@
                 elem: '#startDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
             });
             laydate.render({
                 elem: '#endDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
             });
             laydate.render({
                 elem: '#createStartDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
             });
             laydate.render({
                 elem: '#createEndDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
             });
         });
 

src/main/webapp/webpage/modules/projectcontentinfo/projectReportRecordList.jsp

@@ -23,11 +23,13 @@
                 elem: '#beginDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
             });
             laydate.render({
                 elem: '#endDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
             });
         });
         function openDialogre(title,url,width,height,target){

src/main/webapp/webpage/modules/projectcontentinfo/projectcontentinfoList.jsp

@@ -22,11 +22,13 @@
                 elem: '#beginDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
             });
             laydate.render({
                 elem: '#endDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
             });
         });
 

src/main/webapp/webpage/modules/projectcontentinfo/reportChange.jsp

@@ -137,6 +137,7 @@
                 elem: '#reportDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
             });
             $("#attachment_btn").click(function () {
                 $("#attachment_file").click();

src/main/webapp/webpage/modules/projectcontentinfo/reportChangeList.jsp

@@ -23,11 +23,13 @@
                 elem: '#beginDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
             });
             laydate.render({
                 elem: '#endDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
             });
         });
         function switchInput(obj){

src/main/webapp/webpage/modules/projectcontentinfo/reportChangeModifyApply.jsp

@@ -42,6 +42,7 @@
                 elem: '#reportDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
             });
             $("#attachment_btn").click(function () {
                 $("#attachment_file").click();

src/main/webapp/webpage/modules/projectcontentinfo/reportForm.jsp

@@ -143,6 +143,7 @@
                 elem: '#reportDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
             });
             $("#attachment_btn").click(function () {
                 $("#attachment_file").click();

src/main/webapp/webpage/modules/projectcontentinfo/reportInvalid.jsp

@@ -39,6 +39,7 @@
                 elem: '#reportDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
             });
             $("#attachment_btn").click(function () {
                 $("#attachment_file").click();

src/main/webapp/webpage/modules/projectcontentinfo/reportInvalidList.jsp

@@ -23,11 +23,13 @@
                 elem: '#beginDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
             });
             laydate.render({
                 elem: '#endDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
             });
         });
         function switchInput(obj){

src/main/webapp/webpage/modules/projectcontentinfo/reportInvalidModifyApply.jsp

@@ -42,6 +42,7 @@
                 elem: '#reportDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
             });
             $("#attachment_btn").click(function () {
                 $("#attachment_file").click();

src/main/webapp/webpage/modules/projectcontentinfo/reportList.jsp

@@ -23,11 +23,13 @@
                 elem: '#beginDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
             });
             laydate.render({
                 elem: '#endDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
             });
         });
         function switchInput(obj){

src/main/webapp/webpage/modules/projectcontentinfo/reportModifyApply.jsp

@@ -47,6 +47,7 @@
                 elem: '#reportDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
             });
             $("#attachment_btn").click(function () {
                 $("#attachment_file").click();

src/main/webapp/webpage/modules/projectcontentinfo/workContentForm.jsp

@@ -91,6 +91,7 @@
                 elem: '#createDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
             });*/
             changeContentDetail(document.getElementById("projectContentDataType"));
             var tp = "${projectcontentinfo.dictType}";

src/main/webapp/webpage/modules/projectcontentinfo/workContentView.jsp

@@ -66,6 +66,7 @@
                 elem: '#createDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
             });*/
             changeContentDetail("${projectcontentinfo.projectContentData.type}");
             var tp = "${projectcontentinfo.dictType}";

src/main/webapp/webpage/modules/projectcontroltable/projectControlTableForm.jsp

@@ -30,22 +30,26 @@
                 elem: '#billHandTime', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
             });
             laydate.render({
                 elem: '#askTime', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
             });
 
             laydate.render({
                 elem: '#startDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 format: 'yyyy-MM-dd',
                 type : 'date'
+, trigger: 'click'
             });
             laydate.render({
                 elem: '#startDate1', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 format: 'yyyy-MM-dd',
                 type : 'date'
+, trigger: 'click'
             });
             $('#area1Id').on("change", function () {
                 var aname = $("#area1Name").val()
@@ -379,6 +383,7 @@
                 elem: '#workCommunicateContentList'+idx+'_contentDate',
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
             });
         }
         function bornTemplete(list, idx, tpl, row, idx1){

src/main/webapp/webpage/modules/projectcontroltable/projectControlTableFormView.jsp

@@ -24,11 +24,13 @@
                 elem: '#billHandTime', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
             });
             laydate.render({
                 elem: '#askTime', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
             });
 		});
         function switchType(othis){

src/main/webapp/webpage/modules/projectrecord/armorForMaterials/armorForMaterialsList.jsp

@@ -34,11 +34,13 @@
                 elem: '#beginDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
             });
             laydate.render({
                 elem: '#endDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
             });
         });
 

src/main/webapp/webpage/modules/projectrecord/check/checkClaimList.jsp

@@ -34,11 +34,13 @@
                 elem: '#beginDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
             });
             laydate.render({
                 elem: '#endDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
             });
         });
 

src/main/webapp/webpage/modules/projectrecord/check/checkDesignList.jsp

@@ -35,11 +35,13 @@
                 elem: '#beginDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
             });
             laydate.render({
                 elem: '#endDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
             });
         });
 

src/main/webapp/webpage/modules/projectrecord/check/checkDistributionSettlementList.jsp

@@ -34,11 +34,13 @@
                 elem: '#beginDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
             });
             laydate.render({
                 elem: '#endDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
             });
         });
 

src/main/webapp/webpage/modules/projectrecord/check/checkInterimPayment.jsp

@@ -35,11 +35,13 @@
                 elem: '#beginDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
             });
             laydate.render({
                 elem: '#endDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
             });
         });
 

src/main/webapp/webpage/modules/projectrecord/check/checkVisaList.jsp

@@ -35,11 +35,13 @@
                 elem: '#beginDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
             });
             laydate.render({
                 elem: '#endDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
             });
         });
 

src/main/webapp/webpage/modules/projectrecord/check/reportForm.jsp

@@ -159,6 +159,7 @@
                 elem: '#reportDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
             });
             $("#attachment_btn").click(function () {
                 $("#attachment_file").click();

src/main/webapp/webpage/modules/projectrecord/claim/projectClaimList.jsp

@@ -34,11 +34,13 @@
                 elem: '#beginDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
             });
             laydate.render({
                 elem: '#endDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
             });
         });
 

src/main/webapp/webpage/modules/projectrecord/concealProject/concealProjectList.jsp

@@ -35,11 +35,13 @@
                 elem: '#beginDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
             });
             laydate.render({
                 elem: '#endDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
             });
         });
 

src/main/webapp/webpage/modules/projectrecord/contractMaterial/materialList.jsp

@@ -35,11 +35,13 @@
                 elem: '#beginDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
             });
             laydate.render({
                 elem: '#endDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
             });
         });
 

src/main/webapp/webpage/modules/projectrecord/design/projectDesignList.jsp

@@ -35,11 +35,13 @@
                 elem: '#beginDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
             });
             laydate.render({
                 elem: '#endDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
             });
         });
 

src/main/webapp/webpage/modules/projectrecord/distributionSettlement/distributionSettlementList.jsp

@@ -34,11 +34,13 @@
                 elem: '#beginDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
             });
             laydate.render({
                 elem: '#endDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
             });
         });
 

src/main/webapp/webpage/modules/projectrecord/ftlTemplate/ftlTemplateList.jsp

@@ -34,11 +34,13 @@
                 elem: '#beginDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
             });
             laydate.render({
                 elem: '#endDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
             });
         });
 

src/main/webapp/webpage/modules/projectrecord/implementCompletion/projectCompletionPigeonholeList.jsp

@@ -34,11 +34,13 @@
 				elem: '#beginDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
 				event: 'focus', //响应事件。如果没有传入event，则按照默认的click
 				type : 'date'
+, trigger: 'click'
 			});
 			laydate.render({
 				elem: '#endDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
 				event: 'focus', //响应事件。如果没有传入event，则按照默认的click
 				type : 'date'
+, trigger: 'click'
 			});
 		});
 

src/main/webapp/webpage/modules/projectrecord/implementCompletion/projectCompletionReviewList.jsp

@@ -34,11 +34,13 @@
                 elem: '#beginDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
             });
             laydate.render({
                 elem: '#endDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
             });
         });
 

src/main/webapp/webpage/modules/projectrecord/implementCompletion/projectImplementCompletionList.jsp

@@ -34,11 +34,13 @@
                 elem: '#beginDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
             });
             laydate.render({
                 elem: '#endDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
             });
         });
 

src/main/webapp/webpage/modules/projectrecord/implementEarly/projectEarlyPigeonholeList.jsp

@@ -34,11 +34,13 @@
 				elem: '#beginDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
 				event: 'focus', //响应事件。如果没有传入event，则按照默认的click
 				type : 'date'
+, trigger: 'click'
 			});
 			laydate.render({
 				elem: '#endDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
 				event: 'focus', //响应事件。如果没有传入event，则按照默认的click
 				type : 'date'
+, trigger: 'click'
 			});
 		});
 

src/main/webapp/webpage/modules/projectrecord/implementEarly/projectEarlyReviewList.jsp

@@ -35,11 +35,13 @@
                 elem: '#beginDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
             });
             laydate.render({
                 elem: '#endDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
             });
         });
 

src/main/webapp/webpage/modules/projectrecord/implementEarly/projectImplementEarlyList.jsp

@@ -36,11 +36,13 @@
                 elem: '#beginDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
             });
             laydate.render({
                 elem: '#endDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
             });
         });
 

src/main/webapp/webpage/modules/projectrecord/implementStage/projectDesignChangeList.jsp

@@ -35,11 +35,13 @@
                 elem: '#beginDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
             });
             laydate.render({
                 elem: '#endDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
             });
         });
 

src/main/webapp/webpage/modules/projectrecord/implementStage/projectDesignForm.jsp

@@ -348,6 +348,7 @@
                 elem: '#closingDate',
                 event: 'focus',
                 type : 'date'
+, trigger: 'click'
             });
         });
 

src/main/webapp/webpage/modules/projectrecord/implementStage/projectDesignList.jsp

@@ -35,11 +35,13 @@
                 elem: '#beginDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
             });
             laydate.render({
                 elem: '#endDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
             });
         });
 

src/main/webapp/webpage/modules/projectrecord/implementStage/projectImplementStageList.jsp

@@ -34,11 +34,13 @@
                 elem: '#beginDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
             });
             laydate.render({
                 elem: '#endDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
             });
         });
 

src/main/webapp/webpage/modules/projectrecord/implementStage/projectInterimPaymentList.jsp

@@ -35,11 +35,13 @@
                 elem: '#beginDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
             });
             laydate.render({
                 elem: '#endDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
             });
         });
 

src/main/webapp/webpage/modules/projectrecord/implementStage/projectVisaForm.jsp

@@ -348,6 +348,7 @@
                 elem: '#closingDate',
                 event: 'focus',
                 type : 'date'
+, trigger: 'click'
             });
         });
 

src/main/webapp/webpage/modules/projectrecord/implementStage/projectVisaList.jsp

@@ -35,11 +35,13 @@
                 elem: '#beginDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
             });
             laydate.render({
                 elem: '#endDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
             });
         });
 

src/main/webapp/webpage/modules/projectrecord/monthly/monthlyConsultationReportList.jsp

@@ -34,11 +34,13 @@
                 elem: '#beginDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
             });
             laydate.render({
                 elem: '#endDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
             });
         });
 

src/main/webapp/webpage/modules/projectrecord/plan/projectPlanForm.jsp

@@ -74,11 +74,13 @@
             elem: '#beginDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
             event: 'focus', //响应事件。如果没有传入event，则按照默认的click
             type : 'date'
+, trigger: 'click'
         });
         laydate.render({
             elem: '#endDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
             event: 'focus', //响应事件。如果没有传入event，则按照默认的click
             type : 'date'
+, trigger: 'click'
         });
 
         function func(idx){
@@ -117,13 +119,15 @@
             laydate.render({
                 elem : (list+idx+"_beginDate"),
                 event: 'focus',
-                type : 'date',
+                type : 'date'
+, trigger: 'click',
                 trigger: 'click'
             });
             laydate.render({
                 elem : (list+idx+"_endDate"),
                 event: 'focus',
-                type : 'date',
+                type : 'date'
+, trigger: 'click',
                 trigger: 'click'
             });
         }

src/main/webapp/webpage/modules/projectrecord/plan/projectPlanList.jsp

@@ -34,11 +34,13 @@
 				elem: '#beginDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
 				event: 'focus', //响应事件。如果没有传入event，则按照默认的click
 				type : 'date'
+, trigger: 'click'
 			});
 			laydate.render({
 				elem: '#endDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
 				event: 'focus', //响应事件。如果没有传入event，则按照默认的click
 				type : 'date'
+, trigger: 'click'
 			});
 		});
 

src/main/webapp/webpage/modules/projectrecord/plan/projectPlanView.jsp

@@ -74,11 +74,13 @@
             elem: '#beginDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
             event: 'focus', //响应事件。如果没有传入event，则按照默认的click
             type : 'date'
+, trigger: 'click'
         });
         laydate.render({
             elem: '#endDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
             event: 'focus', //响应事件。如果没有传入event，则按照默认的click
             type : 'date'
+, trigger: 'click'
         });
 
         function func(idx){

src/main/webapp/webpage/modules/projectrecord/projectRecordsAlterList.jsp

@@ -24,11 +24,13 @@
                 elem: '#beginDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
             });
             laydate.render({
                 elem: '#endDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
             });
 		});
 

src/main/webapp/webpage/modules/projectrecord/projectRecordsDetailList.jsp

@@ -23,11 +23,13 @@
                 elem: '#beginDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
             });
             laydate.render({
                 elem: '#endDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
             });
         });
 

src/main/webapp/webpage/modules/projectrecord/projectRecordsList.jsp

@@ -35,11 +35,13 @@
                 elem: '#beginDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
             });
             laydate.render({
                 elem: '#endDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
             });
         });
 

src/main/webapp/webpage/modules/projectrecord/summarizing/armorProjectRecordsList.jsp

@@ -35,11 +35,13 @@
                 elem: '#beginDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
             });
             laydate.render({
                 elem: '#endDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
             });
         });
 

src/main/webapp/webpage/modules/projectrecord/summarizing/claimSumamarizingProjectRecordsList.jsp

@@ -35,11 +35,13 @@
                 elem: '#beginDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
             });
             laydate.render({
                 elem: '#endDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
             });
         });
 

src/main/webapp/webpage/modules/projectrecord/summarizing/concealProjectRecordsList.jsp

@@ -35,11 +35,13 @@
                 elem: '#beginDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
             });
             laydate.render({
                 elem: '#endDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
             });
         });
 

src/main/webapp/webpage/modules/projectrecord/summarizing/designSumamarizingProjectRecordsList.jsp

@@ -35,11 +35,13 @@
                 elem: '#beginDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
             });
             laydate.render({
                 elem: '#endDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
             });
         });
 

src/main/webapp/webpage/modules/projectrecord/summarizing/distributionSumamarizingProjectRecordsList.jsp

@@ -35,11 +35,13 @@
                 elem: '#beginDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
             });
             laydate.render({
                 elem: '#endDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
             });
         });
 

src/main/webapp/webpage/modules/projectrecord/summarizing/materialProjectRecordsList.jsp

@@ -35,11 +35,13 @@
                 elem: '#beginDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
             });
             laydate.render({
                 elem: '#endDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
             });
         });
 

src/main/webapp/webpage/modules/projectrecord/summarizing/sumamarizingProjectRecordsList.jsp

@@ -35,11 +35,13 @@
                 elem: '#beginDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
             });
             laydate.render({
                 elem: '#endDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
             });
         });
 

src/main/webapp/webpage/modules/projectrecord/summarizing/visaSumamarizingProjectRecordsList.jsp

@@ -35,11 +35,13 @@
                 elem: '#beginDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
             });
             laydate.render({
                 elem: '#endDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
             });
         });
 

src/main/webapp/webpage/modules/projectrecord/summarizing/workContentView.jsp

@@ -66,6 +66,7 @@
                 elem: '#createDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
             });*/
             changeContentDetail("${projectcontentinfo.projectContentData.type}");
             var tp = "${projectcontentinfo.dictType}";

src/main/webapp/webpage/modules/projectrecord/visa/projectVisaList.jsp

@@ -35,11 +35,13 @@
                 elem: '#beginDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
             });
             laydate.render({
                 elem: '#endDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
             });
         });
 

src/main/webapp/webpage/modules/projectrecord/workContentFromAndView/reportForm.jsp

@@ -164,6 +164,7 @@
                 elem: '#reportDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
             });
             $("#attachment_btn").click(function () {
                 $("#attachment_file").click();

src/main/webapp/webpage/modules/projectrecord/workContentFromAndView/workContentView.jsp

@@ -66,6 +66,7 @@
                 elem: '#createDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
             });*/
             changeContentDetail("${projectcontentinfo.projectContentData.type}");
             var tp = "${projectcontentinfo.dictType}";

src/main/webapp/webpage/modules/ruralprojectrecords/cost/projectcontentinfo/reportForm.jsp

@@ -127,6 +127,7 @@
                 elem: '#reportDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
             });
             $("#attachment_btn").click(function () {
                 $("#attachment_file").click();

src/main/webapp/webpage/modules/ruralprojectrecords/cost/projectcontentinfo/reportModify.jsp

@@ -126,6 +126,7 @@
                 elem: '#reportDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
             });
             $("#attachment_btn").click(function () {
                 $("#attachment_file").click();

src/main/webapp/webpage/modules/ruralprojectrecords/cost/ruralCostProjectMessageList.jsp

@@ -22,11 +22,13 @@
                 elem: '#beginDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
             });
             laydate.render({
                 elem: '#endDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
             });
         });
 

src/main/webapp/webpage/modules/ruralprojectrecords/cost/ruralCostProjectRecordsAdminModify.jsp

@@ -161,11 +161,13 @@
                 elem: '#startDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
             });
             laydate.render({
                 elem: '#endingDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
             });
         });
 

src/main/webapp/webpage/modules/ruralprojectrecords/cost/ruralCostProjectRecordsForm.jsp

@@ -189,11 +189,13 @@
                 elem: '#startDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
             });
             laydate.render({
                 elem: '#endingDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
             });
 
         });

src/main/webapp/webpage/modules/ruralprojectrecords/cost/ruralCostProjectRecordsList.jsp

@@ -23,11 +23,13 @@
                 elem: '#beginDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
             });
             laydate.render({
                 elem: '#endDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
             });
         });
 

src/main/webapp/webpage/modules/ruralprojectrecords/cost/ruralCostProjectRecordsModify.jsp

@@ -173,11 +173,13 @@
                 elem: '#startDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
             });
             laydate.render({
                 elem: '#endingDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
             });
 		});
 

src/main/webapp/webpage/modules/ruralprojectrecords/ruralProjectRecordsAdminModify.jsp

@@ -161,11 +161,13 @@
                 elem: '#startDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
             });
             laydate.render({
                 elem: '#endingDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
             });
 		});
 

src/main/webapp/webpage/modules/ruralprojectrecords/ruralProjectRecordsAlterList.jsp

@@ -24,11 +24,13 @@
                 elem: '#beginDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
             });
             laydate.render({
                 elem: '#endDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
             });
 		});
 

src/main/webapp/webpage/modules/ruralprojectrecords/ruralProjectRecordsDetailList.jsp

@@ -23,11 +23,13 @@
                 elem: '#beginDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
             });
             laydate.render({
                 elem: '#endDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
             });
         });
 

src/main/webapp/webpage/modules/ruralprojectrecords/ruralProjectRecordsForm.jsp

@@ -206,11 +206,15 @@
                 elem: '#startDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
+                , trigger: 'click'
             });
             laydate.render({
                 elem: '#endingDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
+                , trigger: 'click'
             });
         });
 

src/main/webapp/webpage/modules/ruralprojectrecords/ruralProjectRecordsList.jsp

@@ -23,11 +23,13 @@
                 elem: '#beginDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
             });
             laydate.render({
                 elem: '#endDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
             });
         });
 

src/main/webapp/webpage/modules/ruralprojectrecords/ruralProjectRecordsModify.jsp

@@ -175,11 +175,13 @@
                 elem: '#startDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
             });
             laydate.render({
                 elem: '#endingDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
             });
 		});
 

src/main/webapp/webpage/modules/ruralprojectrecords/ruralProjectRecordsShowList.jsp

@@ -23,11 +23,13 @@
                 elem: '#beginDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
             });
             laydate.render({
                 elem: '#endDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
             });
         });
 

src/main/webapp/webpage/modules/ruralprojectrecords/ruralporjectmessage/projectcontentinfo/reportForm.jsp

@@ -130,6 +130,7 @@
                 elem: '#reportDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
             });
             $("#attachment_btn").click(function () {
                 $("#attachment_file").click();

src/main/webapp/webpage/modules/ruralprojectrecords/ruralporjectmessage/projectcontentinfo/reportModify.jsp

@@ -127,6 +127,7 @@
                 elem: '#reportDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
             });
             $("#attachment_btn").click(function () {
                 $("#attachment_file").click();

src/main/webapp/webpage/modules/ruralprojectrecords/ruralporjectmessage/ruralProjectMessageList.jsp

@@ -23,11 +23,13 @@
                 elem: '#beginDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
             });
             laydate.render({
                 elem: '#endDate', //目标元素。由于laydate.js封装了一个轻量级的选择器引擎，因此elem还允许你传入class、tag但必须按照这种方式 '#id .class'
                 event: 'focus', //响应事件。如果没有传入event，则按照默认的click
                 type : 'date'
+, trigger: 'click'
             });
         });
 

src/main/webapp/webpage/modules/sys/gridSelectRole.jsp

@@ -116,11 +116,13 @@
             elem: '#beginDate',
             event: 'focus',
             type : 'date'
+, trigger: 'click'
         });
         laydate.render({
             elem: '#endDate',
             event: 'focus',
             type : 'date'
+, trigger: 'click'
         });
         $('#contentTable thead tr th input.i-checks').on('ifChecked', function(event){ //ifCreated 事件应该在插件初始化之前绑定
             $('#contentTable tbody tr td input.i-checks').iCheck('check');

src/main/webapp/webpage/modules/sys/gridSelectSingle.jsp

@@ -112,11 +112,13 @@
             elem: '#beginDate',
             event: 'focus',
             type : 'date'
+, trigger: 'click'
         });
         laydate.render({
             elem: '#endDate',
             event: 'focus',
             type : 'date'
+, trigger: 'click'
         });
         $('#contentTable thead tr th input.i-checks').on('ifChecked', function(event){ //ifCreated 事件应该在插件初始化之前绑定
             $('#contentTable tbody tr td input.i-checks').iCheck('check');

src/main/webapp/webpage/modules/sys/gridSelectUser.jsp

@@ -149,11 +149,13 @@
             elem: '#beginDate',
             event: 'focus',
             type : 'date'
+, trigger: 'click'
         });
         laydate.render({
             elem: '#endDate',
             event: 'focus',
             type : 'date'
+, trigger: 'click'
         });
         $('#contentTable thead tr th input.i-checks').on('ifChecked', function(event){ //ifCreated 事件应该在插件初始化之前绑定
             $('#contentTable tbody tr td input.i-checks').iCheck('check');

src/main/webapp/webpage/modules/sys/gridworkSupplier.jsp

@@ -118,11 +118,13 @@
             elem: '#beginDate',
             event: 'focus',
             type : 'date'
+, trigger: 'click'
         });
         laydate.render({
             elem: '#endDate',
             event: 'focus',
             type : 'date'
+, trigger: 'click'
         });
         $('#contentTable thead tr th input.i-checks').on('ifChecked', function(event){ //ifCreated 事件应该在插件初始化之前绑定
             $('#contentTable tbody tr td input.i-checks').iCheck('check');