steve
/
winamp
mirror of https://github.com/WinampDesktop/winamp.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
winamp/Src/Plugins/Input/in_midi/info.cpp

941 lines
21 KiB
C++
Raw Permalink Normal View History

Initial community commit
2024-09-24 12:54:57 +00:00
#include "main.h"
#include "resource.h"
#include <shlwapi.h>
#include <commdlg.h>
#include <strsafe.h>
#include "../nu/AutoWide.h"
#include "../nu/AutoCharFn.h"
#include "CompressionUtility.h"
extern In_Module mod;
extern "C"
{
#include "genres.h"
}
#define HAVE_BMPVIEW
#ifdef HAVE_BMPVIEW
static LRESULT CALLBACK BmpViewProc(HWND wnd, UINT msg, WPARAM wp, LPARAM lp)
{
switch (msg)
{
case WM_PAINT:
{
RECT r;
GetClientRect(wnd, &r);
HDC wdc = GetDC(wnd);
HDC dc = (HDC)GetWindowLongPtr(wnd, 4);
DrawEdge(wdc, &r, EDGE_SUNKEN, BF_RECT);
if (dc) BitBlt(wdc, 2, 2, r.right - 4, r.bottom - 4, dc, 0, 0, SRCCOPY);
ReleaseDC(wnd, wdc);
ValidateRect(wnd, 0);
return 0;
}
break;
case WM_USER:
{
HDC dc = CreateCompatibleDC(0);
SelectObject(dc, (HBITMAP)lp);
SetWindowLongPtr(wnd, 0, lp);
SetWindowLongPtr(wnd, 4, (LONG_PTR)dc);
//RedrawWindow(wnd,0,0,RDW_INVALIDATE);
}
return 0;
case WM_DESTROY:
{
HBITMAP bmp = (HBITMAP)GetWindowLongPtr(wnd, 0);
HDC dc = (HDC)GetWindowLongPtr(wnd, 4);
if (dc) DeleteDC(dc);
if (bmp) DeleteObject(bmp);
}
break;
}
return DefWindowProc(wnd, msg, wp, lp);
}
void bmpview_init()
{
static bool got_class;
if (!got_class)
{
got_class = 1;
WNDCLASS wc =
{
0,
BmpViewProc,
0, 8,
MIDI_callback::GetInstance(), 0, LoadCursor(0, IDC_ARROW), 0,
0,
L"BitmapView"
};
RegisterClassW(&wc);
}
}
#endif
BOOL SaveFile(HWND w, MIDI_file* mf, BOOL info);
int SaveAsGZip(string filename, const void* buffer, size_t size);
UINT align(UINT x, UINT a)
{
a--;
return (x + a) & ~a;
}
typedef struct
{
UINT ctrl_id;
DWORD riff_id;
// char * name;
}
RMI_TAG;
static void _swap_ptrs(void** a, void* b)
{
void* _a = *a;
*a = b;
if (_a) free(_a);
}
#define swap_ptrs(x,y) _swap_ptrs((void**)&x,(void*)(y))
static RMI_TAG rmi_tagz[] =
{
{IDC_DISP, _rv('DISP')},
{IDC_NAME, _rv('INAM')},
{IDC_ARTIST, _rv('IART')},
{IDC_ALBUM, _rv('IALB')},
{IDC_TRACK, _rv('ITRK')},
{IDC_GENRE, _rv('IGNR')},
{IDC_COMPOSER, _rv('ICMP')},
{IDC_COPYRIGHT, _rv('ICOP')},
{IDC_COMMENT, _rv('ICMT')},
{IDC_DATE, _rv('ICRD')},
{IDC_SOFTWARE, _rv('ISFT')},
{IDC_ENGINEER, _rv('IENG')},
{IDC_SUBJECT, _rv('ISBJ')},
};
void SetDlgItemTextSiz(HWND wnd, UINT id, char* text, UINT siz)
{
if (!text[siz - 1]) SetDlgItemTextA(wnd, id, text);
else
{
char* foo = (char*)alloca(siz + 1);
memcpy(foo, text, siz);
foo[siz] = 0;
SetDlgItemTextA(wnd, id, foo);
}
}
#define N_RMI_TAGZ (sizeof(rmi_tagz)/sizeof(rmi_tagz[0]))
static void set_rmi_dlg_title(HWND wnd, MIDI_file* mf)
{
char t[MAX_PATH + 100] = { 0 };
StringCbPrintfA(t, sizeof(t), WASABI_API_LNGSTRING(STRING_RMI_INFO_FMT), (const char*)mf->path);
SetWindowTextA(wnd, t);
}
static BOOL CALLBACK rmiproc(HWND wnd, UINT msg, WPARAM wp, LPARAM lp)
{
switch (msg)
{
case WM_INITDIALOG:
#if defined(_WIN64)
SetWindowLong(wnd, DWLP_USER, lp);
#else
SetWindowLong(wnd, DWL_USER, lp);
#endif
{
MIDI_file* mf = (MIDI_file*)lp;
set_rmi_dlg_title(wnd, mf);
if (mf->title && *mf->title)
{
SetDlgItemTextA(wnd, IDC_DISP, mf->title);
}
if (mf->rmi_data)
{
BYTE* rmi = (BYTE*)mf->rmi_data;
int p = 4;
while (p < mf->rmi_size)
{
DWORD id = *(DWORD*)(rmi + p);
UINT n;
for (n = 0; n < N_RMI_TAGZ; n++)
{
if (id == rmi_tagz[n].riff_id)
{
SetDlgItemTextSiz(wnd, rmi_tagz[n].ctrl_id, (char*)(rmi + p + 8), *(DWORD*)(rmi + p + 4));
break;
}
}
p += 8 + align(*(DWORD*)(rmi + p + 4), 2);
}
}
#ifdef HAVE_BMPVIEW
if (mf->bmp_data)
{
void* pixels;
BITMAPINFOHEADER* foo = (BITMAPINFOHEADER*)mf->bmp_data;
HBITMAP bmp = CreateDIBSection(0, (BITMAPINFO*)foo, DIB_RGB_COLORS, &pixels, 0, 0);
if (bmp)
{
UINT clr_used = foo->biClrUsed;
if (!clr_used) clr_used = 1 << foo->biBitCount;
BYTE* ptr = (BYTE*)foo + foo->biSize + (clr_used << 2);
int max = (BYTE*)mf->bmp_data + mf->bmp_size - ptr;
BITMAP b;
GetObject(bmp, sizeof(b), &b);
int siz = b.bmWidthBytes * b.bmHeight;
if (siz < 0) siz = -siz;
if (siz > max) siz = max;
memcpy(pixels, ptr, siz);
SendDlgItemMessage(wnd, IDC_BMPVIEW, WM_USER, 0, (long)bmp);
}
}
#endif
}
genres_read(GetDlgItem(wnd, IDC_GENRE));
return 1;
case WM_COMMAND:
switch (wp)
{
case IDOK:
{
#if defined(_WIN64)
MIDI_file* mf = (MIDI_file*)GetWindowLong(wnd, DWLP_USER);
#else
MIDI_file* mf = (MIDI_file*)GetWindowLong(wnd, DWL_USER);
#endif
char* title = 0;
HWND w = GetDlgItem(wnd, IDC_DISP);
UINT sz = GetWindowTextLength(w);
if (sz)
{
sz++;
title = (char*)malloc(sz);
GetWindowTextA(w, title, sz);
}
swap_ptrs(mf->title, title);
BYTE* rmi_info = 0;
UINT rmi_siz = 0;
UINT n;
for (n = 0; n < N_RMI_TAGZ; n++)
{
UINT d = GetWindowTextLength(GetDlgItem(wnd, rmi_tagz[n].ctrl_id));
if (d) rmi_siz += align(d + 1, 2) + 8;
}
if (rmi_siz)
{
rmi_siz += 4; //'INFO'
rmi_info = (BYTE*)malloc(rmi_siz);
UINT ptr = 4;
*(DWORD*)rmi_info = _rv('INFO');
for (n = 0; n < N_RMI_TAGZ; n++)
{
w = GetDlgItem(wnd, rmi_tagz[n].ctrl_id);
if (GetWindowTextLength(w))
{
*(DWORD*)(rmi_info + ptr) = rmi_tagz[n].riff_id;
ptr += 4;
char* foo = (char*)(rmi_info + ptr + 4);
GetWindowTextA(w, foo, rmi_siz - (ptr + 4));
UINT s = strlen(foo) + 1;
*(DWORD*)(rmi_info + ptr) = s;
ptr += 4 + align(s, 2);
}
}
rmi_siz = ptr;
}
mf->rmi_size = rmi_siz;
swap_ptrs(mf->rmi_data, rmi_info);
genres_write(GetDlgItem(wnd, IDC_GENRE));
if (SaveFile(wnd, mf, 1)) EndDialog(wnd, 0);
}
break;
case IDCANCEL:
genres_write(GetDlgItem(wnd, IDC_GENRE));
EndDialog(wnd, 1);
break;
}
break;
}
return 0;
}
int show_rmi_info(HWND w, MIDI_file* mf)
{
#ifdef HAVE_BMPVIEW
bmpview_init();
#endif
return WASABI_API_DIALOGBOXPARAM(IDD_RMI_SHIZ, w, rmiproc, (long)mf);
}
static bool is_local(const char* url)
{
if (!_strnicmp(url, "file://", 7) || !strnicmp(url, "partial://", 10)) return 1;
if (url[1] == ':' && url[2] == '\\') return 1;
return strstr(url, "://") ? 0 : 1;
}
static char* fmt_names[] = { "MIDI", "RIFF MIDI", "HMP", "HMI", "XMIDI", "MUS", "CMF", "GMD", "MIDS", "GMF", "MIDI(?)" };
const char* find_tag(MIDI_file* mf, DWORD id, UINT* siz);
char* getfmtstring(MIDI_file* f, char* s)
{
const char* z = fmt_names[f->format];
while (z && *z) *(s++) = *(z++);
if (f->format <= 1) //MID/RMI
{
char foo[32] = { 0 };
StringCbPrintfA(foo, sizeof(foo), WASABI_API_LNGSTRING(STRING_INFO_FORMAT_FMT), f->data[4 + 4 + 1]);
z = foo;
while (z && *z) *(s++) = *(z++);
}
if (f->info.e_type)
{
*(s++) = ' ';
*(s++) = '(';
z = f->info.e_type;
while (z && *z) *(s++) = *(z++);
*(s++) = ')';
}
*s = 0;
return s;
}
void file2title(const char* f, string& t);
static const char* find_tag(MIDI_file* mf, DWORD id, UINT* siz)
{
if (!mf->rmi_data) return 0;
char* rmi = (char*)mf->rmi_data;
int ptr = 4;
while (ptr < mf->rmi_size)
{
if (*(DWORD*)(rmi + ptr) == id)
{
UINT s = *(DWORD*)(rmi + ptr + 4);
UINT s1 = 0;
ptr += 8;
while (rmi[ptr + s1] && s1 < s) s1++;
if (siz) *siz = s1;
return rmi + ptr;
}
ptr += align(*(DWORD*)(rmi + ptr + 4), 2) + 8;
}
return 0;
}
bool KeywordMatch(const char* mainString, const char* keyword)
{
return !_stricmp(mainString, keyword);
}
static const wchar_t* pExtList[] = { L"MID",L"MIDI",L"RMI",L"KAR",L"HMP",L"HMI",L"XMI",L"MSS",L"MUS",L"CMF",L"GMD",L"MIDS",L"MIZ",L"HMZ" };
static const int pExtDescIdList[] = { 0, 0, 0, 1, 2, 2, 3, 4, 5, 6, 7, 0, 8, 9 };
static const int pExtDescList[] =
{
IDS_FAMILY_STRING_MIDI,
IDS_FAMILY_STRING_KARAOKE_MIDI,
IDS_FAMILY_STRING_HMI_MIDI,
IDS_FAMILY_STRING_EXTENDED_MIDI,
IDS_FAMILY_STRING_MSS_MIDI,
IDS_FAMILY_STRING_FINALE_MIDI,
IDS_FAMILY_STRING_CREATIVE_MIDI,
IDS_FAMILY_STRING_GENERAL_MIDI_DUMP,
IDS_FAMILY_STRING_COMPRESSED_MIDI,
IDS_FAMILY_STRING_COMPRESSED_HMI_MIDI
};
MIDI_file* wa2_open_file(const char* url);
extern "C" __declspec(dllexport) int winampGetExtendedFileInfoW(const wchar_t* fn, const char* data, wchar_t* dest, int destlen)
{
MIDI_file* file = 0;
if (KeywordMatch(data, "type"))
{
dest[0] = L'0';
dest[1] = 0;
return 1;
}
if (KeywordMatch(data, "BURNABLE"))
{
dest[0] = L'0';
dest[1] = 0;
return 1;
}
if (KeywordMatch(data, "noburnreason")) // note: this isn't supposed to be any kind of protection - just keeps the burner from misbehaving on protected tracks
{
WASABI_API_LNGSTRINGW_BUF(IDS_MIDIS_ARE_NOT_BURNABLE, dest, destlen);
return 1;
}
if (KeywordMatch(data, "family"))
{
INT index;
LPCWSTR e;
DWORD lcid;
e = PathFindExtensionW(fn);
if (L'.' != *e || 0x00 == *(++e)) return 0;
lcid = MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), SORT_DEFAULT);
for (index = sizeof(pExtList) / sizeof(wchar_t*) - 1; index >= 0 && CSTR_EQUAL != CompareStringW(lcid, NORM_IGNORECASE, e, -1, pExtList[index], -1); index--);
if (index >= 0 && S_OK == StringCchCopyW(dest, destlen, WASABI_API_LNGSTRINGW(pExtDescList[pExtDescIdList[index]]))) return 1;
return 0;
}
file = wa2_open_file(AutoCharFn(fn));
if (!file)
{
return 0;
}
const char* ret = 0;
//else if (!_stricmp(tag,"FILEPATH") || !_stricmp(tag,"PATH")) ret=file->path;
//else if (!_stricmp(tag,"DISPLAY")) ret=file->title;
//else if (!_stricmp(tag,"FIRSTTRACK")) ret=file->info.traxnames[0];
if (KeywordMatch(data, "LENGTH"))
{
_itow(file->GetLength(), dest, 10);
file->Free();
return 1;
}
else if (file->rmi_data)
{
if (KeywordMatch(data, "TITLE")) ret = find_tag(file, _rv('INAM'), 0);
else if (KeywordMatch(data, "ARTIST")) ret = find_tag(file, _rv('IART'), 0);
else if (KeywordMatch(data, "COMPOSER")) ret = find_tag(file, _rv('ICMP'), 0);
else if (KeywordMatch(data, "GENRE")) ret = find_tag(file, _rv('IGNR'), 0);
else if (KeywordMatch(data, "ALBUM")) ret = find_tag(file, _rv('IALB'), 0);
else if (KeywordMatch(data, "COPYRIGHT")) ret = find_tag(file, _rv('ICOP'), 0);
else if (KeywordMatch(data, "COMMENT")) ret = find_tag(file, _rv('ICMT'), 0);
else if (KeywordMatch(data, "TRACK")) ret = find_tag(file, _rv('ITRK'), 0);
else if (KeywordMatch(data, "DATE")) ret = find_tag(file, _rv('ICRD'), 0);
else
{
file->Free();
return 0;
}
}
else
{
file->Free();
return 0;
}
if (ret)
{
lstrcpynW(dest, AutoWide(ret), destlen);
}
file->Free();
return !!ret;
}
void MIDI_file::GetTitle(char* buf, int maxlen)
{
string file_title;
file2title(path, file_title);
lstrcpynA(buf, file_title, maxlen);
}
//int save_gzip(MIDI_file* mf, char* path);
static void do_ext(string& s, const char* ext)
{
const char* p = strrchr(s, '.');
if (p) s.truncate(p - (const char*)s);
s += ext;
}
void* build_rmi(MIDI_file* mf, UINT* siz)
{
UINT sz = 0x14 + align(mf->size, 2);
UINT t_sz = 0;
if (mf->title)
{
t_sz = strlen(mf->title);
if (t_sz)
{
t_sz++; //add null;
sz += 12 + align(t_sz, 2);
}
}
if (mf->rmi_data)
{
sz += align(mf->rmi_size + 8, 2);
}
if (mf->bmp_data)
{
sz += align(mf->bmp_size + 12, 2);
}
if (mf->pDLSdata) sz += align(mf->DLSsize, 2);
BYTE* block = (BYTE*)malloc(sz);
BYTE* b_ptr = block;
*(DWORD*)b_ptr = _rv('RIFF');
b_ptr += 4;
*(DWORD*)b_ptr = sz - 8;
b_ptr += 4;
*(DWORD*)b_ptr = _rv('RMID');
b_ptr += 4;
*(DWORD*)b_ptr = _rv('data');
b_ptr += 4;
*(DWORD*)b_ptr = mf->size;
b_ptr += 4;
memcpy(b_ptr, mf->data, mf->size);
b_ptr += align(mf->size, 2);
if (t_sz)
{
*(DWORD*)b_ptr = _rv('DISP');
b_ptr += 4;
*(DWORD*)b_ptr = t_sz + 4;
b_ptr += 4;
*(DWORD*)b_ptr = 1;
b_ptr += 4;
memcpy(b_ptr, mf->title, t_sz);
b_ptr += align(t_sz, 2);
}
if (mf->rmi_data)
{
*(DWORD*)b_ptr = _rv('LIST');
b_ptr += 4;
*(DWORD*)b_ptr = mf->rmi_size;
b_ptr += 4;
memcpy(b_ptr, mf->rmi_data, mf->rmi_size);
b_ptr += align(mf->rmi_size, 2);
}
if (mf->bmp_data)
{
*(DWORD*)b_ptr = _rv('DISP');
b_ptr += 4;
*(DWORD*)b_ptr = mf->bmp_size + 4;
b_ptr += 4;
*(DWORD*)b_ptr = 8;
b_ptr += 4;
memcpy(b_ptr, mf->bmp_data, mf->bmp_size);
b_ptr += align(mf->bmp_size, 2);
}
if (mf->pDLSdata)
{
memcpy(b_ptr, mf->pDLSdata, mf->DLSsize);
b_ptr += align(mf->DLSsize, 2);
}
*siz = sz;
return block;
}
BOOL SaveFile(HWND w, MIDI_file* mf, BOOL info)
{
BOOL rmi_only = info;
string tmp;
if (is_local(mf->path) && _strnicmp(mf->path, "partial://", 10))
{
tmp = mf->path;
if (!info) do_ext(tmp, ".mid");
}
else
{
info = 0;
file2title(mf->path, tmp);
tmp += ".mid";
}
if (mf->format > 1) info = 0; //not MID/RMI
UINT fmt = 0;
BOOL do_gzip = 0;
if (!info)
{
char filter[512] = { 0 };
OPENFILENAMEA ofn = { sizeof(ofn),0 };
ofn.hwndOwner = w;
ofn.lpstrFile = tmp.buffer_get(MAX_PATH + 1);
ofn.nMaxFile = MAX_PATH;
ofn.Flags = OFN_PATHMUSTEXIST | OFN_HIDEREADONLY;
ofn.lpstrDefExt = "";
ofn.lpstrFilter = filter;
char* pf = filter, * sf = 0;
int len = 0;
#define APPEND(x) {memcpy(pf,x,len);pf+=len;}
if (!rmi_only)
{
sf = BuildFilterString(IDS_MIDI_FILES, "MID", &len);
APPEND(sf);
sf = BuildFilterString(IDS_COMPRESSED_MIDI_FILES, "MIZ", &len);
APPEND(sf);
}
sf = BuildFilterString(IDS_RMI_FILES, "RMI", &len);
APPEND(sf);
sf = BuildFilterString(IDS_COMPRESSED_RMI_FILES, "MIZ", &len);
APPEND(sf);
#undef APPEND
* pf = 0;
if (!GetSaveFileNameA(&ofn)) return 0;
tmp.buffer_done();
fmt = ofn.nFilterIndex - 1;
do_gzip = fmt & 1;
fmt >>= 1;
if (rmi_only) fmt = 1;
if (do_gzip) do_ext(tmp, ".miz");
else if (fmt == 1) do_ext(tmp, ".rmi");
else do_ext(tmp, ".mid");
}
else
{
fmt = 1;
const char* p = strrchr(tmp, '.');
if (p && !_stricmp(p, ".miz")) do_gzip = 1;
}
{
if (fmt > 1) fmt = 0;
BOOL local = 0;
const void* buf = 0;
UINT buf_size = 0;
if (fmt == 0)
{
buf = mf->data;
buf_size = mf->size;
}
else //if (fmt==1)
{
local = 1;
buf = build_rmi(mf, &buf_size);
}
int rv;
if (do_gzip)
{
rv = SaveAsGZip(tmp, buf, buf_size);
}
else
{
HANDLE f = CreateFileA(tmp, GENERIC_WRITE, 0, 0, CREATE_ALWAYS, 0, 0);
if (f != INVALID_HANDLE_VALUE)
{
DWORD bw = 0;
WriteFile(f, buf, buf_size, &bw, 0);
CloseHandle(f);
rv = 1;
}
else rv = 0;
}
if (local) free((void*)buf);
if (!_stricmp(mf->path, tmp))
{
mf->format = fmt;
}
if (!rv)
{
char _m[320] = { 0 };
StringCbPrintfA(_m, sizeof(_m), WASABI_API_LNGSTRING(STRING_WRITE_ERROR_FMT), (const char*)tmp);
MessageBoxA(w, _m, ERROR, MB_ICONERROR);
}
return rv;
}
}
/// <summary>
/// Compress given buffer with GZIP format and saves to given filename
/// </summary>
/// <param name="filename"></param>
/// <param name="buffer"></param>
/// <param name="size"></param>
/// <returns></returns>
int SaveAsGZip(string filename, const void* buffer, size_t size)
{
void* data;
size_t data_len = size;
int ret = CompressionUtility::CompressAsGZip(buffer, size, &data, data_len);
if (ret >= 0)
{
try
{
HANDLE f = CreateFileA(filename, GENERIC_WRITE, 0, 0, CREATE_ALWAYS, 0, 0);
if (f != INVALID_HANDLE_VALUE)
{
DWORD bw = 0;
WriteFile(f, data, data_len, &bw, 0);
CloseHandle(f);
return 1;
}
}
catch (...)
{
DWORD i = GetLastError();
return 0;
}
}
return 0;
}
#define _pr ((MIDI_file*)(lp))
static cfg_struct_t<RECT> cfg_infpos("infpos", -1);
static UINT inf_x_min = 0x80000000, inf_y_min, inf_c_x, inf_c_y;
static RECT r_trax, r_text;
static void SetWindowRect(HWND w, RECT* r)
{
SetWindowPos(w, 0, r->left, r->top, r->right - r->left, r->bottom - r->top, SWP_NOZORDER);
}
void cGetWindowRect(HWND w, RECT* r)
{
RECT tr, tr1;
GetWindowRect(w, &tr);
SetWindowPos(w, 0, 0, 0, 0, 0, SWP_NOZORDER | SWP_NOSIZE);
GetWindowRect(w, &tr1);
r->left = tr.left - tr1.left;
r->right = tr.right - tr1.left;
r->top = tr.top - tr1.top;
r->bottom = tr.bottom - tr1.top;
SetWindowRect(w, r);
}
#define RB_NUM 3
static struct
{
UINT id, dx, dy;
}
rb_dat[RB_NUM] =
{
{IDC_SAVE, 0, 0},
{IDOK, 0, 0},
{IDC_RMI_CRAP, 0, 0},
};
#define BOTTOM_NUM 8
static struct
{
UINT id;
UINT x, dy;
}
b_dat[BOTTOM_NUM] =
{
{IDC_STATIC1, 0, 0},
{IDC_STATIC2, 0, 0},
{IDC_STATIC3, 0, 0},
{IDC_TIX, 0, 0},
{IDC_MS, 0, 0},
{IDC_FSIZE, 0, 0},
{IDC_DLS, 0, 0},
{IDC_LOOP, 0, 0}
};
static void OnSize(HWND wnd)
{
RECT cl, t;
GetClientRect(wnd, &cl);
t.left = r_text.left;
t.right = r_text.right;
t.top = r_text.top;
t.bottom = cl.bottom - (inf_c_y - r_text.bottom);
SetWindowRect(GetDlgItem(wnd, IDC_COPYRIGHT), &t);
t.left = r_trax.left;
t.right = cl.right - (inf_c_x - r_trax.right);
t.top = r_trax.top;
t.bottom = cl.bottom - (inf_c_y - r_trax.bottom);
SetWindowRect(GetDlgItem(wnd, IDC_TRAX), &t);
UINT n;
for (n = 0; n < BOTTOM_NUM; n++)
{
SetWindowPos(GetDlgItem(wnd, b_dat[n].id), 0, b_dat[n].x, cl.bottom - b_dat[n].dy, 0, 0, SWP_NOZORDER | SWP_NOSIZE);
}
for (n = 0; n < RB_NUM; n++)
{
SetWindowPos(GetDlgItem(wnd, rb_dat[n].id), 0, cl.right - rb_dat[n].dx, cl.bottom - rb_dat[n].dy, 0, 0, SWP_NOZORDER | SWP_NOSIZE);
}
}
BOOL WINAPI InfoProc(HWND wnd, UINT msg, WPARAM wp, LPARAM lp)
{
switch (msg)
{
case WM_INITDIALOG:
if (inf_x_min == 0x80000000)
{
RECT r;
GetWindowRect(wnd, &r);
inf_x_min = r.right - r.left;
inf_y_min = r.bottom - r.top;
GetClientRect(wnd, &r);
inf_c_x = r.right;
inf_c_y = r.bottom;
cGetWindowRect(GetDlgItem(wnd, IDC_COPYRIGHT), &r_text);
cGetWindowRect(GetDlgItem(wnd, IDC_TRAX), &r_trax);
UINT n;
for (n = 0; n < BOTTOM_NUM; n++)
{
cGetWindowRect(GetDlgItem(wnd, b_dat[n].id), &r);
b_dat[n].x = r.left;
b_dat[n].dy = inf_c_y - r.top;
}
for (n = 0; n < RB_NUM; n++)
{
cGetWindowRect(GetDlgItem(wnd, rb_dat[n].id), &r);
rb_dat[n].dx = inf_c_x - r.left;
rb_dat[n].dy = inf_c_y - r.top;
}
}
if (cfg_infpos.get_val().left != -1)
{
int sx = GetSystemMetrics(SM_CXSCREEN), sy = GetSystemMetrics(SM_CYSCREEN);
if (cfg_infpos.get_val().right > sx)
{
cfg_infpos.get_val().left -= cfg_infpos.get_val().right - sx;
cfg_infpos.get_val().right = sx;
}
if (cfg_infpos.get_val().bottom > sy)
{
cfg_infpos.get_val().top -= cfg_infpos.get_val().bottom - sy;
cfg_infpos.get_val().bottom = sy;
}
if (cfg_infpos.get_val().left < 0)
{
cfg_infpos.get_val().right -= cfg_infpos.get_val().left;
cfg_infpos.get_val().left = 0;
}
if (cfg_infpos.get_val().top < 0)
{
cfg_infpos.get_val().bottom -= cfg_infpos.get_val().top;
cfg_infpos.get_val().top = 0;
}
SetWindowRect(wnd, &cfg_infpos.get_val());
OnSize(wnd);
}
#if defined(_WIN64)
SetWindowLong(wnd, DWLP_USER, lp);
#else
SetWindowLong(wnd, DWL_USER, lp);
#endif
SetDlgItemTextA(wnd, IDC_COPYRIGHT, _pr->info.copyright);
SetDlgItemInt(wnd, IDC_MS, _pr->len, 0);
SetDlgItemInt(wnd, IDC_TIX, _pr->info.tix, 0);
{
char tmp[128] = { 0 };
getfmtstring(_pr, tmp);
SetDlgItemTextA(wnd, IDC_FORMAT, tmp);
HANDLE f = CreateFileA(_pr->path, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE, 0, OPEN_EXISTING, 0, 0);
if (f != INVALID_HANDLE_VALUE)
{
StringCbPrintfA(tmp, sizeof(tmp), WASABI_API_LNGSTRING(STRING_BYTES_FMT), GetFileSize(f, 0));
CloseHandle(f);
SetDlgItemTextA(wnd, IDC_FSIZE, tmp);
}
}
{
char tmp[1024] = { 0 };
if (_pr->info.traxnames)
{
HWND lb = GetDlgItem(wnd, IDC_TRAX);
UINT n;
for (n = 0; n < _pr->info.ntrax; n++)
{
StringCbPrintfA(tmp, sizeof(tmp), "(%u) %s", n, (const char*)(_pr->info.traxnames[n]));
SendMessageA(lb, LB_ADDSTRING, 0, (LPARAM)tmp);
}
}
StringCbPrintfA(tmp, sizeof(tmp), WASABI_API_LNGSTRING(STRING_TRACKS_FMT), _pr->info.ntrax);
SetDlgItemTextA(wnd, IDC_NTRAX, tmp);
if (_pr->title)
{
StringCbPrintfA(tmp, sizeof(tmp), WASABI_API_LNGSTRING(STRING_MIDI_INFO_FMT1), (const char*)_pr->title, (const char*)_pr->path);
}
else
{
StringCbPrintfA(tmp, sizeof(tmp), WASABI_API_LNGSTRING(STRING_MIDI_INFO_FMT2), (const char*)_pr->path);
}
if (_pr->flags & FLAG_INCOMPLETE) StringCbCatA(tmp, sizeof(tmp), WASABI_API_LNGSTRING(STRING_INCOMPLETE));
SetWindowTextA(wnd, tmp);
}
if (_pr->pDLSdata) EnableWindow(GetDlgItem(wnd, IDC_DLS), 1);
if (_pr->loopstart) EnableWindow(GetDlgItem(wnd, IDC_LOOP), 1);
//if (_pr->rmi_data) EnableWindow(GetDlgItem(wnd,IDC_RMI_CRAP),1);
return 1;
case WM_SIZE:
OnSize(wnd);
break;
case WM_SIZING:
if (lp)
{
RECT* r = (RECT*)lp;
if ((UINT)(r->right - r->left) < inf_x_min)
{
if (wp != WMSZ_LEFT && wp != WMSZ_TOPLEFT && wp != WMSZ_BOTTOMLEFT)
r->right = r->left + inf_x_min;
else r->left = r->right - inf_x_min;
}
if ((UINT)(r->bottom - r->top) < inf_y_min)
{
if (wp != WMSZ_TOP && wp != WMSZ_TOPLEFT && wp != WMSZ_TOPRIGHT)
r->bottom = r->top + inf_y_min;
else r->top = r->bottom - inf_y_min;
}
}
break;
case WM_COMMAND:
if (wp == IDOK || wp == IDCANCEL)
{
EndDialog(wnd, /*changed ? 0 : 1*/0);
}
else if (wp == IDC_SAVE)
{
#if defined(_WIN64)
SaveFile(wnd, (MIDI_file*)GetWindowLong(wnd, DWLP_USER), 0);
#else
SaveFile(wnd, (MIDI_file*)GetWindowLong(wnd, DWL_USER), 0);
#endif
}
else if (wp == IDC_RMI_CRAP)
{
#if defined(_WIN64)
MIDI_file* mf = (MIDI_file*)GetWindowLong(wnd, DWLP_USER);
#else
MIDI_file* mf = (MIDI_file*)GetWindowLong(wnd, DWL_USER);
#endif
show_rmi_info(wnd, mf);
}
break;
case WM_CLOSE:
EndDialog(wnd, /*changed ? 0 : 1*/0);
break;
case WM_DESTROY:
GetWindowRect(wnd, &cfg_infpos.get_val());
break;
}
return 0;
}
#undef _pr