Initial community commit

1 files changed, 790 insertions, 0 deletions

diff --git a/Src/Plugins/Library/ml_pmp/editinfo.cpp b/Src/Plugins/Library/ml_pmp/editinfo.cpp
new file mode 100644
index 00000000..cbd40630
--- /dev/null
+++ b/Src/Plugins/Library/ml_pmp/editinfo.cpp
@@ -0,0 +1,790 @@
+#include "main.h"
+#include "DeviceView.h"
+#include "api__ml_pmp.h"
+#include <api/service/waServiceFactory.h>
+#include <api/service/svcs/svc_imgload.h>
+#include <api/service/svcs/svc_imgwrite.h>
+#include <api/memmgr/api_memmgr.h>
+#include <tataki/bitmap/bitmap.h>
+#include <tataki/canvas/bltcanvas.h>
+
+extern C_ItemList devices;
+extern HWND hwndMediaView;
+
+static C_ItemList * editItems;
+static Device * editDevice;
+
+typedef struct {
+	int w;
+	int h;
+	ARGB32 * data;
+} editinfo_image;
+
+static INT_PTR CALLBACK editInfo_commit_dialogProc(HWND hwnd, UINT uMsg, WPARAM wParam,LPARAM lParam) {
+	static int i;
+	switch(uMsg) {
+		case WM_INITDIALOG:
+			i=0;
+			SetWindowText(hwnd,WASABI_API_LNGSTRINGW(IDS_SETTING_METADATA));
+			SendDlgItemMessage(hwnd,IDC_PROGRESS,PBM_SETRANGE,0,MAKELPARAM(0, editItems->GetSize()));
+			SetTimer(hwnd,1,5,NULL);
+
+			if (FALSE != CenterWindow(hwnd, (HWND)lParam))
+			SendMessage(hwnd, DM_REPOSITION, 0, 0L);
+
+			break;
+		case WM_TIMER:
+			if(wParam == 1) {
+				KillTimer(hwnd,1);
+				HWND hwndDlg = GetParent(hwnd);
+				editinfo_image * image = (editinfo_image *)GetWindowLongPtr(hwndDlg,GWLP_USERDATA);
+				SendDlgItemMessage(hwnd,IDC_PROGRESS,PBM_SETPOS,i,0);
+				if(i < editItems->GetSize()) {
+					int metadata_edited=0;
+					songid_t song=(songid_t)editItems->Get(i);
+					time_t t; time(&t);
+					editDevice->setTrackLastUpdated(song,t);
+					if(IsDlgButtonChecked(hwndDlg,IDC_CHECK_ARTIST)) {
+						wchar_t blah[512] = {0};
+						GetDlgItemText(hwndDlg,IDC_EDIT_ARTIST,blah,sizeof(blah)/sizeof(wchar_t)-1);
+						blah[sizeof(blah)/sizeof(wchar_t)-1]=0;
+						editDevice->setTrackArtist(song,blah);
+						metadata_edited++;
+					}
+					if(IsDlgButtonChecked(hwndDlg,IDC_CHECK_TITLE)) {
+						wchar_t blah[512] = {0};
+						GetDlgItemText(hwndDlg,IDC_EDIT_TITLE,blah,sizeof(blah)/sizeof(wchar_t)-1);
+						blah[sizeof(blah)/sizeof(wchar_t)-1]=0;
+						editDevice->setTrackTitle(song,blah);
+						metadata_edited++;
+					}
+					if(IsDlgButtonChecked(hwndDlg,IDC_CHECK_ALBUM)) {
+						wchar_t blah[512] = {0};
+						GetDlgItemText(hwndDlg,IDC_EDIT_ALBUM,blah,sizeof(blah)/sizeof(wchar_t)-1);
+						blah[sizeof(blah)/sizeof(wchar_t)-1]=0;
+						editDevice->setTrackAlbum(song,blah);
+						metadata_edited++;
+					}
+					if(IsDlgButtonChecked(hwndDlg,IDC_CHECK_GENRE)) {
+						wchar_t blah[512] = {0};
+						GetDlgItemText(hwndDlg,IDC_EDIT_GENRE,blah,sizeof(blah)/sizeof(wchar_t)-1);
+						blah[sizeof(blah)/sizeof(wchar_t)-1]=0;
+						editDevice->setTrackGenre(song,blah);
+						metadata_edited++;
+					}
+					if(IsDlgButtonChecked(hwndDlg,IDC_CHECK_TRACK)) {
+						wchar_t blah[64] = {0};
+						GetDlgItemText(hwndDlg,IDC_EDIT_TRACK,blah,sizeof(blah)/sizeof(wchar_t)-1);
+						blah[sizeof(blah)/sizeof(wchar_t)-1]=0;
+						int n=_wtoi(blah);
+						if (n <= 0) n=-1;
+						editDevice->setTrackTrackNum(song,n);
+						metadata_edited++;
+					}
+					if(IsDlgButtonChecked(hwndDlg,IDC_CHECK_DISC)) {
+						wchar_t blah[64] = {0};
+						GetDlgItemText(hwndDlg,IDC_EDIT_DISC,blah,sizeof(blah)/sizeof(wchar_t)-1);
+						blah[sizeof(blah)/sizeof(wchar_t)-1]=0;
+						int n=_wtoi(blah);
+						if (n <= 0) n=-1;
+						editDevice->setTrackDiscNum(song,n);
+						metadata_edited++;
+					}
+					if(IsDlgButtonChecked(hwndDlg,IDC_CHECK_YEAR)) {
+						wchar_t blah[64] = {0};
+						GetDlgItemText(hwndDlg,IDC_EDIT_YEAR,blah,sizeof(blah)/sizeof(wchar_t)-1);
+						blah[sizeof(blah)/sizeof(wchar_t)-1]=0;
+						int n=_wtoi(blah);
+						if (n <= 0) n=-1;
+						editDevice->setTrackYear(song,n);
+						metadata_edited++;
+					}
+					if(IsDlgButtonChecked(hwndDlg,IDC_CHECK_ALBUMARTIST)) {
+						wchar_t blah[512] = {0};
+						GetDlgItemText(hwndDlg,IDC_EDIT_ALBUMARTIST,blah,sizeof(blah)/sizeof(wchar_t)-1);
+						blah[sizeof(blah)/sizeof(wchar_t)-1]=0;
+						editDevice->setTrackAlbumArtist(song,blah);
+						metadata_edited++;
+					}
+					if(IsDlgButtonChecked(hwndDlg,IDC_CHECK_PUBLISHER)) {
+						wchar_t blah[512] = {0};
+						GetDlgItemText(hwndDlg,IDC_EDIT_PUBLISHER,blah,sizeof(blah)/sizeof(wchar_t)-1);
+						blah[sizeof(blah)/sizeof(wchar_t)-1]=0;
+						editDevice->setTrackPublisher(song,blah);
+						metadata_edited++;
+					}
+					if(IsDlgButtonChecked(hwndDlg,IDC_CHECK_COMPOSER)) {
+						wchar_t blah[512] = {0};
+						GetDlgItemText(hwndDlg,IDC_EDIT_COMPOSER,blah,sizeof(blah)/sizeof(wchar_t)-1);
+						blah[sizeof(blah)/sizeof(wchar_t)-1]=0;
+						editDevice->setTrackComposer(song,blah);
+						metadata_edited++;
+					}
+					if(IsDlgButtonChecked(hwndDlg,IDC_CHECK_ALBUMART)) {
+						if(!image) editDevice->setArt(song,NULL,0,0);
+						else editDevice->setArt(song,image->data,image->w,image->h);
+					}
+
+					if (metadata_edited)
+					{
+						editDevice->extraActions(DEVICE_DONE_SETTING, (intptr_t)song,0,0);
+					}
+					SetTimer(hwnd,1,5,NULL);
+				}
+				else {
+					editDevice->commitChanges();
+					EndDialog(hwnd,0);
+				}
+				i++;
+			}
+			break;
+		case WM_COMMAND:
+			if(LOWORD(wParam) == IDC_ABORT) {
+				editDevice->commitChanges();
+				EndDialog(hwnd,-1);
+			}
+			break;
+	}
+	return 0;
+}
+
+static ARGB32 * loadImg(const void * data, int len, int *w, int *h) {
+	FOURCC imgload = svc_imageLoader::getServiceType();
+	int n = plugin.service->service_getNumServices(imgload);
+	for(int i=0; i<n; i++) {
+		waServiceFactory *sf = plugin.service->service_enumService(imgload,i);
+		if(sf) {
+			svc_imageLoader * l = (svc_imageLoader*)sf->getInterface();
+			if(l) {
+				if(l->testData(data,len)) {
+					ARGB32* ret = l->loadImage(data,len,w,h);
+					sf->releaseInterface(l);
+					return ret;
+				}
+				sf->releaseInterface(l);
+			}
+		}
+	}
+	return NULL;
+}
+
+static void * loadFile(const wchar_t * file, int &len) {	
+	len=0;
+	FILE * f = _wfopen(file,L"rb");
+	if(!f) return 0;
+	fseek(f,0,2);
+	len = ftell(f);
+	if(!len) {fclose(f); return 0;}
+	fseek(f,0,0);
+	void * data = calloc(len, sizeof(void*));
+	fread(data,len,1,f);
+	fclose(f);
+	return data;
+}
+
+static ARGB32 * loadImgFromFile(const wchar_t * file, int *w, int *h) {
+	int len;
+	void * d = loadFile(file,len);
+	if(!d) return 0;
+	ARGB32 * im = loadImg(d,len,w,h);
+	free(d);
+	return im;
+}
+
+static void * writeImg(const ARGB32 *data, int w, int h, int *length, const wchar_t *ext) {
+	if(!ext || !*ext) return NULL;
+	if(*ext == L'.') ext++;
+	FOURCC imgwrite = svc_imageWriter::getServiceType();
+	int n = plugin.service->service_getNumServices(imgwrite);
+	for(int i=0; i<n; i++) {
+		waServiceFactory *sf = plugin.service->service_enumService(imgwrite,i);
+		if(sf) {
+			svc_imageWriter * l = (svc_imageWriter*)sf->getInterface();
+			if(l) {
+				if(wcsstr(l->getExtensions(),ext)) {
+					void* ret = l->convert(data,32,w,h,length);
+					sf->releaseInterface(l);
+					return ret;
+				}
+				sf->releaseInterface(l);
+			}
+		}
+	}
+	return NULL;
+}
+
+static void writeFile(const wchar_t *file, void * data, int length) {
+	FILE *f = _wfopen(file,L"wb");
+	if(!f) return;
+	fwrite(data,length,1,f);
+	fclose(f);
+}
+
+static void writeImageToFile(ARGB32 * img, int w, int h, const wchar_t *file) {
+	int length=0;
+	void * data = writeImg(img,w,h,&length,wcsrchr(file,L'.'));
+	if(data) {
+		writeFile(file,data,length);
+		WASABI_API_MEMMGR->sysFree(data);
+	}
+}
+
+static void enableArt(HWND hwndDlg, bool combo, BOOL enable) {
+	if(combo) EnableWindow(GetDlgItem(hwndDlg,IDC_CHECK_ALBUMART),enable);
+	EnableWindow(GetDlgItem(hwndDlg,IDC_ARTINFO),enable);
+	EnableWindow(GetDlgItem(hwndDlg,IDC_PICTUREHOLDER),enable);
+	EnableWindow(GetDlgItem(hwndDlg,IDC_ART_CHANGE),enable);
+	EnableWindow(GetDlgItem(hwndDlg,IDC_ART_CLEAR),enable);
+}
+
+static int checkEditInfoClick(HWND hwndDlg, POINT p, int item, int check, bool art=false) {
+	if(!IsWindowEnabled(GetDlgItem(hwndDlg,check))) return 0;
+	RECT r;
+	GetWindowRect(GetDlgItem(hwndDlg, item), &r);
+	ScreenToClient(hwndDlg, (LPPOINT)&r);
+	ScreenToClient(hwndDlg, (LPPOINT)&r.right);
+	if (PtInRect(&r, p) && !IsDlgButtonChecked(hwndDlg, check)) {
+		CheckDlgButton(hwndDlg, check, TRUE);
+		if(art) enableArt(hwndDlg,false,TRUE);
+		else EnableWindow(GetDlgItem(hwndDlg, item), TRUE);
+		EnableWindow(GetDlgItem(hwndDlg, IDOK), TRUE);
+		PostMessage(hwndDlg, WM_NEXTDLGCTL, (WPARAM)GetDlgItem(hwndDlg, item), TRUE);
+		return 1;
+	}
+	return 0;
+}
+
+static HBITMAP getBitmap(const editinfo_image * image, HWND parent) {
+	BITMAPINFO info={0};
+	info.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
+	info.bmiHeader.biWidth = image->w;
+	info.bmiHeader.biHeight = -image->h;
+	info.bmiHeader.biPlanes = 1;
+	info.bmiHeader.biBitCount = 32;
+	info.bmiHeader.biCompression = BI_RGB;
+	HDC dc = GetDC(parent);
+	HBITMAP bm = CreateCompatibleBitmap(dc,image->w,image->h);
+	SetDIBits(dc,bm,0,image->h,image->data,&info,DIB_RGB_COLORS);
+	ReleaseDC(parent,dc);
+	return bm;
+}
+
+static HBITMAP getBitmap(pmpart_t art, Device * dev, HWND parent) {
+	int w,h;
+	editDevice->getArtNaturalSize(art,&w,&h);
+	if(w == 0 || h == 0) return NULL;
+	ARGB32 * bits = (ARGB32 *)calloc(w * h, sizeof(ARGB32));
+	if(!bits) return NULL;
+	editDevice->getArtData(art,bits);
+	editinfo_image im={w,h,bits};
+	HBITMAP bm = getBitmap(&im,parent);
+	free(bits);
+	return bm;
+}
+
+static void setBitmap(const editinfo_image * image, HWND hwndDlg, bool init=false) {
+	if(!init) {
+		CheckDlgButton(hwndDlg,IDC_CHECK_ALBUMART,BST_CHECKED);
+		enableArt(hwndDlg,false,TRUE);
+		SendMessage(hwndDlg,WM_COMMAND,MAKEWPARAM(IDC_ART_CLEAR,0),0);
+	}
+	HQSkinBitmap temp(image->data, image->w, image->h); // wrap into a SkinBitmap (no copying involved)
+	BltCanvas newImage(90,90);
+	temp.stretch(&newImage, 0, 0, 90, 90);
+	editinfo_image i = {90,90,(ARGB32*)newImage.getBits()};
+	HBITMAP bm = getBitmap(&i,hwndDlg);
+	HBITMAP bmold = (HBITMAP)SendDlgItemMessage(hwndDlg,IDC_PICTUREHOLDER,STM_SETIMAGE,IMAGE_BITMAP,(LPARAM)bm);
+	if(bmold) DeleteObject(bmold);
+	SetWindowLongPtr(hwndDlg,GWLP_USERDATA,(LONG_PTR)image);
+	wchar_t buf[100] = {0};
+	wsprintf(buf,L"%dx%d",image->w,image->h);
+	SetDlgItemText(hwndDlg,IDC_ARTINFO,buf);
+}
+
+static void GetSize(HBITMAP bm,int &w, int &h,HWND hwndDlg) {
+	HDC dc = GetDC(hwndDlg);
+	BITMAPINFO info={0};
+	info.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
+	GetDIBits(dc,bm,0,0,NULL,&info,DIB_RGB_COLORS);
+	w = abs(info.bmiHeader.biWidth);
+	h = abs(info.bmiHeader.biHeight);
+	ReleaseDC(hwndDlg,dc);
+}
+
+static void setBitmap(HBITMAP bm, HWND hwndDlg) {
+	editinfo_image* image = (editinfo_image*)calloc(1, sizeof(editinfo_image));
+	GetSize(bm,image->w,image->h,hwndDlg);
+	image->data = (ARGB32*)WASABI_API_MEMMGR->sysMalloc(sizeof(ARGB32)*image->w*image->h);
+	BITMAPINFO info={0};
+	info.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
+	info.bmiHeader.biWidth = image->w;
+	info.bmiHeader.biHeight = -image->h;
+	info.bmiHeader.biPlanes = 1;
+	info.bmiHeader.biBitCount = 32;
+	info.bmiHeader.biCompression = BI_RGB;
+	HDC dc = GetDC(hwndDlg);
+	GetDIBits(dc,bm,0,image->h,image->data,&info,DIB_RGB_COLORS);
+	ReleaseDC(hwndDlg,dc);
+	setBitmap(image,hwndDlg);
+}
+
+static INT_PTR CALLBACK editInfo_dialogProc(HWND hwndDlg, UINT uMsg, WPARAM wParam,LPARAM lParam) {
+	switch(uMsg) {
+		case WM_INITDIALOG:
+		{
+			wchar_t last_artist[2048]=L"", last_title[2048]=L"", last_album[2048]=L"", last_genre[2048]=L"", last_albumartist[2048]=L"", last_publisher[2048]=L"", last_composer[2048]=L"";
+			pmpart_t last_albumart=NULL;
+			int last_year=-1, last_track=-1, last_disc=-1;
+			bool disable_artist=0, disable_title=0, disable_album=0, disable_genre=0, disable_year=0, disable_track=0, disable_disc=0, disable_albumartist=0, disable_publisher=0, disable_composer=0, disable_albumart=0;
+			int fieldBits = (int)editDevice->extraActions(DEVICE_SUPPORTED_METADATA,0,0,0);
+			if(!fieldBits) fieldBits = -1;
+			disable_artist = (fieldBits & SUPPORTS_ARTIST)==0;
+			disable_title = (fieldBits & SUPPORTS_TITLE)==0;
+			disable_album = (fieldBits & SUPPORTS_ALBUM)==0;
+			disable_genre = (fieldBits & SUPPORTS_GENRE)==0;
+			disable_year = (fieldBits & SUPPORTS_YEAR)==0;
+			disable_track = (fieldBits & SUPPORTS_TRACKNUM)==0;
+			disable_disc = (fieldBits & SUPPORTS_DISCNUM)==0;
+			disable_albumartist = (fieldBits & SUPPORTS_ALBUMARTIST)==0;
+			disable_publisher = (fieldBits & SUPPORTS_PUBLISHER)==0;
+			disable_composer = (fieldBits & SUPPORTS_COMPOSER)==0;
+			disable_albumart = (fieldBits & SUPPORTS_ALBUMART)==0;
+
+			EnableWindow(GetDlgItem(hwndDlg, IDOK), FALSE);
+
+			EnableWindow(GetDlgItem(hwndDlg,IDC_CHECK_ARTIST),!disable_artist);
+			EnableWindow(GetDlgItem(hwndDlg,IDC_CHECK_TITLE),!disable_title);
+			EnableWindow(GetDlgItem(hwndDlg,IDC_CHECK_ALBUM),!disable_album);
+			EnableWindow(GetDlgItem(hwndDlg,IDC_CHECK_GENRE),!disable_genre);
+			EnableWindow(GetDlgItem(hwndDlg,IDC_CHECK_YEAR),!disable_year);
+			EnableWindow(GetDlgItem(hwndDlg,IDC_CHECK_TRACK),!disable_track);
+			EnableWindow(GetDlgItem(hwndDlg,IDC_CHECK_DISC),!disable_disc);
+			EnableWindow(GetDlgItem(hwndDlg,IDC_CHECK_ALBUMARTIST),!disable_albumartist);
+			EnableWindow(GetDlgItem(hwndDlg,IDC_CHECK_PUBLISHER),!disable_publisher);
+			EnableWindow(GetDlgItem(hwndDlg,IDC_CHECK_COMPOSER),!disable_composer);
+			EnableWindow(GetDlgItem(hwndDlg,IDC_CHECK_ALBUMART),!disable_albumart);
+			//enableArt(hwndDlg,true,!disable_albumart);
+
+			int l=editItems->GetSize();
+			for(int i=0;i<l;i++) {
+				wchar_t buf[2048]=L"";
+				songid_t song=(songid_t)editItems->Get(i);
+				if(!disable_artist)
+				{
+					buf[0]=0;
+					editDevice->getTrackArtist(song,buf,sizeof(buf)/sizeof(wchar_t));
+					if(!buf[0]);
+					else if(!last_artist[0]) lstrcpyn(last_artist,buf,2048);
+					else if(lstrcmp(buf,last_artist)) disable_artist=true;
+				}
+				if(!disable_albumartist)
+				{
+					buf[0]=0;
+					editDevice->getTrackAlbumArtist(song,buf,sizeof(buf)/sizeof(wchar_t));
+					if(!buf[0]);
+					else if(!last_albumartist[0]) lstrcpyn(last_albumartist,buf,2048);
+					else if(lstrcmp(buf,last_albumartist)) disable_albumartist=true;
+				}
+				if(!disable_publisher)
+				{
+					buf[0]=0;
+					editDevice->getTrackPublisher(song,buf,sizeof(buf)/sizeof(wchar_t));
+					if(!buf[0]);
+					else if(!last_publisher[0]) lstrcpyn(last_publisher,buf,2048);
+					else if(lstrcmp(buf,last_publisher)) disable_publisher=true;
+				}
+				if(!disable_composer)
+				{
+					buf[0]=0;
+					editDevice->getTrackComposer(song,buf,sizeof(buf)/sizeof(wchar_t));
+					if(!buf[0]);
+					else if(!last_composer[0]) lstrcpyn(last_composer,buf,2048);
+					else if(lstrcmp(buf,last_composer)) disable_composer=true;
+				}
+				if(!disable_title)
+				{
+					buf[0]=0;
+					editDevice->getTrackTitle(song,buf,sizeof(buf)/sizeof(wchar_t));
+					if(!buf[0]);
+					else if(!last_title[0]) 
+					lstrcpyn(last_title,buf,2048);
+					else if(lstrcmp(buf,last_title)) disable_title=true;
+				}
+				if(!disable_album)
+				{
+					buf[0]=0;
+					editDevice->getTrackAlbum(song,buf,sizeof(buf)/sizeof(wchar_t));
+					if(!buf[0]);
+					else if(!last_album[0]) lstrcpyn(last_album,buf,2048);
+					else if(lstrcmp(buf,last_album)) disable_album=true;
+				}
+				if(!disable_genre)
+				{
+					buf[0]=0;
+					editDevice->getTrackGenre(song,buf,sizeof(buf)/sizeof(wchar_t));
+					if(!buf[0]);
+					else if(!last_genre[0]) lstrcpyn(last_genre,buf,2048);
+					else if(lstrcmp(buf,last_genre)) disable_genre=true;
+				}
+				if(!disable_year)
+				{
+					int val=editDevice->getTrackYear(song);
+					if(val <= 0);
+					else if(last_year==-1) last_year=val;
+					else if(last_year!=val) disable_year=true;
+				}
+				if(!disable_track)
+				{
+					int val=editDevice->getTrackTrackNum(song);
+					if(val <= 0);
+					else if(last_track==-1) last_track=val;
+					else if(last_track!=val) disable_track=true;
+				}
+				if(!disable_disc)
+				{
+					int val=editDevice->getTrackDiscNum(song);
+					if(val <= 0);
+					else if(last_disc==-1) last_disc=val;
+					else if(last_disc!=val) disable_disc=true;
+				}	
+				if(!disable_albumart)
+				{
+					pmpart_t a = editDevice->getArt(song);
+					if(!a);
+					else if(!last_albumart) { editDevice->releaseArt(last_albumart); last_albumart = a; }
+					else if(!editDevice->artIsEqual(a,last_albumart)) { disable_albumart=true; editDevice->releaseArt(a); editDevice->releaseArt(last_albumart); last_albumart=0; }
+				}
+			}
+			if(!disable_artist && last_artist) SetDlgItemText(hwndDlg,IDC_EDIT_ARTIST,last_artist);
+			if(!disable_albumartist && last_albumartist) SetDlgItemText(hwndDlg,IDC_EDIT_ALBUMARTIST,last_albumartist);
+			if(!disable_publisher && last_publisher) SetDlgItemText(hwndDlg,IDC_EDIT_PUBLISHER,last_publisher);
+			if(!disable_composer && last_composer) SetDlgItemText(hwndDlg,IDC_EDIT_COMPOSER,last_composer);
+			if(!disable_title && last_title) SetDlgItemText(hwndDlg,IDC_EDIT_TITLE,last_title);
+			if(!disable_album && last_album) SetDlgItemText(hwndDlg,IDC_EDIT_ALBUM,last_album);
+			if(!disable_genre && last_genre) SetDlgItemText(hwndDlg,IDC_EDIT_GENRE,last_genre);
+			if(!disable_year && last_year>0) {
+				wchar_t tmp[64] = {0};
+				wsprintf(tmp,L"%d",last_year);
+		        SetDlgItemText(hwndDlg,IDC_EDIT_YEAR,tmp);
+			}
+			if(!disable_track && last_track>0) {
+				wchar_t tmp[64] = {0};
+				wsprintf(tmp,L"%d",last_track);
+				SetDlgItemText(hwndDlg,IDC_EDIT_TRACK,tmp);
+			}
+			if(!disable_disc && last_disc>0) {
+				wchar_t tmp[64] = {0};
+				wsprintf(tmp,L"%d",last_disc);
+				SetDlgItemText(hwndDlg,IDC_EDIT_DISC,tmp);
+			}
+			if(!disable_albumart && last_albumart) {
+				// save copy of image
+				editinfo_image* image = (editinfo_image*)calloc(1, sizeof(editinfo_image));
+				editDevice->getArtNaturalSize(last_albumart,&image->w,&image->h);
+				image->data = (ARGB32*)WASABI_API_MEMMGR->sysMalloc(sizeof(ARGB32)*image->w*image->h);
+				editDevice->getArtData(last_albumart,image->data);
+				setBitmap(image,hwndDlg,true);
+				editDevice->releaseArt(last_albumart);
+			}
+			else SetWindowLongPtr(hwndDlg,GWLP_USERDATA,0);
+
+			if (FALSE != CenterWindow(hwndDlg, (HWND)lParam))
+				SendMessage(hwndDlg, DM_REPOSITION, 0, 0L);
+
+		}
+		break;
+		case WM_LBUTTONDOWN:
+		{
+			POINTS p = MAKEPOINTS(lParam);
+			POINT p2 = {p.x, p.y};
+			if (checkEditInfoClick(hwndDlg, p2, IDC_EDIT_ARTIST, IDC_CHECK_ARTIST)) break;
+			if (checkEditInfoClick(hwndDlg, p2, IDC_EDIT_TITLE, IDC_CHECK_TITLE)) break;
+			if (checkEditInfoClick(hwndDlg, p2, IDC_EDIT_ALBUM, IDC_CHECK_ALBUM)) break;
+			if (checkEditInfoClick(hwndDlg, p2, IDC_EDIT_TRACK, IDC_CHECK_TRACK)) break;
+			if (checkEditInfoClick(hwndDlg, p2, IDC_EDIT_DISC, IDC_CHECK_DISC)) break;
+			if (checkEditInfoClick(hwndDlg, p2, IDC_EDIT_GENRE, IDC_CHECK_GENRE)) break;
+			if (checkEditInfoClick(hwndDlg, p2, IDC_EDIT_YEAR, IDC_CHECK_YEAR)) break;
+			if (checkEditInfoClick(hwndDlg, p2, IDC_EDIT_ALBUMARTIST, IDC_CHECK_ALBUMARTIST)) break;
+			if (checkEditInfoClick(hwndDlg, p2, IDC_EDIT_COMPOSER, IDC_CHECK_COMPOSER)) break;
+			if (checkEditInfoClick(hwndDlg, p2, IDC_EDIT_PUBLISHER, IDC_CHECK_PUBLISHER)) break;
+			if (checkEditInfoClick(hwndDlg, p2, IDC_PICTUREHOLDER, IDC_CHECK_ALBUMART,true)) break;
+			if (checkEditInfoClick(hwndDlg, p2, IDC_ART_CLEAR, IDC_CHECK_ALBUMART,true)) break;
+			if (checkEditInfoClick(hwndDlg, p2, IDC_ART_CHANGE, IDC_CHECK_ALBUMART,true)) break;
+			if (checkEditInfoClick(hwndDlg, p2, IDC_ARTINFO, IDC_CHECK_ALBUMART,true)) break;
+		}
+		break;
+		case WM_RBUTTONDOWN:
+		{
+			POINTS pts = MAKEPOINTS(lParam);
+			POINT p = {pts.x, pts.y};
+			RECT r;
+			GetWindowRect(GetDlgItem(hwndDlg, IDC_PICTUREHOLDER), &r);
+			ScreenToClient(hwndDlg, (LPPOINT)&r);
+			ScreenToClient(hwndDlg, (LPPOINT)&r.right);
+			if(PtInRect(&r, p)) { // right click on picture holder
+				extern HMENU m_context_menus;
+				HMENU menu = GetSubMenu(m_context_menus, 11);
+				POINT p;
+				GetCursorPos(&p);
+				wchar_t artist[256]=L"";
+				wchar_t album[256]=L"";
+				GetDlgItemText(hwndDlg,IDC_EDIT_ALBUMARTIST,artist,256);
+				if(!artist[0])
+					GetDlgItemText(hwndDlg,IDC_EDIT_ARTIST,artist,256);
+				GetDlgItemText(hwndDlg,IDC_EDIT_ALBUM,album,256);
+
+				bool canpaste=(!!IsClipboardFormatAvailable(CF_DIB));
+				bool hasimage= (GetWindowLongPtr(hwndDlg,GWLP_USERDATA) != 0);
+				EnableMenuItem(menu, ID_ARTEDITMENU_PASTE, MF_BYCOMMAND | (canpaste?MF_ENABLED:MF_GRAYED));
+				EnableMenuItem(menu, ID_ARTEDITMENU_COPY, MF_BYCOMMAND | (hasimage?MF_ENABLED:MF_GRAYED));
+				EnableMenuItem(menu, ID_ARTEDITMENU_DELETE, MF_BYCOMMAND | (hasimage?MF_ENABLED:MF_GRAYED));
+				EnableMenuItem(menu, ID_ARTEDITMENU_SAVEAS, MF_BYCOMMAND | (hasimage?MF_ENABLED:MF_GRAYED));
+
+				// disabled 30 May 2012 as per email from Tejas w.r.t. to Rovi deal ending
+				#if 0
+				bool candownload = (album[0] || artist[0]);
+				EnableMenuItem(menu, ID_ARTEDITMENU_DOWNLOAD, MF_BYCOMMAND | (candownload?MF_ENABLED:MF_GRAYED));
+				#else
+				DeleteMenu(menu, ID_ARTEDITMENU_DOWNLOAD, MF_BYCOMMAND);
+				#endif
+
+				int r = TrackPopupMenu(menu, TPM_RETURNCMD | TPM_RIGHTBUTTON | TPM_LEFTBUTTON, p.x, p.y, 0, hwndDlg, NULL);
+				switch(r) {
+					// disabled 30 May 2012 as per email from Tejas w.r.t. to Rovi deal ending
+					#if 0
+					case ID_ARTEDITMENU_DOWNLOAD:
+					{
+						artFetchData d = {sizeof(d),hwndDlg,artist,album,0};
+						int r = (int)SendMessage(plugin.hwndWinampParent,WM_WA_IPC,(LPARAM)&d,IPC_FETCH_ALBUMART);
+						if(r == 0 && d.imgData && d.imgDataLen) // success, save art in correct location
+						{
+							int w=0,h=0;
+							ARGB32* bytes = loadImg(d.imgData,d.imgDataLen,&w,&h);
+							if(bytes)
+							{
+								editinfo_image *image = (editinfo_image *)calloc(1, sizeof(editinfo_image));
+								image->data = bytes;
+								image->w = w;
+								image->h = h;
+								setBitmap(image,hwndDlg);
+							}
+							WASABI_API_MEMMGR->sysFree(d.imgData);
+						}
+					}
+					break;
+					#endif
+					case ID_ARTEDITMENU_COPY:
+					{
+						if (!OpenClipboard(hwndDlg)) break;
+						EmptyClipboard(); 
+						HBITMAP bm = getBitmap((editinfo_image*)GetWindowLongPtr(hwndDlg,GWLP_USERDATA),hwndDlg);
+						SetClipboardData(CF_BITMAP,bm);
+						CloseClipboard();
+					}
+					break;
+					case ID_ARTEDITMENU_PASTE:
+					{
+						if (!OpenClipboard(hwndDlg)) break;
+						HBITMAP bm = (HBITMAP)GetClipboardData(CF_BITMAP);
+						if(bm) setBitmap(bm,hwndDlg);
+						CloseClipboard();
+					}
+					break;
+					case ID_ARTEDITMENU_DELETE:
+						CheckDlgButton(hwndDlg,IDC_CHECK_ALBUMART,BST_CHECKED);
+						enableArt(hwndDlg,false,TRUE);
+						SendMessage(hwndDlg,WM_COMMAND,MAKEWPARAM(IDC_ART_CLEAR,0),0);
+						break;
+					case ID_ARTEDITMENU_SAVEAS:
+					{
+
+						static int tests_run = 0;
+						wchar_t file[1024] = {0};
+						static wchar_t filter[1024] = {0}, *sff = filter;
+						OPENFILENAME fn = {0};
+						fn.lStructSize = sizeof(fn);
+						fn.hwndOwner = hwndDlg;
+						fn.lpstrFile = file;
+						fn.nMaxFile = 1020;
+
+						if(!tests_run)
+						{
+							tests_run = 1;
+							FOURCC imgload = svc_imageLoader::getServiceType();
+							int n = plugin.service->service_getNumServices(imgload);
+							size_t size = 1024;
+							for (int i = 0, j = 0; i<n; i++)
+							{
+								waServiceFactory *sf = plugin.service->service_enumService(imgload,i);
+								if (sf)
+								{
+									svc_imageLoader * l = (svc_imageLoader*)sf->getInterface();
+									if (l)
+									{
+										wchar_t *tests[] = {L"*.jpg",L"*.png",L"*.gif",L"*.bmp"};
+										for(int i = 0; i < sizeof(tests)/sizeof(tests[0]); i++)
+										{
+											if (l->isMine(tests[i]))
+											{
+												j++;
+												int len = 0, tests_str[] = {IDS_JPEG_FILE,IDS_PNG_FILE,IDS_GIF_FILE,IDS_BMP_FILE};
+												WASABI_API_LNGSTRINGW_BUF(tests_str[i],sff,size);
+												size-=(len = lstrlenW(sff)+1);
+												sff+=len;
+												lstrcpynW(sff,tests[i],size);
+												size-=(len = lstrlenW(sff)+1);
+												sff+=len;
+											}
+										}
+										sf->releaseInterface(l);
+									}
+								}
+							}
+						}
+
+						fn.lpstrFilter = filter;
+						fn.Flags = OFN_OVERWRITEPROMPT;
+						GetSaveFileName(&fn);
+						int l = wcslen(file);
+						if(l>4 && file[l-4]==L'.'); // we have an extention
+						else switch(fn.nFilterIndex) {
+							case 1: StringCchCat(file, ARRAYSIZE(file), L".jpg"); break;
+							case 2: StringCchCat(file, ARRAYSIZE(file), L".png"); break;
+							case 3: StringCchCat(file, ARRAYSIZE(file), L".gif"); break;
+							case 4: StringCchCat(file, ARRAYSIZE(file), L".bmp"); break;
+						}
+						editinfo_image *image = (editinfo_image *)GetWindowLongPtr(hwndDlg,GWLP_USERDATA);
+						writeImageToFile(image->data,image->w,image->h,file);
+					}
+					break;
+				}
+			}
+		}
+		break;
+		case WM_COMMAND:
+#define HANDLE_CONTROL(item, check) { int enabled = IsDlgButtonChecked(hwndDlg, check); EnableWindow(GetDlgItem(hwndDlg, item), enabled); EnableWindow(GetDlgItem(hwndDlg, IDOK), enabled); }
+			switch(LOWORD(wParam)) {
+
+				case IDC_CHECK_ARTIST: HANDLE_CONTROL(IDC_EDIT_ARTIST, IDC_CHECK_ARTIST); break;
+				case IDC_CHECK_TITLE: HANDLE_CONTROL(IDC_EDIT_TITLE, IDC_CHECK_TITLE); break;
+				case IDC_CHECK_ALBUM: HANDLE_CONTROL(IDC_EDIT_ALBUM, IDC_CHECK_ALBUM); break;
+				case IDC_CHECK_ALBUMARTIST: HANDLE_CONTROL(IDC_EDIT_ALBUMARTIST, IDC_CHECK_ALBUMARTIST); break;
+				case IDC_CHECK_COMPOSER: HANDLE_CONTROL(IDC_EDIT_COMPOSER, IDC_CHECK_COMPOSER); break;
+				case IDC_CHECK_PUBLISHER: HANDLE_CONTROL(IDC_EDIT_PUBLISHER, IDC_CHECK_PUBLISHER); break;
+				case IDC_CHECK_TRACK: HANDLE_CONTROL(IDC_EDIT_TRACK, IDC_CHECK_TRACK); break;
+				case IDC_CHECK_DISC: HANDLE_CONTROL(IDC_EDIT_DISC, IDC_CHECK_DISC); break;
+				case IDC_CHECK_GENRE: HANDLE_CONTROL(IDC_EDIT_GENRE, IDC_CHECK_GENRE); break;
+				case IDC_CHECK_YEAR: HANDLE_CONTROL(IDC_EDIT_YEAR, IDC_CHECK_YEAR); break;
+				//case IDC_CHECK_COMMENT: HANDLE_CONTROL(IDC_EDIT_COMMENT, IDC_CHECK_COMMENT); break;
+				//case IDC_CHECK_CATEGORY: HANDLE_CONTROL(IDC_EDIT_CATEGORY, IDC_CHECK_CATEGORY); break;
+				//case IDC_CHECK_DIRECTOR: HANDLE_CONTROL(IDC_EDIT_DIRECTOR, IDC_CHECK_DIRECTOR); break;
+				//case IDC_CHECK_PRODUCER: HANDLE_CONTROL(IDC_EDIT_PRODUCER, IDC_CHECK_PRODUCER); break;
+				//case IDC_CHECK_BPM: HANDLE_CONTROL(IDC_EDIT_BPM, IDC_CHECK_BPM); break;
+				//case IDC_CHECK_RATING: HANDLE_CONTROL(IDC_COMBO_RATING, IDC_CHECK_RATING); break;
+				case IDC_CHECK_ALBUMART:
+				{
+					int enabled = IsDlgButtonChecked(hwndDlg, IDC_CHECK_ALBUMART);
+					enableArt(hwndDlg, false, enabled);
+					EnableWindow(GetDlgItem(hwndDlg, IDOK), enabled);
+					break;
+				}
+				case IDC_ART_CLEAR:
+				{
+					editinfo_image* image = (editinfo_image*)GetWindowLongPtr(hwndDlg,GWLP_USERDATA);
+					if(image) {
+						if(image->data) WASABI_API_MEMMGR->sysFree(image->data);
+						free(image);
+					}
+					SetDlgItemText(hwndDlg,IDC_ARTINFO,WASABI_API_LNGSTRINGW(IDS_NO_IMAGE));
+					SetWindowLongPtr(hwndDlg,GWLP_USERDATA,0);
+					HBITMAP old = (HBITMAP)SendDlgItemMessage(hwndDlg,IDC_PICTUREHOLDER,STM_SETIMAGE,IMAGE_BITMAP,(LPARAM)0);
+					DeleteObject(old);
+				}
+				break;
+				case IDC_ART_CHANGE:
+				{
+					static wchar_t fileExtensionsString[MAX_PATH] = {0};
+					wchar_t file[1024]=L"";
+					OPENFILENAME fn = {0};
+					fn.lStructSize = sizeof(fn);
+					fn.hwndOwner = hwndDlg;
+					fn.lpstrFile = file;
+					fn.nMaxFile = 1024;
+
+					if(!fileExtensionsString[0])
+					{
+						WASABI_API_LNGSTRINGW_BUF(IDS_IMAGE_FILES,fileExtensionsString,MAX_PATH);
+						wchar_t *temp=fileExtensionsString+lstrlenW(fileExtensionsString) + 1;
+
+						// query the available image loaders and build it against the supported formats
+						FOURCC imgload = svc_imageLoader::getServiceType();
+						int n = plugin.service->service_getNumServices(imgload);
+						for (int i=0; i<n; i++)
+						{
+							waServiceFactory *sf = plugin.service->service_enumService(imgload,i);
+							if (sf)
+							{
+								svc_imageLoader * l = (svc_imageLoader*)sf->getInterface();
+								if (l)
+								{
+									wchar_t *tests[] = {L"*.jpg",L"*.png",L"*.gif",L"*.bmp"};
+									for(int i = 0; i < sizeof(tests)/sizeof(tests[0]); i++)
+									{
+										if (l->isMine(tests[i]))
+										{
+											StringCchCatW(temp,MAX_PATH,tests[i]);
+											StringCchCatW(temp,MAX_PATH,L";");
+										}
+									}
+									sf->releaseInterface(l);
+								}
+							}
+						}
+						*(temp = temp + lstrlenW(temp) + 1) = 0;
+					}
+
+					fn.lpstrFilter = fileExtensionsString;
+					fn.Flags = OFN_PATHMUSTEXIST | OFN_FILEMUSTEXIST;
+					GetOpenFileName(&fn);
+					editinfo_image *image = (editinfo_image *)calloc(1, sizeof(editinfo_image));
+					image->data = loadImgFromFile(file,&image->w,&image->h);
+					if(!image->data) { free(image); break; }
+					setBitmap(image,hwndDlg);
+				}
+				break;
+				case IDOK:
+				{
+					if(WASABI_API_DIALOGBOXPARAMW(IDD_PROGRESS,hwndDlg,editInfo_commit_dialogProc, (LPARAM)hwndDlg) == 0)
+						EndDialog(hwndDlg,0);
+					DeviceView * editDeviceView=NULL;
+					for(int i=0; i < devices.GetSize(); i++) if(((DeviceView*)devices.Get(i))->dev == editDevice) editDeviceView = (DeviceView*)devices.Get(i);
+					if(editDeviceView) editDeviceView->DevicePropertiesChanges();
+					SendMessage(hwndMediaView,WM_USER+2,1,0);
+				}
+				break;
+				case IDCANCEL:
+					EndDialog(hwndDlg,0);
+				break;
+			}
+		break;
+		case WM_DESTROY:
+		{
+			editinfo_image* image = (editinfo_image*)GetWindowLongPtr(hwndDlg,GWLP_USERDATA);
+			if(image) {
+				if(image->data) WASABI_API_MEMMGR->sysFree(image->data);
+				free(image);
+			}
+			SetWindowLongPtr(hwndDlg,GWLP_USERDATA,0);
+			HBITMAP bmold = (HBITMAP)SendDlgItemMessage(hwndDlg,IDC_PICTUREHOLDER,STM_GETIMAGE,IMAGE_BITMAP,0);
+			if(bmold) DeleteObject(bmold);
+		}
+		break;
+	}
+	return FALSE;
+}
+
+void editInfo(C_ItemList * items, Device * dev, HWND centerWindow) {
+	editItems = items;
+	editDevice = dev;
+	WASABI_API_DIALOGBOXPARAMW(IDD_EDIT_INFO, plugin.hwndLibraryParent, editInfo_dialogProc, (LPARAM)centerWindow);
+}
\ No newline at end of file