/*
 * Common støff
 */

Ext.lib.Ajax.defaultPostHeader = "application/x-www-form-urlencoded; charset=UTF-8";
Ext.BLANK_IMAGE_URL = "/util/ext-2.2/resources/images/default/s.gif";
Ext.namespace('Ext.gt');

var getEntity = function(recordDef, data, id) {
	var fi = recordDef.prototype.fields.items;
	
	for (var i = 0; i < fi.length; i++) {
		var f = fi[i];
		var v = data[f.name];
		data[f.name] = f.convert((v !== undefined) ? v : f.defaultValue);
	}
	
	var r = new recordDef(data, id);
	return r;
}

var getDocumentParent = function() {
    var topWindow = window.parent;
    while (topWindow.parent && topWindow.parent != topWindow) {
		try {
			if (topWindow.parent.document.domain != document.domain)
				break;
			if (topWindow.parent.document.getElementsByTagName('frameset').length > 0)
				break;
		} catch (e) {
			break;
		}
		topWindow = topWindow.parent;
	}
	
	return {
		window: topWindow,
		document: topWindow.document
	}
}

var getMimeIconFromMimetype = function(mimetype) {
	var delimiter = mimetype.indexOf("/");
	var commonType = mimetype.substring(0, delimiter);
	var type = mimetype.substring(delimiter + 1);
	var ret;
	
	switch(type) {
		case "pdf":
			ret = "util/admin/images/mime/pdf.png";
			break;
		case "vnd.ms-word":
			ret = "util/admin/images/mime/document.png";
			break;
	}
	
	switch (commonType) {
		case "audio":
			ret = "util/admin/images/mime/audio.png";
			break;
		case "video":
			ret = "util/admin/images/mime/video.png";
			break;
		case "image":
			ret = "util/admin/images/mime/image.png";
			break;
	}
	
	if (ret == null) {
		ret = "util/admin/images/mime/unknown.png";
	}
	return ret;
}

var getSessionId = function() {
	var retval = "";
	
	var offset = document.cookie.indexOf("JSESSIONID=");
	if (offset >= 0) {
		var end = document.cookie.indexOf(";", offset);
		if (end < 0) {
			end = document.cookie.length;
		}
		
		retval = document.cookie.substring(offset + 11, end);
	}
	
	return retval;
}

var getAdminBaseUrl = function() {
	var loc = window.location.pathname;
	loc = loc.substring(0, loc.lastIndexOf("admin"));
	
	return loc + "admin/";
}

var getServletBaseUrl = function() {
	return "";
}
var servletBase = getServletBaseUrl();

var getApplicationBaseUrl = function() {
	var loc = window.location.pathname;
	loc = loc.substring(0, loc.indexOf("/", 1));
	
	return loc;
}
var applicationBaseUrl = getApplicationBaseUrl();

var getQueryParam = function(name) {
	name = name.replace(/[\[]/,"\\\[").replace(/[\]]/,"\\\]");
	var regexS = "[\\?&]"+name+"=([^&#]*)";
	var regex = new RegExp( regexS );
	var results = regex.exec( window.location.href );
	if( results == null )
		return "";
	else
		return results[1];
}

function checkFlashVersion() {
	var x;
	var pluginversion;
	
	if(navigator.plugins && navigator.mimeTypes.length){
		x = navigator.plugins["Shockwave Flash"];
		if(x && x.description) x = x.description;
	} else if (Ext.isIE){
		try {
			x = new ActiveXObject("ShockwaveFlash.ShockwaveFlash");
			x = x.GetVariable("$version");
		} catch(e){}
	}
	
	pluginVersion = (typeof(x) == 'string') ? parseInt(x.match(/\d+/)[0]) : 0;
	return pluginVersion;
}

Ext.override(Ext.Toolbar, {
	insertField : function(position, field){
		var td = document.createElement("td");
		this.tr.insertBefore(td, this.tr.childNodes[position]);
		field.render(td);
		var ti = new Ext.Toolbar.Item(td.firstChild);
		ti.render(td);
		this.items.insert(position, field);
		return ti;
	},
	
	insertItem : function(position, item){
		var td = document.createElement("td");
		this.tr.insertBefore(td, this.tr.childNodes[position]);
		item.render(td);
		this.items.insert(position, item);
		return item;
	},
	
	insertSeparator : function(position){
		this.insertItem(position, new Ext.Toolbar.Separator());
	},
	
	insertSpacing : function(position){
		this.insertItem(position, new Ext.Toolbar.Spacer());
	},
	
	insertFill : function(position){
		this.insertItem(position, new Ext.Toolbar.Fill());
	}
});

