void GEUIDialog::GEClose()
{
//is all of the following needed?
LogDebugMessage(_T("Closing GE requested"));
if (NULL != app && m_bgeisuseable)
{
LogDebugMessage(_T("Closing GE"));
m_bgeisuseable = false;
m_bclosed = true;
try
{
SendMessage((HWND) LongToHandle(app->GetMainHwnd()), WM_COMMAND, WM_QUIT, 0);
PostMessage((HWND) LongToHandle(app->GetMainHwnd()), WM_QUIT, 0, 0);
long is_initialized;
int cnt;
cnt = 0;
do {
is_initialized = app->IsInitialized();
cnt++;
wxMicroSleep(1000);
} while ( is_initialized != 0 && cnt < 1000 );
app->Release();
//delete app;
app = NULL;
CoUninitialize();
}
catch(...) {
LogDebugMessage(_T("Error closing GE"));
}
LogDebugMessage(_T("GE closed"));
}
}
void GEUIDialog::GEAttachWindow(bool attach)
{
LogDebugMessage(_T("Attaching/detaching to GE window requested"));
if (NULL != app && m_bgeisuseable)
{
try
{
if (attach)
{
LogDebugMessage(_T("Attaching to the GE window"));
ShowWindowAsync((HWND) LongToHandle(app->GetMainHwnd()), 0);
GEParentHwnd = ::GetParent((HWND) LongToHandle(app->GetRenderHwnd()));
::SetParent((HWND) LongToHandle(app->GetRenderHwnd()), (HWND)this->m_panel1->GetHWND());
GEResize();
}
else
{
LogDebugMessage(_T("Detaching from the GE window"));
::SetParent((HWND) LongToHandle(app->GetRenderHwnd()), GEParentHwnd);
}
}
catch(...) {
LogDebugMessage(_T("Error attaching/detaching the GE window"));
return;
}
LogDebugMessage(_T("GE window attached/detached"));
}
}
/***********************************************************************
* LZCopy (KERNEL32.@)
*
* Copies everything from src to dest
* if src is a LZ compressed file, it will be uncompressed.
* will return the number of bytes written to dest or errors.
*/
LONG WINAPI LZCopy( HFILE src, HFILE dest )
{
int usedlzinit = 0, ret, wret;
LONG len;
HFILE oldsrc = src, srcfd;
FILETIME filetime;
struct lzstate *lzs;
#define BUFLEN 1000
CHAR buf[BUFLEN];
/* we need that weird typedef, for i can't seem to get function pointer
* casts right. (Or they probably just do not like WINAPI in general)
*/
typedef UINT (WINAPI *_readfun)(HFILE,LPVOID,UINT);
_readfun xread;
DPRINT("(%d,%d)\n",src,dest);
if (!IS_LZ_HANDLE(src)) {
src = LZInit(src);
if ((INT)src <= 0) return 0;
if (src != oldsrc) usedlzinit=1;
}
/* not compressed? just copy */
if (!IS_LZ_HANDLE(src))
xread=_lread;
else
xread=(_readfun)LZRead;
len=0;
while (1) {
ret=xread(src,buf,BUFLEN);
if (ret<=0) {
if (ret==0)
break;
if (ret==-1)
return LZERROR_READ;
return ret;
}
len += ret;
wret = _hwrite(dest,buf,ret);
if (wret!=ret)
return LZERROR_WRITE;
}
/* Maintain the timestamp of source file to destination file */
srcfd = (!(lzs = GET_LZ_STATE(src))) ? src : lzs->realfd;
GetFileTime( LongToHandle(srcfd), NULL, NULL, &filetime );
SetFileTime( LongToHandle(dest), NULL, NULL, &filetime );
/* close handle */
if (usedlzinit)
LZClose(src);
return len;
#undef BUFLEN
}
void GEUIDialog::SaveView( wxCommandEvent & event )
{
m_pdialog->Clean();
if (m_pdialog->ShowModal() == wxID_OK)
{
wxFileName fn(m_pdialog->m_fpPath->GetPath());
wxString viewname = m_pdialog->m_tViewName->GetValue();
int format = m_pdialog->m_rFormat->GetSelection();
m_pdialog->Close();
Update();
InvalidateRect ((HWND) LongToHandle(app->GetRenderHwnd()), NULL, TRUE);
UpdateWindow ((HWND) LongToHandle(app->GetRenderHwnd()));
if ( format == SAVE_KML )
{
if ( fn.GetExt().Upper() != _T("KML") )
fn.SetExt(_T("kml"));
SaveViewAsKml( fn.GetFullPath(), viewname );
}
else if ( format == SAVE_JPG )
{
if ( fn.GetExt().Upper() != _T("JPG") )
fn.SetExt(_T("jpg"));
SaveViewAsJPG( fn.GetFullPath() );
}
else if ( format == SAVE_GE2KAP )
{
//Paul doesn't need the JPG anymore
//if ( fn.GetExt().Upper() != _T("JPG") )
// fn.SetExt(_T("jpg"));
//SaveViewAsJPG( fn.GetFullPath() );
fn.SetExt(_T("gpx"));
SaveViewAsGpx( fn.GetFullPath(), viewname );
}
else if ( format == SAVE_IMGKAP )
{
if ( fn.GetExt().Upper() != _T("KMZ") )
fn.SetExt(_T("kmz"));
SaveViewAsKmz( fn.GetFullPath(), viewname );
}
}
else
{
m_pdialog->Close();
}
if (m_pfocusedwindow)
m_pfocusedwindow->SetFocus();
event.Skip();
}
/***************************************************************************\
* DdeKeepStringHandle (DDEML API)
*
* Description:
* Increments the use count of an HSZ.
*
* History:
* 11-1-91 sanfords Created.
\***************************************************************************/
BOOL DdeKeepStringHandle(
DWORD idInst,
HSZ hsz)
{
PCL_INSTANCE_INFO pcii;
BOOL fRet = FALSE;
EnterDDECrit;
pcii = ValidateInstance((HANDLE)LongToHandle( idInst ));
if (pcii == NULL) {
BestSetLastDDEMLError(DMLERR_INVALIDPARAMETER);
goto Exit;
}
if (ValidateHSZ(hsz) == HSZT_INVALID) {
SetLastDDEMLError(pcii, DMLERR_INVALIDPARAMETER);
goto Exit;
}
if (LATOM_FROM_HSZ(hsz) == 0) {
fRet = TRUE;
goto Exit;
}
MONHSZ(pcii, hsz, MH_KEEP);
fRet = IncLocalAtomCount(LATOM_FROM_HSZ(hsz)) ? TRUE : FALSE;
Exit:
LeaveDDECrit;
return (fRet);
}
/***************************************************************************\
* DdeFreeStringHandle (DDEML API)
*
* Description:
* Decrement the use count of an HSZ.
*
* History:
* 11-1-91 sanfords Created.
\***************************************************************************/
BOOL DdeFreeStringHandle(
DWORD idInst,
HSZ hsz)
{
PCL_INSTANCE_INFO pcii;
BOOL fRet = FALSE;
EnterDDECrit;
pcii = ValidateInstance((HANDLE)LongToHandle( idInst ));
if (pcii == NULL) {
BestSetLastDDEMLError(DMLERR_INVALIDPARAMETER);
goto Exit;
}
if (ValidateHSZ(hsz) == HSZT_INVALID) {
SetLastDDEMLError(pcii, DMLERR_INVALIDPARAMETER);
goto Exit;
}
MONHSZ(pcii, hsz, MH_DELETE);
fRet = TRUE;
if (LATOM_FROM_HSZ(hsz) != 0) {
if (DeleteAtom(LATOM_FROM_HSZ(hsz))) {
SetLastDDEMLError(pcii, DMLERR_INVALIDPARAMETER);
fRet = FALSE;
}
}
Exit:
LeaveDDECrit;
return (fRet);
}
//
// Check the details of an existing sender
//
// 1) Find the sender
// 2) Get it's texture info
// 3) Return the sharehandle, width, height, and format
//
// Returns :
// true - all OK.
// width and height are returned changed for sender size change
// false - sender not found or size changed
// width and height are returned zero for sender not found
//
bool spoutSenderNames::CheckSender(const char *sendername, unsigned int &theWidth, unsigned int &theHeight, HANDLE &hSharehandle, DWORD &dwFormat)
{
SharedTextureInfo info;
// Is the given sender registered ?
if(FindSenderName(sendername)) {
// Does it still exist ?
if(getSharedInfo(sendername, &info)) {
// Return the texture info
theWidth = (unsigned int)info.width;
theHeight = (unsigned int)info.height;
#ifdef _M_X64
hSharehandle = (HANDLE)(LongToHandle((long)info.shareHandle));
#else
hSharehandle = (HANDLE)info.shareHandle;
#endif
// hSharehandle = (HANDLE)info.shareHandle;
dwFormat = (DWORD)info.format;
return true;
}
else {
// Sender is registered but does not exist so close it
ReleaseSenderName(sendername);
}
}
// Return zero width and height to indicate sender not found
theHeight = 0;
theWidth = 0;
return false;
} // end CheckSender
void GEUIDialog::SaveViewAsJPG( wxString filename )
{
if (NULL == app || !m_bgeisuseable)
{
wxMessageBox(_("Screenshot can't be created, GE looks uninitialized..."), _("Problem!"));
return;
}
RECT rect;
GetWindowRect((HWND) LongToHandle(app->GetRenderHwnd()), &rect);
int width, height, x, y;
width = rect.right - rect.left - 1;
height = rect.bottom - rect.top - 1;
x = rect.left;
y = rect.top;
wxSize screenSize = wxGetDisplaySize();
wxBitmap bitmap(screenSize.x, screenSize.y);
wxScreenDC dc;
wxMemoryDC memDC;
memDC.SelectObject(bitmap);
memDC.Blit(0, 0, screenSize.x, screenSize.y, & dc, 0, 0);
memDC.SelectObject(wxNullBitmap);
wxMemoryDC cropDC(bitmap);
wxBitmap screenshot(width, height, -1);
memDC.SelectObject(screenshot);
memDC.Blit( 0, 0, width, height, &cropDC, x, y );
memDC.SelectObject(wxNullBitmap);
screenshot.SaveFile(filename, wxBITMAP_TYPE_JPEG);
}
PPH_PROCESS_RECORD PhSipReferenceMaxCpuRecord(
_In_ LONG Index
)
{
LARGE_INTEGER time;
LONG maxProcessIdLong;
HANDLE maxProcessId;
// Find the process record for the max. CPU process for the particular time.
maxProcessIdLong = PhGetItemCircularBuffer_ULONG(&PhMaxCpuHistory, Index);
if (!maxProcessIdLong)
return NULL;
// This must be treated as a signed integer to handle Interrupts correctly.
maxProcessId = LongToHandle(maxProcessIdLong);
// Note that the time we get has its components beyond seconds cleared.
// For example:
// * At 2.5 seconds a process is started.
// * At 2.75 seconds our process provider is fired, and the process is determined
// to have 75% CPU usage, which happens to be the maximum CPU usage.
// * However the 2.75 seconds is recorded as 2 seconds due to
// RtlTimeToSecondsSince1980.
// * If we call PhFindProcessRecord, it cannot find the process because it was
// started at 2.5 seconds, not 2 seconds or older.
//
// This means we must add one second minus one tick (100ns) to the time, giving us
// 2.9999999 seconds. This will then make sure we find the process.
PhGetStatisticsTime(NULL, Index, &time);
time.QuadPart += PH_TICKS_PER_SEC - 1;
return PhFindProcessRecord(maxProcessId, &time);
}
// The initial pixel format is used to get an initial rendering context so
// that more rendering functions can be loaded. These new rendering functions
// allow a better, final, rendering context to be created.
int gs_get_initial_pixelformat(long shell)
{
HDC hdc = LongToHandle(shell);
int flags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER;
PIXELFORMATDESCRIPTOR pfd =
{
sizeof(PIXELFORMATDESCRIPTOR),
1, // version
flags, // see above
PFD_TYPE_RGBA, // type of framebuffer
32, // colour depth
0,0,0,0,0,0,0,0, // red, green, blue, alpha bits
0,0,0,0,0, // accum bits
24, // depth buffer bits.
0, // stencil buffer bits.
PFD_MAIN_PLANE, // layer
0,0,0,0,0 // unused
};
// create the temporary context using the proper pixel format.
int pixelFormat = ChoosePixelFormat(hdc, &pfd);
if (pixelFormat != 0)
{
SetPixelFormat(hdc, pixelFormat, &pfd);
return pixelFormat;
}
return 0;
}
// The final pixel format created using the bound rendering functions.
int gs_get_pixelformat(long shell)
{
const int attribList[] =
{
WGL_DRAW_TO_WINDOW_ARB, 1,
WGL_SUPPORT_OPENGL_ARB, 1,
WGL_DOUBLE_BUFFER_ARB, 1,
WGL_PIXEL_TYPE_ARB, WGL_TYPE_RGBA_ARB,
WGL_ACCELERATION_ARB, WGL_FULL_ACCELERATION_ARB,
WGL_COLOR_BITS_ARB, 32,
WGL_DEPTH_BITS_ARB, 24,
WGL_STENCIL_BITS_ARB, 8,
0, // end
};
int pixelFormat;
UINT numFormats;
HDC hdc = LongToHandle(shell);
gs_wglChoosePixelFormatARB(hdc, attribList, NULL, 1, &pixelFormat, &numFormats);
if (pixelFormat != 0)
{
PIXELFORMATDESCRIPTOR pfd;
DescribePixelFormat(hdc, pixelFormat, sizeof(PIXELFORMATDESCRIPTOR), &pfd);
SetPixelFormat(hdc, pixelFormat, &pfd);
return pixelFormat;
}
return 0;
}
/*
* @implemented
*/
LONG
WINAPI
_llseek(HFILE hFile, LONG lOffset, int iOrigin)
{
return SetFilePointer(LongToHandle(hFile),
lOffset,
NULL,
(DWORD) iOrigin);
}
/**
* Retrieves current system statistics.
*/
VOID PhPluginGetSystemStatistics(
_Out_ PPH_PLUGIN_SYSTEM_STATISTICS Statistics
)
{
Statistics->Performance = &PhPerfInformation;
Statistics->NumberOfProcesses = PhTotalProcesses;
Statistics->NumberOfThreads = PhTotalThreads;
Statistics->NumberOfHandles = PhTotalHandles;
Statistics->CpuKernelUsage = PhCpuKernelUsage;
Statistics->CpuUserUsage = PhCpuUserUsage;
Statistics->IoReadDelta = PhIoReadDelta;
Statistics->IoWriteDelta = PhIoWriteDelta;
Statistics->IoOtherDelta = PhIoOtherDelta;
Statistics->CommitPages = PhGetItemCircularBuffer_ULONG(&PhCommitHistory, 0);
Statistics->PhysicalPages = PhGetItemCircularBuffer_ULONG(&PhPhysicalHistory, 0);
Statistics->MaxCpuProcessId = LongToHandle(PhGetItemCircularBuffer_ULONG(&PhMaxCpuHistory, 0));
Statistics->MaxIoProcessId = LongToHandle(PhGetItemCircularBuffer_ULONG(&PhMaxIoHistory, 0));
Statistics->CpuKernelHistory = &PhCpuKernelHistory;
Statistics->CpuUserHistory = &PhCpuUserHistory;
Statistics->CpusKernelHistory = &PhCpusKernelHistory;
Statistics->CpusUserHistory = &PhCpusUserHistory;
Statistics->IoReadHistory = &PhIoReadHistory;
Statistics->IoWriteHistory = &PhIoWriteHistory;
Statistics->IoOtherHistory = &PhIoOtherHistory;
Statistics->CommitHistory = &PhCommitHistory;
Statistics->PhysicalHistory = &PhPhysicalHistory;
Statistics->MaxCpuHistory = &PhMaxCpuHistory;
Statistics->MaxIoHistory = &PhMaxIoHistory;
#ifdef PH_RECORD_MAX_USAGE
Statistics->MaxCpuUsageHistory = &PhMaxCpuUsageHistory;
Statistics->MaxIoReadOtherHistory = &PhMaxIoReadOtherHistory;
Statistics->MaxIoWriteHistory = &PhMaxIoWriteHistory;
#else
Statistics->MaxCpuUsageHistory = NULL;
Statistics->MaxIoReadOtherHistory = NULL;
Statistics->MaxIoWriteHistory = NULL;
#endif
}
// Destroy the application window. Attempt to remove the rendering context and
// the device context as well.
void gs_display_dispose(long display)
{
HWND hwnd = LongToHandle(display);
HDC shell = GetDC(hwnd);
HGLRC context = wglGetCurrentContext();
wglMakeCurrent(NULL, NULL);
wglDeleteContext(context);
ReleaseDC(hwnd, shell);
DestroyWindow(hwnd);
}
HSZ InternalDdeCreateStringHandle(
DWORD idInst,
PVOID psz,
int iCodePage)
{
PCL_INSTANCE_INFO pcii;
HSZ hszRet = 0;
int cb;
WCHAR szw[256];
EnterDDECrit;
pcii = ValidateInstance((HANDLE)LongToHandle( idInst ));
if (pcii == NULL) {
BestSetLastDDEMLError(DMLERR_INVALIDPARAMETER);
goto Exit;
}
switch (iCodePage) {
case CP_WINANSI:
if (*(LPSTR)psz == '\0') {
goto Exit;
}
hszRet = NORMAL_HSZ_FROM_LATOM(AddAtomA((LPSTR)psz));
break;
default:
/*
* Convert psz to unicode and fall through.
*/
cb = sizeof(szw) / sizeof(WCHAR);
#ifdef LATER
MultiByteToWideChar((UINT)iCodePage, MB_PRECOMPOSED,
(LPSTR)psz, -1, szw, cb);
#endif
psz = &szw[0];
case CP_WINUNICODE:
if (*(LPWSTR)psz == L'\0') {
goto Exit;
}
hszRet = NORMAL_HSZ_FROM_LATOM(AddAtomW((LPWSTR)psz));
break;
}
MONHSZ(pcii, hszRet, MH_CREATE);
Exit:
LeaveDDECrit;
return (hszRet);
}
BOOL _SetWindowContextHelpId(PWND pWnd, DWORD dwContextId)
{
//If dwContextId is NULL, then this implies that the caller wants to
// remove the dwContextId associated with this Window.
if(dwContextId == 0) {
InternalRemoveProp(pWnd, MAKEINTATOM(gpsi->atomContextHelpIdProp),
PROPF_INTERNAL);
return(TRUE);
}
return (InternalSetProp(pWnd, MAKEINTATOM(gpsi->atomContextHelpIdProp),
(HANDLE)LongToHandle( dwContextId ), PROPF_INTERNAL | PROPF_NOPOOL));
}
/***********************************************************************
* LZClose (KERNEL32.@)
*/
void WINAPI LZClose( HFILE fd )
{
struct lzstate *lzs;
DPRINT("(%d)\n",fd);
if (!(lzs = GET_LZ_STATE(fd))) _lclose(fd);
else
{
if (lzs->get) RtlFreeHeap( GetProcessHeap(), 0, lzs->get );
CloseHandle( LongToHandle(lzs->realfd) );
lzstates[fd - LZ_MIN_HANDLE] = NULL;
RtlFreeHeap( GetProcessHeap(), 0, lzs );
}
}
LRESULT CALLBACK
CDeskBand::WndProc(HWND hWnd, UINT uMessage, WPARAM wParam, LPARAM lParam)
{
CDeskBand *pThis = (CDeskBand*)GetWindowLongPtr(hWnd, GWLP_USERDATA);
switch (uMessage)
{
case WM_NCCREATE:
{
LPCREATESTRUCT lpcs = (LPCREATESTRUCT)lParam;
pThis = (CDeskBand *)( lpcs->lpCreateParams );
SetWindowLongPtr(hWnd, GWLP_USERDATA, (LONG_PTR)pThis);
SetWindowPos(hWnd, NULL, 0, 0, 0, 0,
SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER | SWP_FRAMECHANGED);
//set the window handle
pThis->m_hWnd = hWnd;
SetTimer(hWnd, 0xdeadf00d, 3000, NULL);
}
break;
case WM_COMMAND:
return pThis->OnCommand(wParam, lParam);
case WM_TIMER:
return pThis->OnTimer(wParam, lParam);
case WM_COPYDATA:
return pThis->OnCopyData((PCOPYDATASTRUCT) lParam);
case WM_SETFOCUS:
return pThis->OnSetFocus();
case WM_KILLFOCUS:
return pThis->OnKillFocus();
case WM_SIZE:
return pThis->OnSize(lParam);
case WM_WINDOWPOSCHANGING:
pThis->OnWindowPosChanging(wParam, lParam);
break;
case WM_LBUTTONUP:
SendMessage((HWND)LongToHandle(pThis->m_AppletMenu.command_window),
WM_USER + 1, 0, NULL);
break;
}
return DefWindowProc(hWnd, uMessage, wParam, lParam);
}
/*
* @implemented
*/
long
WINAPI
_hread(HFILE hFile, LPVOID lpBuffer, long lBytes)
{
DWORD NumberOfBytesRead;
if (!ReadFile(LongToHandle(hFile),
lpBuffer,
(DWORD) lBytes,
&NumberOfBytesRead,
NULL))
{
return HFILE_ERROR;
}
return NumberOfBytesRead;
}
void GEUIDialog::GEResize()
{
LogDebugMessage(_T("GE resize requested"));
//while ( m_bbusy ) ;
if ( m_bbusy )
{
LogDebugMessage(_T("GE resize request discarded, busy"));
return;
}
m_bbusy = true;
if(NULL != app && m_bgeisuseable)
{
LogDebugMessage(_T("Resizing GE"));
try
{
this->Layout();
//Calculate the window extents
RECT rect;
GetWindowRect((HWND) LongToHandle(app->GetMainHwnd()), &rect);
int mwidth, mheight, mx, my;
mwidth = rect.right - rect.left - 1;
mheight = rect.bottom - rect.top - 1;
mx = rect.left;
my = rect.top;
GetWindowRect((HWND) LongToHandle(app->GetRenderHwnd()), &rect);
int rwidth, rheight, rx, ry;
rwidth = rect.right - rect.left - 1;
rheight = rect.bottom - rect.top - 1;
rx = rect.left;
ry = rect.top;
int deltawidth = mwidth - rwidth;
int deltaheight = mheight - rheight;
wxSize panelsize = this->m_panel1->GetSize();
//Resize
SendMessage((HWND) LongToHandle(app->GetMainHwnd()), WM_COMMAND, WM_PAINT, 0);
PostMessage((HWND) LongToHandle(app->GetMainHwnd()), WM_QT_PAINT, 0, 0);
SetWindowPos(
(HWND) LongToHandle(app->GetMainHwnd()),
HWND_TOP,
0,
0,
panelsize.GetX() + deltawidth,
panelsize.GetY() + deltaheight,
SWP_FRAMECHANGED);
SendMessage((HWND) LongToHandle(app->GetRenderHwnd()), WM_COMMAND, WM_SIZE, 0);
LogDebugMessage(_T("GE resized"));
}
catch(...) {
LogDebugMessage(_T("Error resizing GE window"));
}
}
m_bbusy = false;
}
//! Method exported to mIRC that can be invoked to subclass a specified
//! window (by hwnd) and make its window frame blue.
extern "C" int __declspec(dllexport) __stdcall blue_window(
HWND mWnd, HWND aWnd, char *data, char *parms, BOOL show, BOOL nopause)
{
DOUT(("mIRC callback for blue_window invoked\n"));
if (data != NULL) {
HWND hwnd = (HWND) LongToHandle(atoi(data));
bool bResult = BlueWindow::SubclassNewWindow(hwnd);
if (bResult) {
DOUT(("blue_window successfully subclassed new window %p\n", (void*) hwnd));
} else {
DOUT(("blue_window failed to subclass new window.\n"));
}
}
return 1; // mIRC should just continue executing.
}
// This retrieves the info from the requested sender and fails if the sender does not exist
// For external access to getSharedInfo - redundancy
bool spoutSenderNames::GetSenderInfo(const char* sendername, unsigned int &width, unsigned int &height, HANDLE &dxShareHandle, DWORD &dwFormat)
{
SharedTextureInfo info;
if(getSharedInfo(sendername, &info)) {
width = (unsigned int)info.width;
height = (unsigned int)info.height;
#ifdef _M_X64
dxShareHandle = (HANDLE)(LongToHandle((long)info.shareHandle));
#else
dxShareHandle = (HANDLE)info.shareHandle;
#endif
// dxShareHandle = (HANDLE)info.shareHandle;
dwFormat = info.format;
return true;
}
return false;
}
/***************************************************************************\
* DdeGetLastError (DDEML API)
*
* Description:
* Returns last error code set for the instance given.
*
* History:
* 11-12-91 sanfords Created.
\***************************************************************************/
UINT DdeGetLastError(
DWORD idInst)
{
UINT uiRet = 0;
PCL_INSTANCE_INFO pcii;
EnterDDECrit;
pcii = ValidateInstance((HANDLE)LongToHandle( idInst ));
if (pcii == NULL) {
uiRet = DMLERR_INVALIDPARAMETER;
goto Exit;
}
uiRet = pcii->LastError;
pcii->LastError = DMLERR_NO_ERROR;
Exit:
LeaveDDECrit;
return (uiRet);
}
HWND
CreatePushButton(const char* lpWindowName, DWORD xSize, DWORD id,DWORD Style)
{
HWND h = CreateWindow("BUTTON",
lpWindowName,
WS_CHILD | BS_PUSHBUTTON | Style,
xButPos, /* x */
yButPos, /* y */
xSize, /* nWidth */
20, /* nHeight */
g_hwnd,
LongToHandle(id),
g_hInst,
NULL
);
yButPos += 21;
return h;
}
// この関数もMtlWin.hの中で浮いていたので隔離した
// もしかしたら作ったの自分かも
HWND _CreateSimpleReBarCtrl(HWND hWndParent, DWORD dwStyle, UINT nID)
{
// Ensure style combinations for proper rebar painting
if (dwStyle & CCS_NODIVIDER && dwStyle & WS_BORDER)
dwStyle &= ~WS_BORDER;
else if ( !(dwStyle & WS_BORDER) && !(dwStyle & CCS_NODIVIDER) )
dwStyle |= CCS_NODIVIDER;
// Create rebar window
HWND hWndReBar = ::CreateWindowEx(
0,
REBARCLASSNAME,
NULL,
dwStyle,
0,
0,
100,
100,
hWndParent,
(HMENU) LongToHandle(nID),
_Module.GetModuleInstance(),
NULL );
if (hWndReBar == NULL) {
ATLTRACE2( atlTraceUI, 0, _T("Failed to create rebar.\n") );
return NULL;
}
// Initialize and send the REBARINFO structure
REBARINFO rbi;
rbi.cbSize = sizeof (REBARINFO);
rbi.fMask = 0;
if ( !::SendMessage(hWndReBar, RB_SETBARINFO, 0, (LPARAM) &rbi) ) {
ATLTRACE2( atlTraceUI, 0, _T("Failed to initialize rebar.\n") );
::DestroyWindow(hWndReBar);
return NULL;
}
return hWndReBar;
}
/* !checksrc! disable SPACEBEFOREPAREN 1 */
curl_thread_t Curl_thread_create(unsigned int (CURL_STDCALL *func) (void *),
void *arg)
{
curl_thread_t t;
#ifdef _WIN32_WCE
t = CreateThread(NULL, 0, func, arg, 0, NULL);
#else
uintptr_t thread_handle = _beginthreadex(NULL, 0, func, arg, 0, NULL);
t = (curl_thread_t)thread_handle;
#endif
if((t == 0) || (t == LongToHandle(-1L))) {
#ifdef _WIN32_WCE
DWORD gle = GetLastError();
errno = ((gle == ERROR_ACCESS_DENIED ||
gle == ERROR_NOT_ENOUGH_MEMORY) ?
EACCES : EINVAL);
#endif
return curl_thread_t_null;
}
return t;
}
HRESULT STDMETHODCALLTYPE CShellDispatch::BrowseForFolder(LONG Hwnd, BSTR Title, LONG Options, VARIANT RootFolder, Folder **ppsdf)
{
TRACE("(%p, %lu, %ls, %lu, %s, %p)\n", this, Hwnd, Title, Options, debugstr_variant(&RootFolder), ppsdf);
*ppsdf = NULL;
if (!is_optional_argument(&RootFolder))
FIXME("root folder is ignored\n");
BROWSEINFOW bi = { 0 };
bi.hwndOwner = reinterpret_cast<HWND>(LongToHandle(Hwnd));
bi.lpszTitle = Title;
bi.ulFlags = Options;
CComHeapPtr<ITEMIDLIST> selection;
selection.Attach(SHBrowseForFolderW(&bi));
if (!selection)
return S_FALSE;
return ShellObjectCreatorInit<CFolder>(static_cast<LPITEMIDLIST>(selection), IID_PPV_ARG(Folder, ppsdf));
}
// Find a sender and return the name, width and height, sharhandle and format
bool spoutSenderNames::FindSender(char *sendername, unsigned int &width, unsigned int &height, HANDLE &hSharehandle, DWORD &dwFormat)
{
SharedTextureInfo info;
// ---------------------------------------------------------
// For a receiver check the user entered Sender name, if one, to see if it exists
if(sendername[0] == 0) {
// Passed name was null, so find the active sender
if(!GetActiveSender(sendername)) {
return false;
}
}
// now we have either an existing sender name or the active sender name
// 01.08.15 - Is the given sender registered ?
if(!FindSenderName(sendername))
return false;
// Sender is registered so try to get the sender information
if(getSharedInfo(sendername, &info)) {
width = (unsigned int)info.width; // pass back sender size
height = (unsigned int)info.height;
#ifdef _M_X64
hSharehandle = (HANDLE)(LongToHandle((long)info.shareHandle));
#else
hSharehandle = (HANDLE)info.shareHandle;
#endif
// hSharehandle = (HANDLE)info.shareHandle;
dwFormat = (DWORD)info.format;
return true;
}
// 01.08.15 - Registered sender is no longer there so release it
ReleaseSenderName(sendername);
return false;
} // end FindSender
/*
* @implemented
*/
long
WINAPI
_hwrite(HFILE hFile, LPCSTR lpBuffer, long lBytes)
{
DWORD NumberOfBytesWritten;
if (lBytes == 0)
{
if (!SetEndOfFile((HANDLE) hFile))
{
return HFILE_ERROR;
}
return 0;
}
if (!WriteFile(LongToHandle(hFile),
(LPVOID) lpBuffer,
(DWORD) lBytes,
&NumberOfBytesWritten,
NULL))
{
return HFILE_ERROR;
}
return NumberOfBytesWritten;
}
//
// Retrieve the texture info of the active sender
// - redundancy
bool spoutSenderNames::FindActiveSender(char sendername[SpoutMaxSenderNameLen], unsigned int &theWidth, unsigned int &theHeight, HANDLE &hSharehandle, DWORD &dwFormat)
{
SharedTextureInfo TextureInfo;
char sname[SpoutMaxSenderNameLen];
if(GetActiveSender(sname)) { // there is an active sender
if(getSharedInfo(sname, &TextureInfo)) {
strcpy_s(sendername, SpoutMaxSenderNameLen, sname); // pass back sender name
theWidth = (unsigned int)TextureInfo.width;
theHeight = (unsigned int)TextureInfo.height;
#ifdef _M_X64
hSharehandle = (HANDLE)(LongToHandle((long)TextureInfo.shareHandle));
#else
hSharehandle = (HANDLE)TextureInfo.shareHandle;
#endif
// hSharehandle = (HANDLE)TextureInfo.shareHandle;
dwFormat = (DWORD)TextureInfo.format;
return true;
}
}
return false;
} // end FindActiveSender
