// factorization for _dtFlags..
void SNM_KnobCaption::DrawText(LICE_IBitmap* _drawbm, RECT* _rect, UINT _dtFlags)
{
if (LICE_CachedFont* font = GetFont())
{
char buf[64] = "";
if (m_value || !m_zeroTxt.GetLength())
_snprintfSafe(buf, sizeof(buf), "%s\n%d %s", m_title.Get(), m_value, m_suffix.Get());
else
_snprintfSafe(buf, sizeof(buf), "%s\n%s", m_title.Get(), m_zeroTxt.Get());
font->DrawText(_drawbm, buf, -1, _rect, _dtFlags);
}
}
void SetStartupSearchOptions (bool official, bool beta, unsigned int lastTime)
{
char tmp[256];
if (lastTime == 0) // lastTime = 0 will prevent overwriting current lastTime
{
GetPrivateProfileString("SWS", STARTUP_VERSION_KEY, "", tmp, sizeof(tmp), get_ini_file());
LineParser lp(false);
lp.parse(tmp);
lastTime = lp.gettoken_uint(2);
}
_snprintfSafe(tmp, sizeof(tmp), "%d %d %u", !!official, !!beta, lastTime);
WritePrivateProfileString("SWS", STARTUP_VERSION_KEY, tmp, get_ini_file());
}
bool SNM_ReadMediaFileTag(const char *fn, const char* tag, char* tagval, int tagval_sz)
{
if (!fn || !*fn || !tagval || tagval_sz<=0) return false;
*tagval=0;
#ifdef _WIN32
wchar_t* w_fn = WideCharPlz(fn);
if (!w_fn) return false;
TagLib::FileRef f(w_fn, false);
#else
TagLib::FileRef f(fn, false);
#endif
if (!f.isNull() && !f.tag()->isEmpty())
{
TagLib::String s;
if (!_stricmp(tag, "artist")) s=f.tag()->artist();
else if (!_stricmp(tag, "album")) s=f.tag()->album();
else if (!_stricmp(tag, "genre")) s=f.tag()->genre();
else if (!_stricmp(tag, "comment")) s=f.tag()->comment();
else if (!_stricmp(tag, "title")) s=f.tag()->title();
if (s.length())
{
const char *p=s.toCString(true);
if (strcmp(p,"0")) lstrcpyn(tagval, p, tagval_sz); // must be a taglib bug...
}
else
{
if (!_stricmp(tag, "year") && f.tag()->year()) _snprintfSafe(tagval, tagval_sz, "%u", f.tag()->year());
else if (!_stricmp(tag, "track") && f.tag()->track()) _snprintfSafe(tagval, tagval_sz, "%u", f.tag()->track());
}
}
#ifdef _WIN32
delete [] w_fn;
#endif
return !!*tagval;
}
void TieFileToProject(const char* _fn, ReaProject* _prj, bool _tie)
{
if (_fn && *_fn)
{
if (ReaProject* prj = _prj ? _prj : EnumProjects(-1, NULL, 0))
{
void *p[2] = { (void*)_fn, (void*)prj };
plugin_register(_tie ? "file_in_project_ex" : "-file_in_project_ex", p);
#ifdef _SNM_DEBUG
char dbg[256]="";
_snprintfSafe(dbg, sizeof(dbg), "TieFileToProject() - ReaProject: %p, %s %s\n", prj, _tie ? "Added" : "Removed", _fn);
OutputDebugString(dbg);
#endif
}
}
}
void SetTrackHeight(MediaTrack* track, int height, bool useChunk)
{
if (!useChunk)
{
GetSetMediaTrackInfo(track, "I_HEIGHTOVERRIDE", &height);
PreventUIRefresh(1);
Main_OnCommand(41327, 0);
Main_OnCommand(41328, 0);
PreventUIRefresh(-1);
}
else
{
SNM_ChunkParserPatcher p(track);
char pTrackLine[BUFFER_SIZE] = "";
if (p.Parse(SNM_GET_CHUNK_CHAR, 1, "TRACK", "TRACKHEIGHT", 0, 1, pTrackLine))
{
_snprintfSafe(pTrackLine, BUFFER_SIZE, "%d", height);
p.ParsePatch(SNM_SET_CHUNK_CHAR, 1, "TRACK", "TRACKHEIGHT", 0, 1, pTrackLine);
}
}
}
/******************************************************************************
* Dialog functionality *
******************************************************************************/
static void SetVersionMessage (HWND hwnd, BR_SearchObject* searchObject)
{
BR_Version versionO, versionB;
int status = searchObject->GetStatus(&versionO, &versionB);
char tmp[256] = {0};
if (status == SEARCH_INITIATED)
{
EnableWindow(GetDlgItem(hwnd, IDC_BR_VER_DOWNLOAD), false);
ShowWindow(GetDlgItem(hwnd, IDC_BR_VER_DOWNLOAD), SW_SHOW);
ShowWindow(GetDlgItem(hwnd, IDC_BR_VER_OFF), SW_HIDE);
ShowWindow(GetDlgItem(hwnd, IDC_BR_VER_BETA), SW_HIDE);
ShowWindow(GetDlgItem(hwnd, IDC_BR_VER_PROGRESS), SW_SHOW);
SendMessage(GetDlgItem(hwnd, IDC_BR_VER_PROGRESS), PBM_SETPOS, 0, 0);
}
else if (status == NO_CONNECTION)
{
_snprintfSafe(tmp, sizeof(tmp), __LOCALIZE("Connection could not be established","sws_DLG_172"));
SetWindowText(GetDlgItem(hwnd, IDC_BR_VER_DOWNLOAD), __LOCALIZE("Retry","sws_DLG_172"));
EnableWindow(GetDlgItem(hwnd, IDC_BR_VER_DOWNLOAD), true);
ShowWindow(GetDlgItem(hwnd, IDC_BR_VER_DOWNLOAD), SW_SHOW);
ShowWindow(GetDlgItem(hwnd, IDC_BR_VER_OFF), SW_HIDE);
ShowWindow(GetDlgItem(hwnd, IDC_BR_VER_BETA), SW_HIDE);
ShowWindow(GetDlgItem(hwnd, IDC_BR_VER_PROGRESS), SW_HIDE);
}
else if (status == UP_TO_DATE)
{
_snprintfSafe(tmp, sizeof(tmp), __LOCALIZE("SWS extension is up to date.","sws_DLG_172"));
EnableWindow(GetDlgItem(hwnd, IDC_BR_VER_DOWNLOAD), false);
ShowWindow(GetDlgItem(hwnd, IDC_BR_VER_DOWNLOAD), SW_SHOW);
ShowWindow(GetDlgItem(hwnd, IDC_BR_VER_OFF), SW_HIDE);
ShowWindow(GetDlgItem(hwnd, IDC_BR_VER_BETA), SW_HIDE);
ShowWindow(GetDlgItem(hwnd, IDC_BR_VER_PROGRESS), SW_HIDE);
}
else if (status == OFFICIAL_AVAILABLE)
{
_snprintfSafe(tmp, sizeof(tmp), __LOCALIZE("Official update is available: Version %d.%d.%d Build #%d","sws_DLG_172"), versionO.maj, versionO.min, versionO.rev, versionO.build);
EnableWindow(GetDlgItem(hwnd, IDC_BR_VER_DOWNLOAD), true);
ShowWindow(GetDlgItem(hwnd, IDC_BR_VER_DOWNLOAD), SW_SHOW);
ShowWindow(GetDlgItem(hwnd, IDC_BR_VER_OFF), SW_HIDE);
ShowWindow(GetDlgItem(hwnd, IDC_BR_VER_BETA), SW_HIDE);
ShowWindow(GetDlgItem(hwnd, IDC_BR_VER_PROGRESS), SW_HIDE);
}
else if (status == BETA_AVAILABLE)
{
_snprintfSafe(tmp, sizeof(tmp), __LOCALIZE("Beta update is available: Version %d.%d.%d Build #%d","sws_DLG_172"), versionB.maj, versionB.min, versionB.rev, versionB.build);
EnableWindow(GetDlgItem(hwnd, IDC_BR_VER_DOWNLOAD), true);
ShowWindow(GetDlgItem(hwnd, IDC_BR_VER_DOWNLOAD), SW_SHOW);
ShowWindow(GetDlgItem(hwnd, IDC_BR_VER_OFF), SW_HIDE);
ShowWindow(GetDlgItem(hwnd, IDC_BR_VER_BETA), SW_HIDE);
ShowWindow(GetDlgItem(hwnd, IDC_BR_VER_PROGRESS), SW_HIDE);
}
else if (status == BOTH_AVAILABLE)
{
_snprintfSafe(tmp, sizeof(tmp), __LOCALIZE("Official update is available: Version %d.%d.%d Build #%d\nBeta update is available: Version %d.%d.%d Build #%d","sws_DLG_172"), versionO.maj, versionO.min, versionO.rev, versionO.build, versionB.maj, versionB.min, versionB.rev, versionB.build);
ShowWindow(GetDlgItem(hwnd, IDC_BR_VER_OFF), SW_SHOW);
ShowWindow(GetDlgItem(hwnd, IDC_BR_VER_BETA), SW_SHOW);
ShowWindow(GetDlgItem(hwnd, IDC_BR_VER_DOWNLOAD), SW_HIDE);
ShowWindow(GetDlgItem(hwnd, IDC_BR_VER_PROGRESS), SW_HIDE);
}
SetWindowText(GetDlgItem(hwnd, IDC_BR_VER_MESSAGE), tmp);
}
void DeleteTempo (COMMAND_T* ct)
{
// Get tempo map
BR_Envelope tempoMap(GetTempoEnv());
if (!tempoMap.CountSelected())
return;
int offset = 0;
// Loop through selected points and perform BPM calculations
int skipped = 0;
for (int i = 0; i < tempoMap.CountSelected(); ++i)
{
int id = tempoMap.GetSelected(i) + offset;
if (id == 0)
continue;
// Get tempo points
double t1, t2, t3, t4;
double b1, b2, b3, b4;
int s0, s1, s2, s3;
tempoMap.GetPoint(id, &t2, &b2, &s2, NULL);
bool P0 = tempoMap.GetPoint(id-2, NULL, NULL, &s0, NULL);
bool P1 = tempoMap.GetPoint(id-1, &t1, &b1, &s1, NULL);
bool P3 = tempoMap.GetPoint(id+1, &t3, &b3, &s3, NULL);
bool P4 = tempoMap.GetPoint(id+2, &t4, &b4, NULL, NULL);
// Hold new values
double Nt1, Nb1;
double Nt3, Nb3;
// If previous point doesn't exist, fake it
if (!P0)
s0 = SQUARE;
// Get P2-P3 length
double m2;
if (s2 == SQUARE)
m2 = b2*(t3-t2) / 240;
else
m2 = (b2+b3)*(t3-t2) / 480;
///// CALCULATE BPM VALUES /////
////////////////////////////////
if (P3)
{
if (s0 == SQUARE)
{
if (s1 == SQUARE)
{
Nt1 = t1;
Nb1 = (240*m2 + b1*(t2-t1)) / (t3-t1);
}
else
{
Nt1 = t1;
Nb1 = (480*m2 + (b1+b2)*(t2-t1)) / (t3-t1) - b3;
}
// Check new value is legal
if (Nb1 > MAX_BPM || Nb1 < MIN_BPM)
SKIP(skipped, 1);
// Next point stays the same
P3 = false;
}
else
{
// If P4 exists...
if (P4)
{
if (s1 == SQUARE)
{
if (s3 == SQUARE)
{
Nt3 = t2 + 240*m2 / b1;
Nb3 = b3*(t4-t3) / (t4-Nt3);
}
else
{
Nt3 = t2 + 240*m2 / b1;
Nb3 = (b3+b4)*(t4-t3) / (t4-Nt3) - b4;
}
}
else
{
if (s3 == SQUARE)
{
double f1 = (b1+b2)*(t2-t1) + 480*m2;
double f2 = b3*(t4-t3);
double a = b1;
double b = (a*(t1+t4) + f1+f2) / 2;
double c = a*(t1*t4) + f1*t4 + f2*t1;
Nt3 = c / (b + sqrt(pow(b,2) - a*c));
Nb3 = f2 / (t4 - Nt3);
}
else
{
double f1 = (b1+b2)*(t2-t1) + 480*m2;
double f2 = (b3+b4)*(t4-t3);
double a = b1-b4;
double b = (a*(t1+t4) + f1+f2) / 2;
double c = a*(t1*t4) + f1*t4 + f2*t1;
Nt3 = c / (b + sqrt(pow(b,2) - a*c));
Nb3 = f2 / (t4 - Nt3) - b4;
}
}
// Check new position is legal
if ((Nt3 - t1) < MIN_TEMPO_DIST || (t4 - Nt3) < MIN_TEMPO_DIST)
SKIP(skipped, 1);
}
// If P4 does not exist
else
{
if (s1 == SQUARE)
{
Nt3 = t2 + 240*m2 / b1;
Nb3 = b3;
}
else
{
Nt3 = t3;
Nb3 = (480*m2 + (b1+b2)*(t2-t1)) / (t3-t1) - b1;
}
// Check new position is legal
if ((Nt3 - t1) < MIN_TEMPO_DIST)
SKIP(skipped, 1);
}
// Check new value is legal
if (Nb3 > MAX_BPM || Nb3 < MIN_BPM)
SKIP(skipped, 1);
// Previous point stays the same
P1 = false;
}
}
else
{
// No surrounding points get edited
P1 = false;
P3 = false;
}
///// SET NEW BPM /////
///////////////////////
// Previous point
if (P1)
tempoMap.SetPoint(id-1, &Nt1, &Nb1, NULL, NULL);
// Next point
if (P3)
tempoMap.SetPoint(id+1, &Nt3, &Nb3, NULL, NULL);
// Delete point
tempoMap.DeletePoint(id);
--offset;
}
// Commit changes
if (tempoMap.Commit())
Undo_OnStateChangeEx2(NULL, SWS_CMD_SHORTNAME(ct), UNDO_STATE_ALL, -1);
// Warn user if some points weren't processed
static bool s_warnUser = true;
if (s_warnUser && skipped != 0)
{
char buffer[512];
_snprintfSafe(buffer, sizeof(buffer), __LOCALIZE_VERFMT("%d of the selected points didn't get processed because some points would end up with illegal BPM or position. Would you like to be warned if it happens again?", "sws_mbox"), skipped);
int userAnswer = ShowMessageBox(buffer, __LOCALIZE("SWS - Warning", "sws_mbox"), 4);
if (userAnswer == 7)
s_warnUser = false;
}
}
void SNM_DynSizedText::OnPaint(LICE_IBitmap *drawbm, int origin_x, int origin_y, RECT *cliprect)
{
RECT r = m_position;
r.left += origin_x;
r.right += origin_x;
r.top += origin_y;
r.bottom += origin_y;
int h = r.bottom-r.top;
int w = r.right-r.left;
ColorTheme* ct = SNM_GetColorTheme();
int col = m_col;
if (!col)
col = ct ? LICE_RGBA_FROMNATIVE(ct->main_text, m_alpha) : LICE_RGBA(255,255,255,255);
if (m_wantBorder)
LICE_DrawRect(drawbm,r.left,r.top,w,h,col,0.2f);
// title lane
int laneHeight = GetTitleLaneHeight();
if (WantTitleLane() && HasTitleLane())
{
if (m_wantBorder)
LICE_Line(drawbm, r.left,r.top+laneHeight-1,r.right,r.top+laneHeight-1,col,0.2f);
// title's band coloring (works for all themes)
LICE_FillRect(drawbm,r.left,r.top,r.right-r.left,laneHeight,col,1.0f,LICE_BLIT_MODE_OVERLAY);
LICE_FillRect(drawbm,r.left,r.top,r.right-r.left,laneHeight,col,1.0f,LICE_BLIT_MODE_OVERLAY);
static LICE_CachedFont sFont;
if (!sFont.GetHFont()) // single lazy init..
{
LOGFONT lf = {
SNM_FONT_HEIGHT, 0,0,0,FW_BOLD,FALSE,FALSE,FALSE,DEFAULT_CHARSET,
OUT_DEFAULT_PRECIS,CLIP_DEFAULT_PRECIS,DEFAULT_QUALITY,DEFAULT_PITCH,SNM_FONT_NAME
};
sFont.SetFromHFont(CreateFontIndirect(&lf),LICE_FONT_FLAG_OWNS_HFONT|LICE_FONT_FLAG_FORCE_NATIVE);
// others props are set on demand (support theme switches)
}
sFont.SetBkMode(TRANSPARENT);
sFont.SetTextColor(LICE_RGBA_FROMNATIVE(WDL_STYLE_GetSysColor(COLOR_WINDOW), 255)); // "negative" color
{
RECT tr = {r.left,r.top,r.right,r.top+laneHeight};
char buf[64] = "";
_snprintfSafe(buf, sizeof(buf), " %s ", m_title.Get()); // trick for better display when left/right align
sFont.DrawText(drawbm, buf, -1, &tr, DT_SINGLELINE|DT_NOPREFIX|DT_VCENTER|m_titleAlign);
}
// resize draw rect: take band into account
r.top += laneHeight;
h = r.bottom-r.top;
}
// ok, now the meat: render lines with a dynamic sized text
if (!m_lines.GetSize() || !m_lines.Get(m_maxLineIdx))
return;
///////////////////////////////////////////////////////////////////////////////
#ifndef _SNM_MISC // 1st sol.: full width but several fonts can be tried
// initial font height estimation
// touchy: the better estimation, the less cpu use!
int estimFontH = int((w*2.65)/m_lines.Get(m_maxLineIdx)->GetLength()); // 2.65 = average from tests..
if (estimFontH > int(h/m_lines.GetSize())+0.5)
estimFontH = int(h/m_lines.GetSize()+0.5);
// check if the current font can do the job
if (m_lastFontH>=SNM_FONT_HEIGHT && abs(estimFontH-m_lastFontH) < 2) // tolerance: 2 pixels
{
#ifdef _SNM_DYN_FONT_DEBUG
OutputDebugString("SNM_DynSizedText::OnPaint() - Skip font creation\n");
#endif
m_font.SetTextColor(col);
DrawLines(drawbm, &r, m_lastFontH);
}
else
{
m_lastFontH = estimFontH;
#ifdef _SNM_DYN_FONT_DEBUG
int dbgTries=0;
#endif
while(m_lastFontH>SNM_FONT_HEIGHT)
{
HFONT lf = CreateFont(m_lastFontH,0,0,0,FW_NORMAL,FALSE,FALSE,FALSE,DEFAULT_CHARSET,
OUT_DEFAULT_PRECIS,CLIP_DEFAULT_PRECIS,DEFAULT_QUALITY,DEFAULT_PITCH,m_fontName.Get());
m_font.SetFromHFont(lf, LICE_FONT_FLAG_OWNS_HFONT|LICE_FONT_FLAG_FORCE_NATIVE);
m_font.SetBkMode(TRANSPARENT);
m_font.SetTextColor(col);
RECT tr = {0,0,0,0};
// DT flags must be consistent with DrawLines()
m_font.DrawText(NULL, m_lines.Get(m_maxLineIdx)->Get(), -1, &tr, DT_SINGLELINE|DT_BOTTOM|DT_NOPREFIX|DT_CALCRECT);
if ((tr.right - tr.left) > (w-int(w*0.02+0.5))) // room: 2% of w
{
m_font.SetFromHFont(NULL,LICE_FONT_FLAG_OWNS_HFONT);
DeleteObject(lf);
m_lastFontH--;
#ifdef _SNM_DYN_FONT_DEBUG
dbgTries++;
#endif
}
else
{
DrawLines(drawbm, &r, m_lastFontH);
// no font deletion: will try to re-use it..
break;
}
}
#ifdef _SNM_DYN_FONT_DEBUG
char dbg[256];
_snprintfSafe(dbg, sizeof(dbg), "SNM_DynSizedText::OnPaint() - %d tries, estim: %d, real: %d\n", dbgTries, estimFontH, m_lastFontH);
OutputDebugString(dbg);
#endif
}
///////////////////////////////////////////////////////////////////////////////
#else // 2nd sol.: render text in best effort, single font creation
/*JFB commented: truncated text..
int fontHeight = int((w*2.65)/m_lines.Get(m_maxLineIdx)->GetLength()); // 2.65 = average from tests..
if (fontHeight > int(h/m_lines.GetSize())+0.5)
fontHeight = int(h/m_lines.GetSize()+0.5);
*/
// font height estimation (safe but it does not use all the available width/height)
int fontHeight = int(h/m_lines.GetSize() + 0.5);
while (fontHeight>SNM_FONT_HEIGHT && (fontHeight*m_lines.Get(m_maxLineIdx)->GetLength()*0.55) > w) // 0.55: h/w factor
fontHeight--;
if (fontHeight>=SNM_FONT_HEIGHT)
{
HFONT lf = CreateFont(fontHeight,0,0,0,FW_NORMAL,FALSE,FALSE,FALSE,DEFAULT_CHARSET,
OUT_DEFAULT_PRECIS,CLIP_DEFAULT_PRECIS,DEFAULT_QUALITY,DEFAULT_PITCH,m_fontName.Get());
m_font.SetFromHFont(lf, LICE_FONT_FLAG_OWNS_HFONT|LICE_FONT_FLAG_FORCE_NATIVE);
m_font.SetBkMode(TRANSPARENT);
m_font.SetTextColor(col);
DrawLines(drawbm, &r, fontHeight);
m_font.SetFromHFont(NULL,LICE_FONT_FLAG_OWNS_HFONT);
DeleteObject(lf);
}
#endif
}
void EditTempoGradual (COMMAND_T* ct)
{
// Get tempo map
BR_Envelope tempoMap(GetTempoEnv());
if (!tempoMap.CountSelected())
return;
// Get values and type of operation to be performed
bool percentage = false;
double diff;
if (GetFirstDigit((int)ct->user) == 1)
diff = (double)ct->user / 1000;
else
{
diff = (double)ct->user / 200000;
percentage = true;
}
// Loop through selected points and perform BPM calculations
int skipped = 0;
for (int i = 0; i < tempoMap.CountSelected(); ++i)
{
int id = tempoMap.GetSelected(i);
// Hold new values for selected and next point
double Nb1, Nt1;
vector<double> selPos;
vector<double> selBpm;
///// CURRENT POINT /////
/////////////////////////
// Store new values for selected points into vectors
int offset = 0;
while (true)
{
// Get point currently in the loop and points surrounding it
double t0, t1, t2, b0, b1, b2;
int s0, s1;
bool P0 = tempoMap.GetPoint(id+offset-1, &t0, &b0, &s0, NULL);
tempoMap.GetPoint(id+offset, &t1, &b1, &s1, NULL);
tempoMap.GetPoint(id+offset+1, &t2, &b2, NULL, NULL);
// If square or not selected, break
if (s1 == SQUARE || !tempoMap.GetSelection(id+offset))
{
// If breaking on the first selected point, don't adjust i (so for loop doesn't go backwards).
i += (offset == 0) ? (0) : (offset-1);
--offset; // since this point is not taken into account, correct offset
break;
}
// Get new BPM
double bpm = b1 + ((percentage) ? (b1*diff) : (diff));
if (bpm < MIN_BPM)
bpm = MIN_BPM;
else if (bpm > MAX_BPM)
bpm = MAX_BPM;
// Get new position (special case for the first point)
double position;
if (offset == 0)
{
if (P0 && s0 == LINEAR)
{
position = (t1*(b0+b1) + t0*(bpm-b1)) / (b0 + bpm); // first point moves but the one before it
if (position - t0 < MIN_TEMPO_DIST) // doesn't so check if their distance is legal
break;
}
else
position = t1;
}
else
position = ((b0+b1)*(t1-t0) + selPos.back() * (selBpm.back() + bpm)) / (selBpm.back() + bpm);
// Store new values
selPos.push_back(position);
selBpm.push_back(bpm);
++offset;
}
// Check for illegal position/no linear points encountered (in that case offset is -1 so skipped won't change)
if (!selPos.size())
SKIP(skipped, offset+1);
///// NEXT POINT /////
//////////////////////
// Get points after the last selected point
double t1, t2;
double b1, b2;
int s2;
bool P1 = tempoMap.GetPoint(id+offset+1, &t1, &b1, &s2, NULL);
bool P2 = tempoMap.GetPoint(id+offset+2, &t2, &b2, NULL, NULL);
// Calculate new value and position for the next point
if (P1)
{
// Get last selected tempo point (old and new)
double Nb0 = selBpm.back();
double Nt0 = selPos.back();
double t0, b0;
tempoMap.GetPoint(id+offset, &t0, &b0, NULL, NULL);
if (P2)
{
if (s2 == SQUARE)
{
double f1 = (b0+b1)*(t1-t0);
double f2 = b1*(t2-t1);
double a = Nb0;
double b = (a*(Nt0+t2) + f1+f2) / 2;
double c = a*(Nt0*t2) + f1*t2 + f2*Nt0;
Nt1 = c / (b + sqrt(pow(b,2) - a*c));
Nb1 = f2 / (t2-Nt1);
}
else
{
double f1 = (b0+b1)*(t1-t0);
double f2 = (b1+b2)*(t2-t1);
double a = Nb0 - b2;
double b = (a*(Nt0+t2) + f1+f2) / 2;
double c = a*(Nt0*t2) + f1*t2 + f2*Nt0;
Nt1 = c / (b + sqrt(pow(b,2) - a*c));
Nb1 = f2 / (t2-Nt1) - b2;
}
}
else
{
Nt1 = t1;
Nb1 = (b0+b1)*(t1-t0) / (t1-Nt0) - Nb0;
}
// If points after selected point don't exist, fake them
if (!P1)
Nt1 = Nt0 + 1;
if (!P2)
t2 = Nt1 + 1;
// Check new value is legal
if (Nb1 > MAX_BPM || Nb1 < MIN_BPM)
SKIP(skipped, offset+1);
if ((Nt1-Nt0) < MIN_TEMPO_DIST || (t2 - Nt1) < MIN_TEMPO_DIST)
SKIP(skipped, offset+1);
}
///// SET NEW BPM /////
///////////////////////
// Current point(s)
for (int i = 0; i < (int)selPos.size(); ++i)
tempoMap.SetPoint(id+i, &selPos[i], &selBpm[i], NULL, NULL);
// Next point
if (P1)
tempoMap.SetPoint(id+offset+1, &Nt1, &Nb1, NULL, NULL);
}
// Commit changes
if (tempoMap.Commit())
Undo_OnStateChangeEx2(NULL, SWS_CMD_SHORTNAME(ct), UNDO_STATE_ALL, -1);
// Warn user if some points weren't processed
static bool s_warnUser = true;
if (s_warnUser && skipped != 0 && tempoMap.CountSelected() > 1 )
{
char buffer[512];
_snprintfSafe(buffer, sizeof(buffer), __LOCALIZE_VERFMT("%d of the selected points didn't get processed because some points would end up with illegal BPM or position. Would you like to be warned if it happens again?", "sws_mbox"), skipped);
int userAnswer = ShowMessageBox(buffer, __LOCALIZE("SWS - Warning", "sws_mbox"), 4);
if (userAnswer == 7)
s_warnUser = false;
}
}
void EditTempo (COMMAND_T* ct)
{
// Get tempo map
BR_Envelope tempoMap(GetTempoEnv());
if (!tempoMap.CountSelected())
return;
// Get values and type of operation to be performed
bool percentage = false;
double diff;
if (GetFirstDigit((int)ct->user) == 1)
diff = (double)ct->user / 1000;
else
{
diff = (double)ct->user / 200000;
percentage = true;
}
// Loop through selected points and perform BPM calculations
int skipped = 0;
for (int i = 0; i < tempoMap.CountSelected(); ++i)
{
int id = tempoMap.GetSelected(i);
// Hold new values for selected and surrounding points
double Nt1, Nt3, Nb1, Nb3;
vector<double> selPos;
vector<double> selBpm;
///// CURRENT POINT /////
/////////////////////////
// Get all consequentially selected points into a vector with their new values. In case
// there is consequential selection, middle musical position of a transition between first
// and last selected point will preserve it's time position (where possible)
int offset = 0;
if (tempoMap.GetSelection(id+1))
{
// Store new values for selected points into vectors
double musicalMiddle = 0;
vector<double> musicalLength;
while (true)
{
// Once unselected point is encountered, break
if (!tempoMap.GetSelection(id+offset))
{
--offset; // since this point is not taken into account, correct offset
i += offset; // in case of consequential selection, points are treated as
break; // one big transition, so skip them all
}
// Get point currently in the loop and surrounding points
double t0, t1, t2, b0, b1, b2;
int s0, s1;
bool P0 = tempoMap.GetPoint(id+offset-1, &t0, &b0, &s0, NULL);
tempoMap.GetPoint(id+offset, &t1, &b1, &s1, NULL);
tempoMap.GetPoint(id+offset+1, &t2, &b2, NULL, NULL);
// Get musical length for every transition but the last
double mLen = 0;
if (tempoMap.GetSelection(id+offset+1))
{
if (s1 == SQUARE)
mLen = b1*(t2-t1) / 240;
else
mLen = (b1+b2)*(t2-t1) / 480;
}
musicalMiddle += mLen;
// Get new BPM
double bpm = b1 + (percentage ? (b1*diff) : (diff));
if (bpm < MIN_BPM)
bpm = MIN_BPM;
else if (bpm > MAX_BPM)
bpm = MAX_BPM;
// Get new position (special case for the first point)
double position;
if (!offset)
{
if (P0 && s0 == LINEAR)
position = (t1*(b0+b1) + t0*(bpm-b1)) / (b0 + bpm);
else
position = t1;
}
else
{
if (s0 == LINEAR)
position = (480*musicalLength.back() + selPos.back()*(bpm + selBpm.back())) / (bpm + selBpm.back());
else
position = (240*musicalLength.back() + selPos.back()*selBpm.back()) / selBpm.back();
}
// Store new values
selPos.push_back(position);
selBpm.push_back(bpm);
musicalLength.push_back(mLen);
++offset;
}
// Find time position of musical middle and move all point so time position
// of musical middle is preserved (only if previous point exists)
musicalMiddle /= 2;
if (tempoMap.GetPoint(id-1, NULL, NULL, NULL, NULL))
{
double temp = 0;
for (int i = 0; i < (int)selPos.size()-1; ++i)
{
temp += musicalLength[i];
if (temp >= musicalMiddle)
{
// Get length between the points that contain musical middle
double len = musicalMiddle - (temp-musicalLength[i]);
// Find original time position of musical middle
double t0, t1, b0, b1; int s0;
tempoMap.GetPoint(id+i, &t0, &b0, &s0, NULL);
tempoMap.GetPoint(id+i+1, &t1, &b1, NULL, NULL);
double prevPos = t0 + PositionAtMeasure (b0, (s0 == 1 ? b0 : b1), t1-t0, len);
// Find new time position of musical middle
double newPos = t0 + PositionAtMeasure (selBpm[i], (s0 == 1 ? selBpm[i] : selBpm[i+1]), selPos[i+1] - selPos[i], len);
// Reset time positions of selected points
double diff = newPos - prevPos;
for (size_t i = 0; i < selPos.size(); ++i)
selPos[i] -= diff;
break;
}
}
}
}
else
{
// Get selected point
double t, b;
tempoMap.GetPoint(id, &t, &b, NULL, NULL);
// Get new BPM
b += (percentage) ? (b*diff) : (diff);
if (b < MIN_BPM)
b = MIN_BPM;
else if (b > MAX_BPM)
b = MAX_BPM;
// Store it
selPos.push_back(t);
selBpm.push_back(b);
}
///// PREVIOUS POINT /////
//////////////////////////
// Get points before selected points
double t0, t1, b0, b1;
int s0, s1;
bool P0 = tempoMap.GetPoint(id-2, &t0, &b0, &s0, NULL);
bool P1 = tempoMap.GetPoint(id-1, &t1, &b1, &s1, NULL);
if (P1)
{
// Get first selected point (old and new)
double t2, b2;
tempoMap.GetPoint(id, &t2, &b2, NULL, NULL);
double Nb2 = selBpm.front();
double Nt2 = selPos.front();
// If point behind previous doesn't exist, fake it as square
if (!P0)
s0 = SQUARE;
// Calculate new value and position for previous point
if (!P0 || s0 == SQUARE)
{
if (s1 == SQUARE)
{
Nt1 = t1;
Nb1 = b1*(t2-t1) / (Nt2-Nt1);
}
else
{
Nt1 = t1;
Nb1 = (b1+b2)*(t2-t1) / (Nt2-Nt1) - Nb2;
}
}
else
{
if (s1 == SQUARE)
{
double f1 = (b0+b1) *(t1-t0);
double f2 = b1*(t2-t1);
double a = b0;
double b = (a*(t0+Nt2) + f1+f2) / 2;
double c = a*(t0*Nt2) + f1*Nt2 + f2*t0;
Nt1 = c / (b + sqrt(pow(b,2) - a*c));
Nb1 = f2 / (Nt2 - Nt1);
}
else
{
double f1 = (b0+b1)*(t1-t0);
double f2 = (b1+b2)*(t2-t1);
double a = b0 - Nb2;
double b = (a*(t0+Nt2) + f1+f2) / 2;
double c = a*(t0*Nt2) + f1*Nt2 + f2*t0;
Nt1 = c / (b + sqrt(pow(b,2) - a*c));
Nb1 = f2 / (Nt2 - Nt1) - Nb2;
}
}
// If point behind previous doesn't exist, fake it's position so it can pass legality check
if (!P0)
t0 = Nt1 - 1;
// Check new value is legal
if (Nb1 > MAX_BPM || Nb1 < MIN_BPM)
SKIP(skipped, offset+1);
if ((Nt1-t0) < MIN_TEMPO_DIST || (Nt2 - Nt1) < MIN_TEMPO_DIST)
SKIP(skipped, offset+1 );
}
///// NEXT POINT /////
//////////////////////
// Get points after selected points
double t3, t4, b3, b4;
int s3;
bool P3 = tempoMap.GetPoint(id+offset+1, &t3, &b3, &s3, NULL);
bool P4 = tempoMap.GetPoint(id+offset+2, &t4, &b4, NULL, NULL);
if (P3)
{
// Get last selected point (old and new)
double t2, b2; int s2;
tempoMap.GetPoint(id+offset, &t2, &b2, &s2, NULL);
double Nb2 = selBpm.back();
double Nt2 = selPos.back();
// Calculate new value and position for next point
if (s2 == SQUARE)
{
if (P4)
{
if (s3 == SQUARE)
{
Nt3 = (b2*(t3-t2) + Nb2*Nt2) / Nb2;
Nb3 = b3*(t4-t3) / (t4-Nt3);
}
else
{
Nt3 = (b2*(t3-t2) + Nb2*Nt2) / Nb2;
Nb3 = (b3+b4)*(t4-t3) / (t4-Nt3) - b4;
}
}
else
{
Nt3 = (b2*(t3-t2) + Nb2*Nt2) / Nb2;
Nb3 = b3;
}
}
else
{
if (P4)
{
if (s3 == SQUARE)
{
double f1 = (b2+b3)*(t3-t2);
double f2 = b3*(t4-t3);
double a = Nb2;
double b = (a*(Nt2+t4) + f1+f2) / 2;
double c = a*(Nt2*t4) + f1*t4 + f2*Nt2;
Nt3 = c / (b + sqrt(pow(b,2) - a*c));
Nb3 = f2 / (t4-Nt3);
}
else
{
double f1 = (b2+b3)*(t3-t2);
double f2 = (b3+b4)*(t4-t3);
double a = Nb2 - b4;
double b = (a*(Nt2+t4) + f1+f2) / 2;
double c = a*(Nt2*t4) + f1*t4 + f2*Nt2;
Nt3 = c / (b + sqrt(pow(b,2) - a*c));
Nb3 = f2 / (t4-Nt3) - b4;
}
}
else
{
Nt3 = t3;
Nb3 = (b2+b3)*(t3-t2) / (Nt3-Nt2) - Nb2;
}
}
// If point after the next doesn't exist fake it's position so it can pass legality check
if (!P4)
t4 = Nt3 + 1;
// Check new value is legal
if (Nb3 > MAX_BPM || Nb3 < MIN_BPM)
SKIP(skipped, offset+1);
if ((Nt3-Nt2) < MIN_TEMPO_DIST || (t4 - Nt3) < MIN_TEMPO_DIST)
SKIP(skipped, offset+1);
}
///// SET BPM /////
///////////////////
// Previous point
if (P1)
tempoMap.SetPoint(id-1, &Nt1, &Nb1, NULL, NULL);
// Current point(s)
for (int i = 0; i < (int)selPos.size(); ++i)
tempoMap.SetPoint(id+i, &selPos[i], &selBpm[i], NULL, NULL);
// Next point
if (P3)
tempoMap.SetPoint(id+offset+1, &Nt3, &Nb3, NULL, NULL);
}
// Commit changes
if (tempoMap.Commit())
Undo_OnStateChangeEx2(NULL, SWS_CMD_SHORTNAME(ct), UNDO_STATE_ALL, -1);
// Warn user if some points weren't processed
static bool s_warnUser = true;
if (s_warnUser && skipped != 0 && tempoMap.CountSelected() > 1)
{
char buffer[512];
_snprintfSafe(buffer, sizeof(buffer), __LOCALIZE_VERFMT("%d of the selected points didn't get processed because some points would end up with illegal BPM or position. Would you like to be warned if it happens again?", "sws_mbox"), skipped);
int userAnswer = ShowMessageBox(buffer, __LOCALIZE("SWS - Warning", "sws_mbox"), 4);
if (userAnswer == 7)
s_warnUser = false;
}
}
void MoveTempo (COMMAND_T* ct)
{
BR_Envelope tempoMap(GetTempoEnv());
if (!tempoMap.Count())
return;
double cursor = GetCursorPositionEx(NULL);
double tDiff = 0;
int targetId = -1;
// Find tempo marker closest to the edit cursor
if ((int)ct->user == 3)
{
targetId = tempoMap.FindClosest(cursor);
if (targetId == 0) ++targetId;
if (!tempoMap.ValidateId(targetId))
return;
double cTime; tempoMap.GetPoint(targetId, &cTime, NULL, NULL, NULL);
tDiff = cursor - cTime;
}
// Just get time difference for selected points
else
{
if ((int)ct->user == 2 || (int)ct->user == -2)
tDiff = 1 / GetHZoomLevel() * (double)ct->user / 2;
else
tDiff = (double)ct->user/10000;
}
if (tDiff == 0)
return;
// Loop through selected points
int skipped = 0;
int count = (targetId != -1) ? (1) : (tempoMap.CountSelected());
for (int i = 0; i < count; ++i)
{
if (int id = ((int)ct->user == 3) ? (targetId) : (tempoMap.GetSelected(i))) // skip first point
skipped += (MoveTempo(tempoMap, id, tDiff)) ? (0) : (1);
}
// Commit changes
PreventUIRefresh(1); // prevent jumpy cursor
if (tempoMap.Commit())
{
if ((int)ct->user == 3)
SetEditCurPos2(NULL, cursor, false, false); // always keep cursor position when moving to closest tempo marker
Undo_OnStateChangeEx2(NULL, SWS_CMD_SHORTNAME(ct), UNDO_STATE_ALL, -1);
}
PreventUIRefresh(-1);
// Warn user if some points weren't processed
static bool s_warnUser = true;
if (s_warnUser && skipped != 0)
{
char buffer[512];
_snprintfSafe(buffer, sizeof(buffer), __LOCALIZE_VERFMT("%d of the selected points didn't get processed because some points would end up with illegal BPM or position. Would you like to be warned if it happens again?", "sws_mbox"), skipped);
int userAnswer = ShowMessageBox(buffer, __LOCALIZE("SWS - Warning", "sws_mbox"), 4);
if (userAnswer == 7)
s_warnUser = false;
}
}
void TempoShapeSquare (COMMAND_T* ct)
{
// Get tempo map
BR_Envelope tempoMap (GetTempoEnv());
if (!tempoMap.CountSelected())
return;
// Get splitting options
double splitRatio;
bool split = GetTempoShapeOptions(&splitRatio);
// Loop through selected points and perform BPM calculations
int skipped = 0;
int count = tempoMap.Count()-1;
for (int i = 0; i < tempoMap.CountSelected(); ++i)
{
int id = tempoMap.GetSelected(i);
// Skip selected point if already square
double t1, b1; int s1;
tempoMap.GetPoint(id, &t1, &b1, &s1, NULL);
if (s1 == SQUARE)
continue;
else
s1 = SQUARE;
// Get next point
double b2; bool P2;
if (id < count) // since we're creating points at the end of tempo map, check if dealing with the last point
P2 = tempoMap.GetPoint(id+1, NULL, &b2, NULL, NULL);
else
P2 = false;
// Get previous point
double t0, b0; int s0;
bool P0 = tempoMap.GetPoint(id-1, &t0, &b0, &s0, NULL);
// Get new bpm of selected point
double Nb1;
if (P2 && b1 != b2)
Nb1 = (b1+b2) / 2;
else
Nb1 = b1;
// Check if new bpm is legal, if not, skip
if (Nb1 < MIN_BPM || Nb1 > MAX_BPM)
SKIP(skipped, 1);
///// SET NEW SHAPE /////
/////////////////////////
// Create middle point(s) is needed
if (P0 && s0 == LINEAR && P2 && Nb1 != b2)
{
// Get middle point's position and BPM
double position, bpm = 120, measure = (b0+b1)*(t1-t0) / 480;
FindMiddlePoint(&position, &bpm, measure, t0, t1, b0, Nb1);
// Don't split middle point
if (!split)
{
if (bpm<= MAX_BPM && bpm>=MIN_BPM && (position-t0)>=MIN_TEMPO_DIST && (t1-position)>=MIN_TEMPO_DIST)
tempoMap.CreatePoint(tempoMap.Count(), position, bpm, LINEAR, 0, false);
else
SKIP(skipped, 1);
}
// Split middle point
else
{
double position1, position2, bpm1, bpm2;
SplitMiddlePoint (&position1, &position2, &bpm1, &bpm2, splitRatio, measure, t0, position, t1, b0, bpm, Nb1);
if (bpm1>=MIN_BPM && bpm1<=MAX_BPM && bpm2>=MIN_BPM && bpm2<=MAX_BPM && (position1-t0)>=MIN_TEMPO_DIST && (position2-position1)>=MIN_TEMPO_DIST && (t1-position2)>=MIN_TEMPO_DIST)
{
tempoMap.CreatePoint(tempoMap.Count(), position1, bpm1, LINEAR, 0, false);
tempoMap.CreatePoint(tempoMap.Count(), position2, bpm2, LINEAR, 0, false);
}
else
SKIP(skipped, 1);
}
}
// Change shape of the selected point
tempoMap.SetPoint(id, NULL, &Nb1, &s1, NULL);
}
// Commit changes
if (tempoMap.Commit())
Undo_OnStateChangeEx2(NULL, SWS_CMD_SHORTNAME(ct), UNDO_STATE_ALL, -1);
// Warn user if some points weren't processed
static bool s_warnUser = true;
if (s_warnUser && skipped != 0)
{
char buffer[512];
_snprintfSafe(buffer, sizeof(buffer), __LOCALIZE_VERFMT("%d of the selected points didn't get processed because some points would end up with illegal BPM or position. Would you like to be warned if it happens again?", "sws_mbox"), skipped);
int userAnswer = ShowMessageBox(buffer, __LOCALIZE("SWS - Warning", "sws_mbox"), 4);
if (userAnswer == 7)
s_warnUser = false;
}
}
// _type: 0=Post-Fader (Post-Pan), 1=Pre-FX, 2=deprecated, 3=Pre-Fader (Post-FX)
// _undoMsg: NULL=no undo
bool CueBuss(const char* _undoMsg, const char* _busName, int _type, bool _showRouting,
int _soloDefeat, char* _trTemplatePath, bool _sendToMaster, int* _hwOuts)
{
if (!SNM_CountSelectedTracks(NULL, false))
return false;
WDL_FastString tmplt;
if (_trTemplatePath && (!FileOrDirExists(_trTemplatePath) || !LoadChunk(_trTemplatePath, &tmplt) || !tmplt.GetLength()))
{
char msg[SNM_MAX_PATH] = "";
lstrcpyn(msg, __LOCALIZE("Cue buss not created!\nNo track template file defined","sws_DLG_149"), sizeof(msg));
if (*_trTemplatePath)
_snprintfSafe(msg, sizeof(msg), __LOCALIZE_VERFMT("Cue buss not created!\nTrack template not found (or empty): %s","sws_DLG_149"), _trTemplatePath);
MessageBox(GetMainHwnd(), msg, __LOCALIZE("S&M - Error","sws_DLG_149"), MB_OK);
return false;
}
bool updated = false;
MediaTrack * cueTr = NULL;
SNM_SendPatcher* p = NULL;
for (int i=1; i <= GetNumTracks(); i++) // skip master
{
MediaTrack* tr = CSurf_TrackFromID(i, false);
if (tr && *(int*)GetSetMediaTrackInfo(tr, "I_SELECTED", NULL))
{
GetSetMediaTrackInfo(tr, "I_SELECTED", &g_i0);
// add the buss track, done once!
if (!cueTr)
{
InsertTrackAtIndex(GetNumTracks(), false);
TrackList_AdjustWindows(false);
cueTr = CSurf_TrackFromID(GetNumTracks(), false);
GetSetMediaTrackInfo(cueTr, "P_NAME", (void*)_busName);
p = new SNM_SendPatcher(cueTr);
if (tmplt.GetLength())
{
WDL_FastString chunk;
MakeSingleTrackTemplateChunk(&tmplt, &chunk, true, true, false);
ApplyTrackTemplate(cueTr, &chunk, false, false, p);
}
updated = true;
}
// add a send
if (cueTr && p && tr != cueTr)
AddReceiveWithVolPan(tr, cueTr, _type, p);
}
}
if (cueTr && p)
{
// send to master/parent init
if (!tmplt.GetLength())
{
// solo defeat
if (_soloDefeat) {
char one[2] = "1";
updated |= (p->ParsePatch(SNM_SET_CHUNK_CHAR, 1, "TRACK", "MUTESOLO", 0, 3, one) > 0);
}
// master/parend send
WDL_FastString mainSend;
mainSend.SetFormatted(SNM_MAX_CHUNK_LINE_LENGTH, "MAINSEND %d 0", _sendToMaster?1:0);
// adds hw outputs
if (_hwOuts)
{
int monoHWCount=0;
while (GetOutputChannelName(monoHWCount)) monoHWCount++;
bool cr = false;
for(int i=0; i<SNM_MAX_HW_OUTS; i++)
{
if (_hwOuts[i])
{
if (!cr) {
mainSend.Append("\n");
cr = true;
}
if (_hwOuts[i] >= monoHWCount)
mainSend.AppendFormatted(32, "HWOUT %d ", (_hwOuts[i]-monoHWCount) | 1024);
else
mainSend.AppendFormatted(32, "HWOUT %d ", _hwOuts[i]-1);
mainSend.Append("0 ");
mainSend.AppendFormatted(20, "%.14f ", *(double*)GetConfigVar("defhwvol"));
mainSend.Append("0.00000000000000 0 0 0 -1.00000000000000 -1\n");
}
}
if (!cr)
mainSend.Append("\n"); // hot
}
// patch both updates (no break keyword here: new empty track)
updated |= p->ReplaceLine("TRACK", "MAINSEND", 1, 0, mainSend.Get());
}
p->Commit();
delete p;
if (updated)
{
GetSetMediaTrackInfo(cueTr, "I_SELECTED", &g_i1);
UpdateTimeline();
ScrollSelTrack(true, true);
if (_showRouting)
Main_OnCommand(40293, 0);
if (_undoMsg)
Undo_OnStateChangeEx2(NULL, _undoMsg, UNDO_STATE_ALL, -1);
}
}
return updated;
}