// http://extjs.com/learn/Tutorial:Extending_Ext2_Class
if (Ext.version && (Ext.version.substring(0, 3) == '2.2')) {
	Ext.gt.IconCombo = Ext.extend(Ext.form.ComboBox, {
		initComponent:function() {
			Ext.apply(this, {
			tpl:  '<tpl for=".">'
				+ '<div class="x-combo-list-item x-icon-combo-item x-flag-{' + this.valueField + '}">'
				+ '{' + this.displayField + '}'
				+ '</div></tpl>'
			});
			Ext.gt.IconCombo.superclass.initComponent.call(this);
		},
		onRender:function(ct, position) {
			Ext.gt.IconCombo.superclass.onRender.call(this, ct, position);
			this.wrap.applyStyles({position:'relative'});
			this.el.addClass('x-icon-combo-input');
			this.icon = Ext.DomHelper.append(this.el.up('div.x-form-field-wrap'), {
				tag: 'div', style:'position:absolute'
			});
		},
		setIconCls:function() {
			var rec = this.store.query(this.valueField, this.getValue()).itemAt(0);
			if(rec) {
				this.icon.className = 'x-icon-combo-icon x-flag-' + rec.get(this.valueField);
			}
		},
		setValue: function(value) {
			Ext.gt.IconCombo.superclass.setValue.call(this, value);
			this.setIconCls();
		}
	});
	Ext.reg('iconcombo', Ext.gt.IconCombo);
}

var sessionKeepAlive = function(url, interval){
	var fail = function() {
		Ext.Msg.show({
			title: "Logged out",
			msg: "You have been logged out. Any changes made in the current document will be discarded. "
			   + "Press OK to redirect to the login page. "
			   + "Press Cancel to close this message (if you need to copy unsaved changes from the current document, before reloading manually).",
			buttons: Ext.Msg.OKCANCEL,
			icon: Ext.Msg.ERROR,
			fn: function(btn) {
				if (btn == 'ok') {
					window.location.reload(true);
				}
				Ext.TaskMgr.stop(t);
			}
		});
	}
	
	var t = {
		run: function() {
			Ext.Ajax.request({
				url: url,
				success: function(res, o) {
					if (res.responseText.indexOf("<!-- CMX1 OK -->") < 0) {
						fail();
					}
				},
				failure: fail
			});
		},
		interval: interval
	}
	
	Ext.TaskMgr.start(t);
}

if (Ext.ux.UploadForm) {
	Ext.override(Ext.ux.UploadForm, {
		getProgressTemplate : function(){
			var tpl = new Ext.Template(
					'<table class="x-uf-pginfo-table"><tbody>'
					, '<tr><td class="x-uf-pginfo-label">' + this.pgSizeText + ':</td>'
					, '<td class="x-uf-pginfo-value">{bytes_uploaded}/{bytes_total}</td></tr>'
					, '<tr><td class="x-uf-pginfo-label">' + this.pgSpeedAvgText + ':</td>'
					, '<td class="x-uf-pginfo-value">{speed_average}</td></tr>'
					, '<tr><td class="x-uf-pginfo-label">' + this.pgEtaText + ':</td>'
					, '<td class="x-uf-pginfo-value">{est_sec}</td></tr>'
					, '</tbody></table>'
			);
			tpl.compile();
			return tpl;
		}
	});
}
if (Ext.gt.SWFUpload) {
	Ext.override(Ext.gt.SWFUpload, {
		getProgressTemplate : function(){
			var tpl = new Ext.Template(
					'<table class="x-uf-pginfo-table"><tbody>'
					, '<tr><td class="x-uf-pginfo-label">' + this.pgSizeText + ':</td>'
					, '<td class="x-uf-pginfo-value">{bytes_uploaded}/{bytes_total}</td></tr>'
					, '<tr><td class="x-uf-pginfo-label">' + this.pgSpeedAvgText + ':</td>'
					, '<td class="x-uf-pginfo-value">{speed_average}</td></tr>'
					, '<tr><td class="x-uf-pginfo-label">' + this.pgEtaText + ':</td>'
					, '<td class="x-uf-pginfo-value">{est_sec}</td></tr>'
					, '</tbody></table>'
			);
			tpl.compile();
			return tpl;
		}
	});
}

