TG.RiskRules = Ext.extend(Ext.grid.EditorGridPanel, {
	id: 'risk-rules',
	//title: 'Risico regeles',
	clicksToEdit: 1,
	stateful: true,
	initComponent: function() {
		var filters = new Ext.ux.grid.GridFilters({
			encode: true,
			local: true,
			filters:[
			{
				type: 'numeric',
				dataIndex: 'id'
			},
			{
				type: 'string',
				dataIndex: 'cluster'
			},
			{
				type: 'string',
				dataIndex: 'thema'
			},
			{
				type: 'string',
				dataIndex: 'otg'
			},
			{
				type: 'string',
				dataIndex: 'kenmerk1'
			},
			{
				type: 'string',
				dataIndex: 'kenmerk2'
			},
			{
				type: 'string',
				dataIndex: 'status'
			},
			{
				type: 'string',
				dataIndex: 'verantwoordelijke'
			}
			]
		});

		var store = new Ext.data.DirectStore({
			autoLoad: true,
			autoSave: true,
			reader: new Ext.data.JsonReader({
				idProperty: 'id',
				root: 'data',
				totalProperty: 'total',
				fields: ['id', 'oorzaak', 'gebeurtenis', 'gevolg', 'cluster',
				'thema', 'otg', 'kenmerk1', 'kenmerk2',	'aantal_punten1',
				'aantal_punten2', 'kanswaarde', 'vrije_kanswaarde',
				'gevolgwaarde_a', 'vrije_gevolgwaarde_a', 'gevolgwaarde_b',
				'vrije_gevolgwaarde_b', 'kg_waarde_a', 'vrije_kg_waarde_a',
				'kg_waarde_b', 'vrije_kg_waarde_b', 'alloctie',
				'verantwoordelijke', 'verandering', 'status', 'meegenomen',
				'koppelink_planning', 'opmerking', 'onderbouwing_kg',
				'oorsprong'
				]
			}),
			proxy: new Ext.data.DirectProxy({
				api: {
					read: TG.Remoting.RiscRules.read,
					create: TG.Remoting.RiscRules.create,
					update: TG.Remoting.RiscRules.update,
					destroy: TG.Remoting.RiscRules.remove
				},
				listeners: {
					exception: function(p, type, action, opt, resp) {
						alert('Er is een fout op getreden.');
					}
				}
			}),
			writer: new Ext.data.JsonWriter({
				encode : false
			})
		});

		var editor = new Ext.ux.grid.RowEditor({
			saveText: 'Wijzigen'
		});

		Ext.apply(this, {
			plugins: [filters],
			tbar: [{
				icon: 'images/page_white.gif',
				text: 'Nieuw',
				handler: function(btn) {
					var g = Ext.getCmp('risk-rules');
					var s = g.getStore();

					Ext.Msg.show({
						title:'Opslaan?',
						msg: 'Het bestand wordt gesloten. Wilt u uw wijzigingen opslaan?',
						buttons: Ext.Msg.YESNOCANCEL,
						fn: function(id) {
							if (id == 'yes') {
								var ss = g.getState();
								Ext.Ajax.request({
									url: BASE_URL+'/index/save-state/',
									params: {
										state: Ext.encode(ss)
									},
									success: function() {
										document.location.href = BASE_URL + '/index/save/';
									}
								});		
							} else if (id == 'no') {
								s.load({
									params: {
										new_file: true
									}
								});
							} else if (id == 'cancel') {
						//alert('cancel')
						}
						},
						animEl: btn,
						icon: Ext.MessageBox.QUESTION
					});
					
				}
			},{
				icon: 'images/folder_page.gif',
				text: 'Open',
				handler: function() {

					var g = Ext.getCmp('risk-rules');
					var s = g.getStore();

					Ext.Msg.show({
						title:'Opslaan?',
						msg: 'Het bestand wordt gesloten. Wilt u uw wijzigingen opslaan?',
						buttons: Ext.Msg.YESNOCANCEL,
						fn: function(id) {
							if (id == 'yes') {
								var ss = g.getState();
								Ext.Ajax.request({
									url: BASE_URL+'/index/save-state/',
									params: {
										state: Ext.encode(ss)
									},
									success: function() {
										document.location.href = BASE_URL + '/index/save/';
									}
								});
							} else if (id == 'no') {
								if (!TG.upload) {
									TG.upload = new TG.Upload();
								}
								TG.upload.show();
							} else if (id == 'cancel') {
								//alert('cancel')
							}
						},
						icon: Ext.MessageBox.QUESTION
					});
					
				}
			},{
				icon: 'images/disk.gif',
				text: 'Opslaan',
				handler: function() {
					var g = Ext.getCmp('risk-rules');
					var s = g.getState();

					Ext.Ajax.request({
						url: BASE_URL+'/index/save-state/',
						params: {
							state: Ext.encode(s)
						},
						success: function() {
							document.location.href = BASE_URL + '/index/save/';
						}
					});					
				}
			},'-',{
				iconCls: 'x-icon-add',
				text: 'Toevoegen',
				handler: function () {
					var g = Ext.getCmp('risk-rules');
					var RiscRule = g.getStore().recordType;
					var r = new RiscRule({
						id: 9999,
						oorzaak: ' ',
						gebeurtenis: ' ',
						gevolg: ' '
					});
					g.stopEditing();
					g.store.add(r);
					var ri = g.store.getCount()-1;
					g.startEditing(ri, 5);
				}
			},{
				iconCls: 'x-icon-delete',
				text: 'Verwijderen',
				handler: function () {
					var g = Ext.getCmp('risk-rules');
					var sm = g.getSelectionModel();
					if (sm.hasSelection()) {
						var c = sm.getSelectedCell();
						g.store.removeAt(c[0]);
					}
				}
			},'-',{
				icon: 'images/page_white_excel.gif',
				text: 'Exporteer naar Excel',
				handler: function() {
					if(!TG.exportwin){
						TG.exportwin = new TG.Export();
					}
					TG.exportwin.setExportUrl(BASE_URL + '/index/excel/');
					TG.exportwin.show();
				}
			},{
				icon: 'images/page_white_acrobat.gif',
				text: 'Exporteer naar PDF',
				handler: function() {
					if(!TG.exportwin){
						TG.exportwin = new TG.Export();
					}
					TG.exportwin.setExportUrl(BASE_URL + '/index/report/');
					TG.exportwin.show();
				}
			}, '-', {
				icon: 'images/unsorted.gif',
				text: 'Verwijder sortering',
				handler: function() {
					var g = Ext.getCmp('risk-rules');
					var v = g.getView();
					delete g.store.sortInfo
					delete g.store.baseParams['dir'];
					delete g.store.baseParams['sort'];
					v.updateHeaderSortState();
					v.mainHd.select('td').removeClass(v.sortClasses);
					g.store.reload();					
				}
			}, '-', {
				icon: 'images/help.gif',
				text: 'Handleiding',
				handler: function() {
					document.location.href = BASE_URL + '/pdf/twysk-risicotool-handleiding.pdf';
				}
			}],
			colModel: new Ext.ux.grid.LockingColumnModel([{
				header: '',
				sortable: false,
				menuDisabled:true,
				width: 23,
				hidden: false,
				id: 'numberer',
				locked: true,
				fixed: true,
				renderer : function(v, p, record, rowIndex){
					if(true){
					//p.cellAttr = 'rowspan="'+2+'"';
					}
					return v;
				}	,
				dataIndex: 'id'
			},{
				header: 'Oorzaak',
				sortable: true,
				width: 200,
				dataIndex: 'oorzaak',
				editor: {
					xtype: 'textarea',
					grow: true,
					growMax: 350
					
				},
				renderer: function(v) {
					if (typeof(v) == 'string') {
						return v.replace(/(\r\n|\r|\n)/g, "<br/>");
					}
				}
			},{
				header: 'Gebeurtenis',
				sortable: true,
				width: 200,
				dataIndex: 'gebeurtenis',
				editor: {
					xtype: 'textarea',
					grow: true,
					growMax: 350
				},
				renderer: function(v) {
					if (typeof(v) == 'string') {
						return v.replace(/(\r\n|\r|\n)/g, "<br />");
					}
				}
			},{
				header: 'Gevolg',
				sortable: true,
				width: 200,
				dataIndex: 'gevolg',
				editor: {
					xtype: 'textarea',
					grow: true,
					growMax: 350
				},
				renderer: function(v) {
					if (typeof(v) == 'string') {
						return v.replace(/(\r\n|\r|\n)/g, "<br />");
					}
				}
			},{
				header: 'Cluster',
				sortable: true,
				dataIndex: 'cluster',
				editor: {
					xtype: 'domain-options',
					domainName: 'Cluster',
					type: 1
				}
			},{
				header: 'Thema',
				sortable: true,
				dataIndex: 'thema',
				editor: {
					xtype: 'domain-options',
					domainName: 'Thema',
					type: 2
				}
			},{
				header: 'OTG',
				sortable: true,
				dataIndex: 'otg',
				editor: {
					xtype: 'domain-options',
					domainName: 'OTG',
					type: 3
				}
			},{
				header: 'Kenmerk I',
				sortable: true,
				dataIndex: 'kenmerk1',
				editor: {
					xtype: 'domain-options',
					domainName: 'Kenmerk I',
					type: 4
				}
			},{
				header: 'Kenmerk II',
				sortable: true,
				dataIndex: 'kenmerk2',
				editor: {
					xtype: 'domain-options',
					domainName: 'Kenmerk II',
					type: 5
				}
			},{
				header: 'Aantal punten (pro) I',
				sortable: true,
				hidden: true,
				dataIndex: 'aantal_punten1',
				editor: {
					xtype: 'numberfield'
				}
			},{
				header: 'Aantal punten (pro) II',
				sortable: true,
				hidden: true,
				dataIndex: 'aantal_punten2',
				editor: {
					xtype: 'numberfield'
				}
			},{
				header: 'Kans (klasse)',
				sortable: true,
				width: 50,
				dataIndex: 'kanswaarde',
				editor: {
					xtype: 'combo',
					triggerAction: 'all',
					lazyRender:true,
					mode: 'local',
					displayField: 'value',
					valueField: 'value',
					store: new Ext.data.ArrayStore({
						data: [
						[1],[2],[3],[4],[5],[6],[7],[8]
						],
						fields: ['value']
					})
				}
			},{
				header: 'Kans (vrije waarde)',
				sortable: true,
				hidden: true,
				width: 50,
				dataIndex: 'vrije_kanswaarde',
				editor: {
					xtype: 'numberfield'
				}
			},{
				header: 'Gevolg A (klasse)',
				sortable: true,
				width: 50,
				dataIndex: 'gevolgwaarde_a',
				editor: {
					xtype: 'combo',
					triggerAction: 'all',
					lazyRender:true,
					mode: 'local',
					displayField: 'value',
					valueField: 'value',
					store: new Ext.data.ArrayStore({
						data: [
						[1],[2],[3],[4]
						],
						fields: ['value']
					})
				}
			},{
				header: 'Gevolg A (vrije waarde)',
				sortable: true,
				hidden: true,
				width: 50,
				dataIndex: 'vrije_gevolgwaarde_a',
				editor: {
					xtype: 'numberfield'
				}
			},{
				header: 'Gevolg B (klasse)',
				sortable: true,
				width: 50,
				dataIndex: 'gevolgwaarde_b',
				editor: {
					xtype: 'combo',
					triggerAction: 'all',
					lazyRender:true,
					mode: 'local',
					displayField: 'value',
					valueField: 'value',
					store: new Ext.data.ArrayStore({
						data: [
						[1],[2],[3],[4]
						],
						fields: ['value']
					})
				}
			},{
				header: 'Gevolg B (vrije waarde)',
				sortable: true,
				hidden: true,
				width: 50,
				dataIndex: 'vrije_gevolgwaarde_b',
				editor: {
					xtype: 'numberfield'
				}
			},{
				header: 'K*G A (klasse)',
				sortable: true,
				hidden: true,
				dataIndex: 'kg_waarde_a',
				renderer: function(v, meta, rec) {
					var k = rec.get('kanswaarde');
					var g = rec.get('gevolgwaarde_a');
					k = parseInt(k);
					g = parseInt(g);
					var val = k * g;
					rec.data.kg_waarde_a = val;
					return val;
				}
			},{
				header: 'K*G A (vrijewaarde)',
				sortable: true,
				hidden: true,
				dataIndex: 'vrije_kg_waarde_a',
				renderer: function(v, meta, rec) {
					var k = rec.get('vrije_kanswaarde');
					var g = rec.get('vrije_gevolgwaarde_a');
					k = parseInt(k)/100; // procent
					g = parseInt(g);
					var val = k * g;
					rec.data.vrije_kg_waarde_a = val;
					return val;
				}
			},{
				header: 'K*G B (klasse)',
				sortable: true,
				hidden: true,
				dataIndex: 'kg_waarde_b',
				renderer: function(v, meta, rec) {
					var k = rec.get('kanswaarde');
					var g = rec.get('gevolgwaarde_b');
					k = parseInt(k);
					g = parseInt(g);
					var val = k * g;
					rec.data.kg_waarde_b = val;
					return val;
				}
			},{
				header: 'K*G B (vrijewaarde)',
				sortable: true,
				hidden: true,
				dataIndex: 'vrije_kg_waarde_b',
				renderer: function(v, meta, rec) {
					var k = rec.get('vrije_kanswaarde');
					var g = rec.get('vrije_gevolgwaarde_b');
					k = parseInt(k)/100;
					g = parseInt(g);
					var val = k * g;
					rec.data.vrije_kg_waarde_b = val;
					return val;
				}
			},{
				header: 'Allocatie',
				sortable: true,
				dataIndex: 'alloctie',
				editor: {
					xtype: 'domain-options',
					doxtypemainName: 'Allocatie',
					type: 10
				}
			},{
				header: 'Verantwoordelijke',
				sortable: true,
				dataIndex: 'verantwoordelijke',
				editor: {
					xtype: 'domain-options',
					doxtypemainName: 'Verantwoordelijke voor risico',
					type: 6
				}
			},{
				header: 'Verandering',
				sortable: true,
				dataIndex: 'verandering',
				editor: {
					xtype: 'combo',
					triggerAction: 'all',
					lazyRender:true,
					mode: 'local',
					displayField: 'value',
					valueField: 'value',
					store: new Ext.data.ArrayStore({
						data: [
							['Gelijk'],['Groter'],['Kleiner']
						],
						fields: ['value']
					})
				}
			},{
				header: 'Status',
				sortable: true,
				dataIndex: 'status',
				editor: {
					xtype: 'domain-options',
					domainName: 'Status risico',
					type: 7
				}
			},{
				header: 'Meegenomen',
				sortable: true,
				dataIndex: 'meegenomen',
				editor: {
					xtype: 'domain-options',
					domainName: 'Meegenomen in raming als',
					type: 8
				}
			},{
				header: 'Koppeling planning',
				sortable: true,
				dataIndex: 'koppelink_planning',
				editor: {
					xtype: 'domain-options',
					domainName: 'Koppeling planning',
					type: 9
				}
			},{
				header: 'Opmerking',
				sortable: true,
				hidden: true,
				dataIndex: 'opmerking',
				editor: {
					xtype: 'textarea',
					grow: true,
					growMax: 350
				}
			},{
				header: 'Onderbouwing K &amp; G',
				sortable: true,
				hidden: true,
				dataIndex: 'onderbouwing_kg',
				editor: {
					xtype: 'textfield'
				}
			},{
				header: 'Oorsprong',
				sortable: true,
				hidden: true,
				dataIndex: 'oorsprong',
				editor: {
					xtype: 'textfield'
				}
			}]),
			store: store,
			view: new Ext.ux.grid.LockingGridView({
				syncHeights: true
			})
		});
		TG.RiskRules.superclass.initComponent.apply(this, arguments);
	},
	selModel: new Ext.grid.CellSelectionModel({
		listeners: {
			selectionchange: function(sm, row) {
				var g = Ext.getCmp('management-measure');
				if (row) {
					g.store.baseParams.riscruleid = row.record.id;
					g.enable();
				} else {
					g.disable();
				}
			},
			cellselect: function(sm, row, coll) {
				var g = Ext.getCmp('management-measure');

				g.store.baseParams.riscruleid = sm.selection.record.id
				g.store.load();


				var tplMarkup = [
				'<dl class="x-detail">',
				'<dt>Oorzaak:</dt><dd>{oorzaak}</dd>',
				'<dt>Gebeurtenis:</dt><dd>{gebeurtenis}</dd>',
				'<dt>Gevolg:</dt><dd>{gevolg}</dd>',
				'</dl>'
				];
				var detailTpl = new Ext.Template(tplMarkup);
				var d = sm.selection.record.data;
				if (d.oorzaak==null) {
					d.oorzaak='';
				}
				if (d.gebeurtenis==null) {
					d.gebeurtenis='';
				}
				if (d.gevolg==null) {
					d.gevolg='';
				}

				detailTpl.overwrite(Ext.getCmp('detail-panel').body, sm.selection.record.data);
			
			}
		}
	})
});
Ext.reg('risk-rules', TG.RiskRules);