static std::tm millisToUTC (int64 millis) noexcept
{
#if JUCE_WINDOWS && JUCE_MINGW
time_t now = (time_t) (millis / 1000);
return *gmtime (&now);
#elif JUCE_WINDOWS
std::tm result;
millis /= 1000;
if (_gmtime64_s (&result, &millis) != 0)
zerostruct (result);
return result;
#else
std::tm result;
time_t now = (time_t) (millis / 1000);
if (gmtime_r (&now, &result) == nullptr)
zerostruct (result);
return result;
#endif
}
ID3D11ShaderResourceView* D3D11Context::createShaderResourceView (ID3D11Texture2D* texture, DXGI_FORMAT srvFormat)
{
D3D11_TEXTURE2D_DESC texdesc;
texture->GetDesc (&texdesc);
D3D11_SHADER_RESOURCE_VIEW_DESC desc;
zerostruct (desc);
if (-1 == srvFormat)
desc.Format = texdesc.Format;
else
desc.Format = srvFormat;
if (1 == texdesc.ArraySize)
{
desc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2D;
desc.Texture2D.MipLevels = texdesc.MipLevels;
desc.Texture2D.MostDetailedMip = 0;
}
else
{
desc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2DARRAY;
desc.Texture2DArray.ArraySize = texdesc.ArraySize;
desc.Texture2DArray.FirstArraySlice = 0;
desc.Texture2DArray.MipLevels = texdesc.MipLevels;
desc.Texture2DArray.MostDetailedMip = 0;
}
Hold<ID3D11ShaderResourceView> srview;
if (m_failed (device->CreateShaderResourceView (texture, &desc, srview)))
return nullptr;
return srview.drop();
}
ID3D11DepthStencilView* D3D11Context::createDepthStencilView (ID3D11Texture2D* texture, size_t mipLevel, DXGI_FORMAT dsvFormat)
{
D3D11_TEXTURE2D_DESC texdesc;
texture->GetDesc (&texdesc);
D3D11_DEPTH_STENCIL_VIEW_DESC desc;
zerostruct (desc);
if (-1 == dsvFormat)
desc.Format = texdesc.Format;
else
desc.Format = dsvFormat;
if (1 == texdesc.ArraySize)
{
desc.ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2D;
desc.Texture2D.MipSlice = mipLevel;
}
else
{
desc.ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2DARRAY;
desc.Texture2DArray.ArraySize = texdesc.ArraySize;
desc.Texture2DArray.FirstArraySlice = 0;
desc.Texture2DArray.MipSlice = mipLevel;
}
Hold<ID3D11DepthStencilView> dsview;
if (m_failed (device->CreateDepthStencilView (texture, &desc, dsview)))
return nullptr;
return dsview.drop();
}
ID3D11RenderTargetView* D3D11Context::createRenderTargetView (ID3D11Texture2D* texture, size_t mipLevel, DXGI_FORMAT rtvFormat)
{
D3D11_TEXTURE2D_DESC texdesc;
texture->GetDesc (&texdesc);
D3D11_RENDER_TARGET_VIEW_DESC desc;
zerostruct (desc);
if (-1 == rtvFormat)
desc.Format = texdesc.Format;
else
desc.Format = rtvFormat;
if (1 == texdesc.ArraySize)
{
desc.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2D;
desc.Texture2D.MipSlice = mipLevel;
}
else
{
desc.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2DARRAY;
desc.Texture2DArray.ArraySize = texdesc.ArraySize;
desc.Texture2DArray.FirstArraySlice = 0;
desc.Texture2DArray.MipSlice = mipLevel;
}
Hold<ID3D11RenderTargetView> rtview;
if (m_failed (device->CreateRenderTargetView (texture, &desc, rtview)))
return nullptr;
return rtview.drop();
}
ID3D11Texture2D* D3D11Context::createTexture2D (size_t width, size_t height, size_t mipLevels, DXGI_FORMAT dataFormat, const void* initialData, size_t rowPitch, size_t slicePitch)
{
D3D11_TEXTURE2D_DESC desc;
zerostruct (desc);
desc.ArraySize = 1;
desc.Usage = D3D11_USAGE_DEFAULT;
desc.Format = dataFormat;
desc.Width = width;
desc.Height = height;
desc.MipLevels = mipLevels;
desc.BindFlags = D3D11_BIND_SHADER_RESOURCE;
desc.SampleDesc.Count = 1;
Hold<ID3D11Texture2D> texture;
D3D11_SUBRESOURCE_DATA srdata;
srdata.pSysMem = initialData;
srdata.SysMemPitch = rowPitch;
srdata.SysMemSlicePitch = slicePitch;
if (m_failed (device->CreateTexture2D (&desc, initialData == nullptr ? nullptr : &srdata, texture)))
return nullptr;
return texture.drop();
}
ID3D11Texture2D* D3D11Resource::createTexture2DArrayRenderBuffer (ID3D11Device* d3dDevice, size_t width, size_t height, size_t arraySize, size_t mipLevels, DXGI_FORMAT dataFormat, DXGI_FORMAT rtvFormat)
{
if (-1 == rtvFormat)
rtvFormat = dataFormat;
D3D11_TEXTURE2D_DESC desc;
zerostruct (desc);
desc.ArraySize = arraySize;
desc.Usage = D3D11_USAGE_DEFAULT;
desc.Format = dataFormat;
desc.Width = width;
desc.Height = height;
desc.MipLevels = mipLevels;
desc.SampleDesc.Count = 1;
switch (rtvFormat)
{
case ::DXGI_FORMAT_D16_UNORM:
case ::DXGI_FORMAT_D24_UNORM_S8_UINT:
case ::DXGI_FORMAT_D32_FLOAT:
case ::DXGI_FORMAT_D32_FLOAT_S8X24_UINT:
desc.BindFlags = D3D11_BIND_DEPTH_STENCIL | D3D11_BIND_SHADER_RESOURCE;
break;
default:
desc.BindFlags = D3D11_BIND_RENDER_TARGET | D3D11_BIND_SHADER_RESOURCE;
break;
}
Hold<ID3D11Texture2D> texture;
if (FAILED (d3dDevice->CreateTexture2D (&desc, nullptr, texture)))
return nullptr;
return texture.drop();
}
//==============================================================================
void VstPluginExternalEditor::mouseExit (const MouseEvent& e)
{
#if defined(LINUX)
if (! handle) return;
XEvent ev;
zerostruct (ev);
ev.xcrossing.display = display;
ev.xcrossing.type = LeaveNotify;
ev.xcrossing.window = handle;
ev.xcrossing.root = RootWindow (display, DefaultScreen (display));
ev.xcrossing.time = CurrentTime;
ev.xcrossing.x = e.x;
ev.xcrossing.y = e.y;
ev.xcrossing.x_root = e.getScreenX ();
ev.xcrossing.y_root = e.getScreenY ();
ev.xcrossing.mode = NotifyNormal; // NotifyGrab, NotifyUngrab
ev.xcrossing.detail = NotifyAncestor; // NotifyVirtual, NotifyInferior, NotifyNonlinear,NotifyNonlinearVirtual
ev.xcrossing.focus = hasKeyboardFocus (true); // TODO - yes ?
translateJuceToXCrossingModifiers (e, ev);
sendEventToChild (& ev);
#endif
}
void AudioPlayHead::CurrentPositionInfo::resetToDefault()
{
zerostruct (*this);
timeSigNumerator = 4;
timeSigDenominator = 4;
bpm = 120;
}
Pimpl (SystemTrayIconComponent& owner_, HICON hicon, HWND hwnd)
: owner (owner_),
originalWndProc ((WNDPROC) GetWindowLongPtr (hwnd, GWLP_WNDPROC)),
taskbarCreatedMessage (RegisterWindowMessage (TEXT ("TaskbarCreated")))
{
SetWindowLongPtr (hwnd, GWLP_WNDPROC, (LONG_PTR) hookedWndProc);
zerostruct (iconData);
iconData.cbSize = sizeof (iconData);
iconData.hWnd = hwnd;
iconData.uID = (UINT) (pointer_sized_int) hwnd;
iconData.uFlags = NIF_ICON | NIF_MESSAGE | NIF_TIP;
iconData.uCallbackMessage = WM_TRAYNOTIFY;
iconData.hIcon = hicon;
Shell_NotifyIcon (NIM_ADD, &iconData);
// In order to receive the "TaskbarCreated" message, we need to request that it's not filtered out.
// (Need to load dynamically, as ChangeWindowMessageFilter is only available in Vista and later)
typedef BOOL (WINAPI* ChangeWindowMessageFilterType) (UINT, DWORD);
ChangeWindowMessageFilterType changeWindowMessageFilter
= (ChangeWindowMessageFilterType) getUser32Function ("ChangeWindowMessageFilter");
if (changeWindowMessageFilter != nullptr)
changeWindowMessageFilter (taskbarCreatedMessage, 1 /* MSGFLT_ADD */);
}
void VstPluginExternalEditor::updateWindowPosition (const int x, const int y)
{
#if defined(LINUX)
if (! handle) return;
XEvent ev;
zerostruct (ev);
ev.xgravity.type = GravityNotify;
ev.xgravity.display = display;
ev.xgravity.window = handle;
ev.xgravity.event = (Window) window->getWindowHandle ();
ev.xgravity.x = x;
ev.xgravity.y = y;
// DBG ("Window Position Updated to: " + String (x) + " " + String (y));
sendEventToChild (& ev);
#endif
//#ifdef JUCE_MAC
#if 0
if (vstGuiWindow)
vstGuiWindow->setTopLeftPosition(window->getX() + offsetX, window->getY() + offsetY);
#endif
}
const StringArray Font::findAllTypefaceNames()
{
StringArray results;
HDC dc = CreateCompatibleDC (0);
{
LOGFONTW lf;
zerostruct (lf);
lf.lfWeight = FW_DONTCARE;
lf.lfOutPrecision = OUT_OUTLINE_PRECIS;
lf.lfQuality = DEFAULT_QUALITY;
lf.lfCharSet = DEFAULT_CHARSET;
lf.lfClipPrecision = CLIP_DEFAULT_PRECIS;
lf.lfPitchAndFamily = FF_DONTCARE;
lf.lfFaceName[0] = 0;
EnumFontFamiliesEx (dc, &lf,
(FONTENUMPROCW) &wfontEnum1,
(LPARAM) &results, 0);
}
DeleteDC (dc);
results.sort (true);
return results;
}
//==============================================================================
void VstPluginExternalEditor::mouseWheelMove (const MouseEvent& e,
float incrementX,
float incrementY)
{
#if defined(LINUX)
if (! handle) return;
XEvent ev;
zerostruct (ev);
ev.xbutton.display = display;
ev.xbutton.type = ButtonPress;
ev.xbutton.window = handle;
ev.xbutton.root = RootWindow (display, DefaultScreen (display));
ev.xbutton.time = CurrentTime;
ev.xbutton.x = e.x;
ev.xbutton.y = e.y;
ev.xbutton.x_root = e.getScreenX ();
ev.xbutton.y_root = e.getScreenY ();
translateJuceToXMouseWheelModifiers (e, incrementY, ev);
sendEventToChild (& ev);
// TODO - put a usleep here ?
ev.xbutton.type = ButtonRelease;
sendEventToChild (& ev);
#endif
}
bool VstPluginExternalEditor::keyPressed (const KeyPress &key)
{
#if defined(LINUX)
if (! handle) return false;
XEvent ev;
zerostruct (ev);
ev.xkey.type = 2; // KeyPress
ev.xkey.display = display;
ev.xkey.window = handle;
ev.xkey.root = RootWindow (display, DefaultScreen (display));
ev.xkey.subwindow = None;
ev.xkey.time = CurrentTime;
// ev.xkey.x = e.x;
// ev.xkey.y = e.y;
// ev.xkey.x_root = e.getScreenX ();
// ev.xkey.y_root = e.getScreenY ();
// ev.xkey.state = e.y;
ev.xkey.keycode = key.getKeyCode();
ev.xkey.same_screen = True;
sendEventToChild (& ev);
return true;
#else
return false;
#endif
}
void childBoundsChanged (juce::Component* child)
{
setSize (child->getWidth(), child->getHeight());
child->setTopLeftPosition (0, 0);
#if JUCE_WIN32
resizeHostWindow (hostWindow, titleW, titleH, this);
owner->updateSize();
#else
Rect r;
GetWindowBounds ((WindowRef) hostWindow, kWindowContentRgn, &r);
HIRect p;
zerostruct (p);
HIViewConvertRect (&p, parentView, 0); // find the X position of our view in case there's space to the left of it
r.right = r.left + jmax (titleW, ((int) p.origin.x) + getWidth());
r.bottom = r.top + getHeight() + titleH;
SetWindowBounds ((WindowRef) hostWindow, kWindowContentRgn, &r);
owner->updateSize();
owner->Invalidate();
#endif
}
static int CALLBACK wfontEnum1 (ENUMLOGFONTEXW* lpelfe,
NEWTEXTMETRICEXW*,
int type,
LPARAM lParam)
{
if (lpelfe != 0 && (type & RASTER_FONTTYPE) == 0)
{
LOGFONTW lf;
zerostruct (lf);
lf.lfWeight = FW_DONTCARE;
lf.lfOutPrecision = OUT_OUTLINE_PRECIS;
lf.lfQuality = DEFAULT_QUALITY;
lf.lfCharSet = DEFAULT_CHARSET;
lf.lfClipPrecision = CLIP_DEFAULT_PRECIS;
lf.lfPitchAndFamily = FF_DONTCARE;
const String fontName (lpelfe->elfLogFont.lfFaceName);
fontName.copyToUnicode (lf.lfFaceName, LF_FACESIZE - 1);
HDC dc = CreateCompatibleDC (0);
EnumFontFamiliesEx (dc, &lf,
(FONTENUMPROCW) &wfontEnum2,
lParam, 0);
DeleteDC (dc);
}
return 1;
}
MD5::MD5 (const File& file)
{
FileInputStream fin (file);
if (fin.getStatus().wasOk())
processStream (fin, -1);
else
zerostruct (result);
}
JUCE_COMRESULT Stat (STATSTG* stat, DWORD)
{
if (stat == nullptr)
return STG_E_INVALIDPOINTER;
zerostruct (*stat);
stat->type = STGTY_STREAM;
stat->cbSize.QuadPart = jmax ((int64) 0, source.getTotalLength());
return S_OK;
}
BEGIN_JUCE_NAMESPACE
#include "juce_MD5.h"
#include "../io/files/juce_FileInputStream.h"
//==============================================================================
MD5::MD5()
{
zerostruct (result);
}
BEGIN_JUCE_NAMESPACE
#include "juce_MidiKeyboardState.h"
#include "../../core/juce_Time.h"
//==============================================================================
MidiKeyboardState::MidiKeyboardState()
{
zerostruct (noteStates);
}
struct tm millisToLocal (const int64 millis) noexcept
{
struct tm result;
const int64 seconds = millis / 1000;
if (seconds < literal64bit (86400) || seconds >= literal64bit (2145916800))
{
// use extended maths for dates beyond 1970 to 2037..
const int timeZoneAdjustment = 31536000 - (int) (Time (1971, 0, 1, 0, 0).toMilliseconds() / 1000);
const int64 jdm = seconds + timeZoneAdjustment + literal64bit (210866803200);
const int days = (int) (jdm / literal64bit (86400));
const int a = 32044 + days;
const int b = (4 * a + 3) / 146097;
const int c = a - (b * 146097) / 4;
const int d = (4 * c + 3) / 1461;
const int e = c - (d * 1461) / 4;
const int m = (5 * e + 2) / 153;
result.tm_mday = e - (153 * m + 2) / 5 + 1;
result.tm_mon = m + 2 - 12 * (m / 10);
result.tm_year = b * 100 + d - 6700 + (m / 10);
result.tm_wday = (days + 1) % 7;
result.tm_yday = -1;
int t = (int) (jdm % literal64bit (86400));
result.tm_hour = t / 3600;
t %= 3600;
result.tm_min = t / 60;
result.tm_sec = t % 60;
result.tm_isdst = -1;
}
else
{
time_t now = static_cast <time_t> (seconds);
#if JUCE_WINDOWS
#ifdef USE_NEW_SECURE_TIME_FNS
if (now >= 0 && now <= 0x793406fff)
localtime_s (&result, &now);
else
zerostruct (result);
#else
result = *localtime (&now);
#endif
#else
localtime_r (&now, &result); // more thread-safe
#endif
}
return result;
}
static bool bindSocketToPort (const SocketHandle handle, const int port) noexcept
{
if (handle <= 0 || port <= 0)
return false;
struct sockaddr_in servTmpAddr;
zerostruct (servTmpAddr); // (can't use "= { 0 }" on this object because it's typedef'ed as a C struct)
servTmpAddr.sin_family = PF_INET;
servTmpAddr.sin_addr.s_addr = htonl (INADDR_ANY);
servTmpAddr.sin_port = htons ((uint16) port);
return bind (handle, (struct sockaddr*) &servTmpAddr, sizeof (struct sockaddr_in)) >= 0;
}
static bool bindSocketToPort (const int handle, const int port) throw()
{
if (handle <= 0 || port <= 0)
return false;
struct sockaddr_in servTmpAddr;
zerostruct (servTmpAddr);
servTmpAddr.sin_family = PF_INET;
servTmpAddr.sin_addr.s_addr = htonl (INADDR_ANY);
servTmpAddr.sin_port = htons ((uint16) port);
return bind (handle, (struct sockaddr*) &servTmpAddr, sizeof (struct sockaddr_in)) >= 0;
}
//==============================================================================
String SystemStats::getStackBacktrace()
{
String result;
#if JUCE_ANDROID || JUCE_MINGW || JUCE_HAIKU
jassertfalse; // sorry, not implemented yet!
#elif JUCE_WINDOWS
HANDLE process = GetCurrentProcess();
SymInitialize (process, nullptr, TRUE);
void* stack[128];
int frames = (int) CaptureStackBackTrace (0, numElementsInArray (stack), stack, nullptr);
HeapBlock<SYMBOL_INFO> symbol;
symbol.calloc (sizeof (SYMBOL_INFO) + 256, 1);
symbol->MaxNameLen = 255;
symbol->SizeOfStruct = sizeof (SYMBOL_INFO);
for (int i = 0; i < frames; ++i)
{
DWORD64 displacement = 0;
if (SymFromAddr (process, (DWORD64) stack[i], &displacement, symbol))
{
result << i << ": ";
IMAGEHLP_MODULE64 moduleInfo;
zerostruct (moduleInfo);
moduleInfo.SizeOfStruct = sizeof (moduleInfo);
if (::SymGetModuleInfo64 (process, symbol->ModBase, &moduleInfo))
result << moduleInfo.ModuleName << ": ";
result << symbol->Name << " + 0x" << String::toHexString ((int64) displacement) << newLine;
}
}
#else
void* stack[128];
int frames = backtrace (stack, numElementsInArray (stack));
char** frameStrings = backtrace_symbols (stack, frames);
for (int i = 0; i < frames; ++i)
result << frameStrings[i] << newLine;
::free (frameStrings);
#endif
return result;
}
static addrinfo* getAddressInfo (const bool isDatagram, const String& hostName, int portNumber)
{
struct addrinfo hints;
zerostruct (hints);
hints.ai_family = AF_UNSPEC;
hints.ai_socktype = isDatagram ? SOCK_DGRAM : SOCK_STREAM;
hints.ai_flags = AI_NUMERICSERV;
struct addrinfo* info = nullptr;
if (getaddrinfo (hostName.toUTF8(), String (portNumber).toUTF8(), &hints, &info) == 0)
return info;
return nullptr;
}
static bool bindSocket (SocketHandle handle, int port, const String& address) noexcept
{
if (handle <= 0 || ! isValidPortNumber (port))
return false;
struct sockaddr_in addr;
zerostruct (addr); // (can't use "= { 0 }" on this object because it's typedef'ed as a C struct)
addr.sin_family = PF_INET;
addr.sin_port = htons ((uint16) port);
addr.sin_addr.s_addr = address.isNotEmpty() ? ::inet_addr (address.toRawUTF8())
: htonl (INADDR_ANY);
return ::bind (handle, (struct sockaddr*) &addr, sizeof (addr)) >= 0;
}
static bool multicast (int handle, const String& multicastIPAddress,
const String& interfaceIPAddress, bool join) noexcept
{
struct ip_mreq mreq;
zerostruct (mreq);
mreq.imr_multiaddr.s_addr = inet_addr (multicastIPAddress.toUTF8());
mreq.imr_interface.s_addr = INADDR_ANY;
if (interfaceIPAddress.isNotEmpty())
mreq.imr_interface.s_addr = inet_addr (interfaceIPAddress.toUTF8());
int joinCmd = join ? IP_ADD_MEMBERSHIP : IP_DROP_MEMBERSHIP;
return setsockopt (handle, IPPROTO_IP, joinCmd, (const char*) &mreq, sizeof (mreq)) == 0;
}
static String getTypefaceNameFromFile (MemoryInputStream& input)
{
OffsetTable offsetTable = { 0 };
input.read (&offsetTable, sizeof (offsetTable));
for (int i = 0; i < (int) ByteOrder::swapIfLittleEndian (offsetTable.numTables); ++i)
{
TableDirectory tableDirectory;
zerostruct (tableDirectory);
input.read (&tableDirectory, sizeof (tableDirectory));
if (String (tableDirectory.tag, sizeof (tableDirectory.tag)).equalsIgnoreCase ("name"))
return parseNameTable (input, ByteOrder::swapIfLittleEndian (tableDirectory.offset));
}
return {};
}
static bool bindSocket (const SocketHandle handle, const int port, const String& address) noexcept
{
if (handle <= 0 || port < 0)
return false;
struct sockaddr_in servTmpAddr;
zerostruct (servTmpAddr); // (can't use "= { 0 }" on this object because it's typedef'ed as a C struct)
servTmpAddr.sin_family = PF_INET;
servTmpAddr.sin_addr.s_addr = htonl (INADDR_ANY);
servTmpAddr.sin_port = htons ((uint16) port);
#if JUCE_WINDOWS
if (address.isNotEmpty())
servTmpAddr.sin_addr.s_addr = ::inet_addr (address.toUTF8());
#else
ignoreUnused (address);
#endif
return bind (handle, (struct sockaddr*) &servTmpAddr, sizeof (struct sockaddr_in)) >= 0;
}
//==============================================================================
bool StreamingSocket::createListener (const int newPortNumber, const String& localHostName)
{
if (connected)
close();
hostName = "listener";
portNumber = newPortNumber;
isListener = true;
struct sockaddr_in servTmpAddr;
zerostruct (servTmpAddr);
servTmpAddr.sin_family = PF_INET;
servTmpAddr.sin_addr.s_addr = htonl (INADDR_ANY);
if (localHostName.isNotEmpty())
{
inet_pton(PF_INET, localHostName.toUTF8(), &servTmpAddr.sin_addr);
//servTmpAddr.sin_addr.s_addr = ::inet_addr(localHostName.toUTF8());
}
servTmpAddr.sin_port = htons ((uint16) portNumber);
handle = (int) socket (AF_INET, SOCK_STREAM, 0);
if (handle < 0)
return false;
const int reuse = 1;
setsockopt (handle, SOL_SOCKET, SO_REUSEADDR, (const char*) &reuse, sizeof (reuse));
if (bind (handle, (struct sockaddr*) &servTmpAddr, sizeof (struct sockaddr_in)) < 0
|| listen (handle, SOMAXCONN) < 0)
{
close();
return false;
}
connected = true;
return true;
}
//==============================================================================
void VstPluginExternalEditor::mouseMove (const MouseEvent& e)
{
#if defined(LINUX)
if (! handle) return;
XEvent ev;
zerostruct (ev);
ev.xmotion.display = display;
ev.xmotion.type = MotionNotify;
ev.xmotion.window = handle;
ev.xmotion.root = RootWindow (display, DefaultScreen (display));
ev.xmotion.time = CurrentTime;
ev.xmotion.is_hint = NotifyNormal;
ev.xmotion.x = e.x;
ev.xmotion.y = e.y;
ev.xmotion.x_root = e.getScreenX ();
ev.xmotion.y_root = e.getScreenY ();
sendEventToChild (& ev);
#endif
}