var createUploader;
if (Ext.gt.SWFUpload || Ext.ux.UploadForm) {
	createUploader = function(o) {
		var iconPath = '/util/admin/images/';
		var uploader;
		
		if (checkFlashVersion() >= 9) {
			uploader = new Ext.gt.SWFUpload({
				autoScroll: true,
				iconPath: iconPath,
				flashPath: '/util/ext-2.2/ux/swfupload.swf',
				fileSizeLimit: '0',
				fileTypes: o.fileSelection,
				fileTypesDescription: o.fileDescription,
				uploadTarget: o.url + '/admin/blank.html;jsessionid=' + getSessionId(),
				pgCfg: {
					progressBar: true,
					progressTarget: 'under'
				}
			});
			
			uploader.on('beforeupload', function(form) {
				var cmid;
				if (o.scope) {
					cmid = o.cmidCallback.call(o.scope);
				} else {
					cmid = o.cmidCallback();
				}
				form.setPostParams({
					"TYPE": o.cmtype,
					"ID": cmid,
					"CHARACTER_ENCODING": "UTF8"
				});
			});
		} else {
			var id = Ext.id();
			var el = Ext.DomHelper.append(document.body, {tag: 'div', id: id});
			uploadForm = new Ext.ux.UploadForm(el, {
				iconPath: iconPath,
				uploadIcon: 'transmit_go.png',
				clearIcon: 'cancel.png',
				autoCreate: true,
				url: o.url,
				method: 'post',
				maxNameLength: 30
				, pgCfg: {
					uploadIdName: 'ID'
					, uploadIdValue: "-1"
					, progressBar: true
					, progressTarget: 'under'
					, interval: 1000
					, maxPgErrors: 20
					, options: {
						url: servletBase + '/openPage/admin/progress.html'
						, method: 'post'
					}
				}
			});
			
			uploadForm.on('beforeaction', function(form) {
				form.baseParams = {'TYPE': o.cmtype};
				form.uploadId.value = o.cmidCallback.call(o.scope);
			});
			
			uploader = new Ext.Panel({
				autoScroll: true,
				autoHeight: true,
				layout: 'fit',
				contentEl: el
			});
			
			uploader.relayEvents(uploadForm, ['stopupload', 'fileadded', 'fileremoved', 'clearqueue']);
			uploader.clearQueue = uploadForm.clearQueue.createDelegate(uploadForm);
			uploader.startUpload = function() { uploadForm.startUpload(); }
			
			uploadForm.uploadBtn.setText("Upload");
			uploadForm.uploadBtn.getEl().replaceClass('x-btn-icon', 'x-btn-text-icon');
			uploadForm.clearBtn.setText("Cancel");
			uploadForm.clearBtn.getEl().replaceClass('x-btn-icon', 'x-btn-text-icon');
		}
		
		return uploader;
	};
}

Ext.gt.ItemImages = function(config) {
	this.cmtype = config.cmtype;
	this.uploadButton = new Ext.Toolbar.Button({text: "Upload", icon: "/util/admin/images/image_add.png", cls: "x-btn-text-icon", handler: this.showUploadDialog, scope: this });
	this.deleteButton = new Ext.Toolbar.Button({text: "Delete", icon: "/util/admin/images/image_delete.png", cls: "x-btn-text-icon", handler: this.deleteImages, scope: this });
	
	Ext.apply(this, config, {
		border: false,
		store: new Ext.data.Store({
			baseParams: {TYPE: this.cmtype},
			proxy: new Ext.data.HttpProxy({url: servletBase + "/getItemImages/admin/jsonObjectsResult.html?objects=images"}),
			reader: new Ext.data.JsonReader({
				root: "images",
				totalProperty: "results",
				id: "IMAGE_ID"
			}, Ext.gt.ItemImages.recordDef),
			sortInfo: {field: 'IMAGE_SORT', direction: 'ASC'}
		}),
		autoExpandColumn: 'YARR',
		enableDragDrop: true,
		ddGroup: 'dd_' + Ext.id(),
		columns: [
			{header: 'Preview', width: 100, dataIndex: 'IMAGE_ID', renderer: this.renderPreview},
			{header: 'Filename', width: 200, dataIndex: 'IMAGE_NAME'},
			{header: 'Description', width: 300, dataIndex: 'IMAGE_DESCRIPTION', editor: new Ext.form.TextArea()},
			{id: 'YARR', header: 'Long Description', width: 200, dataIndex: 'IMAGE_LONG_DESCRIPTION', editor: new Ext.form.TextArea()},
			{header: '<img src="/util/admin/images/pictures.png">', renderer: this.renderSlideShowToggle, width: 30, dataIndex: 'IMAGE_EXCLUDE_SLIDESHOW', menuDisabled: true, tooltip: "Doubleclick to toggle slideshow exclusion of this image"}
		],
		sm: new Ext.grid.RowSelectionModel({singleSelect: false}),
		tbar: [this.uploadButton, this.deleteButton]
	});
	
	Ext.gt.ItemImages.superclass.constructor.call(this);
	
	this.conn = new Ext.data.Connection();
	this.queuedDeleteImages = 0;
	this.cmid = -1;
	
	this.uploader = createUploader({
		cmtype: this.cmtype,
		cmidCallback: function() {return this.cmid},
		url: servletBase + "/insertItemImage",
		fileSelection: "*.png;*.jpg;*.gif",
		fileDescription: "Images",
		scope: this
	});
	this.dialog = new Ext.Window({
		closeAction: 'hide',
		modal: true,
		layout: 'fit',
		title: 'Upload Images',
		width: 400,
		height: 300,
		items: this.uploader
	});
	
	/* Event handlers */
	this.uploader.on('stopupload', function() {
		this.uploader.clearQueue();
		this.refresh();
	}, this);
	this.uploader.on('clearqueue', function() {
		this.dialog.hide();
	}, this);
	this.on('render', function() {
		var dropTarget = new Ext.dd.DropTarget(this.getEl(), {
			itemImages: this,
			ddGroup: this.ddGroup,
			notifyDrop: function(source, e, data) {
				var sel = data.selections;
				var rec = null;
				var newSort = source.getDragData(e).rowIndex + 1;
				if (sel.length > 0) {
					rec = sel[0];
				}
				rec.set('IMAGE_SORT', newSort);
				this.itemImages.updateMetadata({record: rec, field: 'IMAGE_SORT', value: newSort});
			}
		});
	}, this);
	this.on("celldblclick", function(p, row, cell) {
		var r = this.store.getAt(row);
		if (!r) return;
		
		if (cell == 4) {
			r.set("IMAGE_EXCLUDE_SLIDESHOW", r.get("IMAGE_EXCLUDE_SLIDESHOW") == 1 ? 0 : 1);
			this.updateMetadata({record: r, field: "IMAGE_EXCLUDE_SLIDESHOW", value: r.get("IMAGE_EXCLUDE_SLIDESHOW")});
		}
	}, this);
	this.on('afteredit', this.updateMetadata);
};

Ext.gt.ItemImages.recordDef = Ext.data.Record.create([
    'IMAGE_ID', 'CM_TYPE', 'CM_ID', 'IMAGE_NAME', 'IMAGE_SIZE', 'IMAGE_MIME',
    'IMAGE_DESCRIPTION', 'IMAGE_LONG_DESCRIPTION',
    {name: 'IMAGE_SORT', type: 'int'},
    {name: 'IMAGE_EXCLUDE_SLIDESHOW', type: 'int'}
]);

Ext.extend(Ext.gt.ItemImages, Ext.grid.EditorGridPanel, {
	showUploadDialog: function() {
		this.dialog.show(this.uploadButton.getEl());
	},
	
	deleteImageCallback: function() {
		this.queuedDeleteImages--;
		if (this.queuedDeleteImages == 0) {
			this.getEl().unmask();
			this.refresh();
		}
	},
	
	deleteImage: function(imageId) {
		var values = new Object();
		values.ID = this.cmid;
		values.TYPE = this.cmtype;
		values.IMAGE_ID = imageId;
		
		this.conn.request({
			url: servletBase + "/deleteItemImage",
			method: "post",
			params: values,
			success: this.deleteImageCallback,
			scope: this,
			failure: function(){
				Ext.MessageBox.alert('Status', 'aaaaaaaaaaaaaaaaaaarh');
			}
		});
	},
	
	deleteImages: function() {
		var selNodes = this.getSelectionModel().getSelections();
		var ids = new Array();
		for (var i = 0; i < selNodes.length; i++) {
			ids.push(selNodes[i].id);
		}
		
		if (ids.length == 0) {
			return;
		}
		
		Ext.Msg.confirm("Confirm delete", String.format("Confirm delete of {0} image(s)", ids.length), function(b) {
			if (b != 'yes') {
				return;
			}
			this.getEl().mask("Deleting images...");
			this.queuedDeleteImages = ids.length;
			for (var i = 0; i < ids.length; i++) {
				this.deleteImage(ids[i]);
			}
		}, this);
	},
	
	renderPreview: function(val) {
		return String.format('<img src="{1}/getImage?IMAGE_ID={0}&WIDTH=80" />', val, servletBase);
	},
	
	renderSlideShowToggle: function(val) {
		if (val) {
			return "<img src='/util/admin/images/bullet_red.png'>";
		} else {
			return "<img src='/util/admin/images/bullet_green.png'>";
		}
	},
	
	updateMetadata: function(event) {
		var rec = event.record;
		var conn = new Ext.data.Connection();
		var values = new Object();
		values.IMAGE_ID = rec.id;
		values[event.field] = event.value;
		
		conn.request({
			url: servletBase + "/updateImageMetadata",
			method: "post",
			params: values,
			scope: this,
			success: function(responseObject){
				rec.commit();
				if (event.field == 'IMAGE_SORT') {
					this.getEl().child('.x-grid3-viewport .x-grid3-row-selected').frame('8db2e3');
					this.refresh();
					this.getSelectionModel().clearSelections();
				}
			},
			failure: function(){
				Ext.MessageBox.alert('Status', 'aaaaaaaaaaaaaaaaaaarh');
			}
		});
	},
	
	refresh: function(id) {
		if (id) {
			this.cmid = id;
		}
		this.store.load({params: {'ID': this.cmid}});
	},
	
	enable: function() {
		this.uploadButton.enable();
		this.deleteButton.enable();
	},
	
	disable: function() {
		this.uploadButton.disable();
		this.deleteButton.disable();
	}
});

Ext.gt.ItemAttachments = function(config) {
	this.cmtype = config.cmtype;
	this.uploadButton = new Ext.Toolbar.Button({text: "Upload", icon: "/util/admin/images/tag_blue_add.png", cls: "x-btn-text-icon", handler: this.showUploadDialog, scope: this });
	this.deleteButton = new Ext.Toolbar.Button({text: "Delete", icon: "/util/admin/images/tag_blue_delete.png", cls: "x-btn-text-icon", handler: this.deleteAttachments, scope: this });
	
	Ext.apply(this, config, {
		store: new Ext.data.Store({
			baseParams: {TYPE: this.cmtype},
			url: servletBase + "/getItemAttachments/admin/jsonObjectsResult.html?objects=attachments&LANGUAGE=ALL",
			reader: new Ext.data.JsonReader({
				root: "attachments",
				totalProperty: "results",
				id: "ATTACHMENT_ID"
			}, Ext.gt.ItemAttachments.recordDef)
		}),
		border: false,
		loadMask: true,
		autoWidth: true,
		autoExpandColumn: 'EXPANDCOL',
		languageSwitcher: true,
		columns: [
			{header: "", dataIndex: 'ATTACHMENT_ORIGINAL_NAME', width: 125, renderer: this.renderItem},
			{header: "Filename", dataIndex: 'ATTACHMENT_ORIGINAL_NAME', editor: new Ext.form.TextField(), width: 300},
			{id: 'EXPANDCOL', header: "Description", dataIndex: 'ATTACHMENT_DESCRIPTION', editor: new Ext.form.TextArea(), width: 300}
		],
		sm: new Ext.grid.RowSelectionModel({singleSelect: false}),
		tbar: [this.uploadButton, this.deleteButton]
	});
	
	if (this.languageSwitcher) {
		this.columns.push({header: "Language", dataIndex: 'ATTACHMENT_LANGUAGE', editor: languageStore.getCombobox(), width: 200, renderer: this.renderLang });
	}
	
	Ext.gt.ItemAttachments.superclass.constructor.call(this);
	
	this.cmid = -1;
	this.queuedDelete = 0;
	
	this.uploader = createUploader({
		cmtype: this.cmtype,
		cmidCallback: function() {return this.cmid},
		url: servletBase + "/insertItemAttachment",
		fileSelection: "*.*",
		fileDescription: "All files",
		scope: this
	});
	this.dialog = new Ext.Window({
		closeAction: 'hide',
		modal: true,
		layout: 'fit',
		title: 'Upload Attachments',
		width: 400,
		height: 300,
		items: this.uploader
	});
	
	/* Event handlers */
	this.uploader.on('stopupload', function() {
		this.uploader.clearQueue();
		this.refresh();
	}, this);
	this.uploader.on('clearqueue', function() {
		this.dialog.hide();
	}, this);
	this.on('celldblclick', function(grid, row, col) {
		if (col === 0) {	// download for første kolonne
			var rec = this.getSelectionModel().getSelected();
			window.location.replace(servletBase + "/getAttachment?ATTACHMENT_ID=" + rec.get('ATTACHMENT_ID'));
		}
	}, this);
	this.on('afteredit', function(event) {
		var rec = event.record;
		
		var conn = new Ext.data.Connection();
		var values = new Object();
		
		values.ATTACHMENT_ID = rec.get('ATTACHMENT_ID');
		values[event.field] = event.value;
		if (event.field == "ATTACHMENT_LANGUAGE" && event.value == "all") {
			values[event.field] = '';
		}
		
		conn.request({
			url: servletBase + "/updateAttachmentMetadata",
			method: "post",
			params: values,
			success: function(responseObject){
				rec.commit();
			},
			failure: function(){
				Ext.MessageBox.alert('Status', 'aaaaaaaaaaaaaaaaaaarh');
			}
		});
	}, this);
}

Ext.gt.ItemAttachments.recordDef = Ext.data.Record.create([
	'ATTACHMENT_ID', 'CM_TYPE', 'CM_ID', 'ATTACHMENT_NAME', 'ATTACHMENT_ORIGINAL_NAME',
	'ATTACHMENT_SIZE', 'ATTACHMENT_MIME', 'ATTACHMENT_LANGUAGE', 'ATTACHMENT_DESCRIPTION'
]);

Ext.extend(Ext.gt.ItemAttachments, Ext.grid.EditorGridPanel, {
	deleteAttachmentCallback: function() {
		this.queuedDelete--;
		if (this.queuedDelete == 0) {
			this.getEl().unmask();
			this.refresh();
		}
	},
	
	deleteAttachment: function(id) {
		var values = new Object();
		values.ID = this.cmid;
		values.TYPE = this.cmtype;
		values.ATTACHMENT_ID = id;
		
		var conn = new Ext.data.Connection();
		conn.request({
			url: servletBase + "/deleteItemAttachment",
			method: "post",
			params: values,
			success: this.deleteAttachmentCallback,
			scope: this,
			failure: function(){
				Ext.MessageBox.alert('Status', 'aaaaaaaaaaaaaaaaaaarh');
			}
		});
	},
	
	deleteAttachments: function() {
		var selected = this.getSelectionModel().getSelections();
		if (selected.length == 0) {
			return;
		}
		
		Ext.Msg.confirm("Confirm delete", String.format("Confirm delete of {0} attachment(s)", selected.length), function(b) {
			if (b != 'yes') {
				return;
			}
			
			this.getEl().mask("Deleteing attachments...");
			this.queuedDelete = selected.length;
			for (var i = 0; i < selected.length; i++) {
				this.deleteAttachment(selected[i].id);
			}
		}, this);

	},
	
	showUploadDialog: function() {
		this.dialog.show(this.uploadButton.getEl());
	},
	
	renderItem: function(val, cell, rec) {
		var iconpath = '/' + getMimeIconFromMimetype(rec.data['ATTACHMENT_MIME']);
		return String.format('<img src="{0}" style="float: left;"><b>{1}</b><br />Size: {2}', iconpath, "Download", Ext.util.Format.fileSize(rec.data['ATTACHMENT_SIZE']));
	},
	renderLang: function(val, cell, rec) {
		var r = languageStore.get(val);
		if (r == null) return;
		
		return String.format('<div class="x-icon-combo-item x-flag-{0}">{1}</div>', val, r.get('language'));
	},
	
	refresh: function(id) {
		if (id) {
			this.cmid = id;
		}
		this.store.load({params: {'ID': this.cmid}});
	},
	
	enable: function() {
		this.uploadButton.enable();
		this.deleteButton.enable();
	},
	disable: function() {
		this.uploadButton.disable();
		this.deleteButton.disable();
	}
});