Windows stdio capture is working on my MSVC5. Here is the first
alpha release. git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@6290 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
Guilhem Lavaux
parent
13d12797d2
commit
a9c3ed030e
672
utils/wxMMedia2/utilsexc.cpp
Normal file
672
utils/wxMMedia2/utilsexc.cpp
Normal file
@ -0,0 +1,672 @@
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
// Name: msw/utilsexec.cpp
|
||||
// Purpose: Various utilities
|
||||
// Author: Julian Smart
|
||||
// Modified by:
|
||||
// Created: 04/01/98
|
||||
// RCS-ID: $Id$
|
||||
// Copyright: (c) Julian Smart and Markus Holzem
|
||||
// Licence: wxWindows license
|
||||
/////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
// ============================================================================
|
||||
// declarations
|
||||
// ============================================================================
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// headers
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
#ifdef __GNUG__
|
||||
#pragma implementation
|
||||
#endif
|
||||
|
||||
// For compilers that support precompilation, includes "wx.h".
|
||||
#include "wx/wxprec.h"
|
||||
|
||||
#ifdef __BORLANDC__
|
||||
#pragma hdrstop
|
||||
#endif
|
||||
|
||||
#ifndef WX_PRECOMP
|
||||
#include "wx/utils.h"
|
||||
#include "wx/app.h"
|
||||
#include "wx/intl.h"
|
||||
#endif
|
||||
|
||||
#include "wx/log.h"
|
||||
|
||||
#ifdef __WIN32__
|
||||
#include "wx/stream.h"
|
||||
#include "wx/process.h"
|
||||
#endif
|
||||
|
||||
#include "wx/msw/private.h"
|
||||
|
||||
#include <ctype.h>
|
||||
|
||||
#if !defined(__GNUWIN32__) && !defined(__WXWINE__) && !defined(__SALFORDC__)
|
||||
#include <direct.h>
|
||||
#ifndef __MWERKS__
|
||||
#include <dos.h>
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#if defined(__GNUWIN32__) && !defined(__TWIN32__)
|
||||
#include <sys/unistd.h>
|
||||
#include <sys/stat.h>
|
||||
#endif
|
||||
|
||||
#if defined(__WIN32__) && !defined(__WXWINE__)
|
||||
#include <io.h>
|
||||
|
||||
#ifndef __GNUWIN32__
|
||||
#include <shellapi.h>
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#ifndef __WATCOMC__
|
||||
#if !(defined(_MSC_VER) && (_MSC_VER > 800))
|
||||
#include <errno.h>
|
||||
#endif
|
||||
#endif
|
||||
#include <stdarg.h>
|
||||
|
||||
#if wxUSE_IPC
|
||||
#include "wx/dde.h" // for WX_DDE hack in wxExecute
|
||||
#endif // wxUSE_IPC
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// constants
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
// this message is sent when the process we're waiting for terminates
|
||||
#define wxWM_PROC_TERMINATED (WM_USER + 10000)
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// this module globals
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
// we need to create a hidden window to receive the process termination
|
||||
// notifications and for this we need a (Win) class name for it which we will
|
||||
// register the first time it's needed
|
||||
static const wxChar *gs_classForHiddenWindow = NULL;
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// private types
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
// structure describing the process we're being waiting for
|
||||
struct wxExecuteData
|
||||
{
|
||||
public:
|
||||
~wxExecuteData()
|
||||
{
|
||||
#ifndef __WIN16__
|
||||
if ( !::CloseHandle(hProcess) )
|
||||
{
|
||||
wxLogLastError("CloseHandle(hProcess)");
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
HWND hWnd; // window to send wxWM_PROC_TERMINATED to
|
||||
HANDLE hProcess; // handle of the process
|
||||
DWORD dwProcessId; // pid of the process
|
||||
wxProcess *handler;
|
||||
DWORD dwExitCode; // the exit code of the process
|
||||
bool state; // set to FALSE when the process finishes
|
||||
};
|
||||
|
||||
|
||||
#ifdef __WIN32__
|
||||
// ----------------------------------------------------------------------------
|
||||
// wxPipeStreams
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
class wxPipeInputStream: public wxInputStream {
|
||||
public:
|
||||
wxPipeInputStream(HANDLE hInput);
|
||||
~wxPipeInputStream();
|
||||
|
||||
protected:
|
||||
size_t OnSysRead(void *buffer, size_t len);
|
||||
|
||||
protected:
|
||||
HANDLE m_hInput;
|
||||
};
|
||||
|
||||
class wxPipeOutputStream: public wxOutputStream {
|
||||
public:
|
||||
wxPipeOutputStream(HANDLE hOutput);
|
||||
~wxPipeOutputStream();
|
||||
|
||||
protected:
|
||||
size_t OnSysWrite(const void *buffer, size_t len);
|
||||
|
||||
protected:
|
||||
HANDLE m_hOutput;
|
||||
};
|
||||
|
||||
// ==================
|
||||
// wxPipeInputStream
|
||||
// ==================
|
||||
|
||||
wxPipeInputStream::wxPipeInputStream(HANDLE hInput)
|
||||
{
|
||||
m_hInput = hInput;
|
||||
}
|
||||
|
||||
wxPipeInputStream::~wxPipeInputStream()
|
||||
{
|
||||
::CloseHandle(m_hInput);
|
||||
}
|
||||
|
||||
size_t wxPipeInputStream::OnSysRead(void *buffer, size_t len)
|
||||
{
|
||||
DWORD bytesRead;
|
||||
|
||||
m_lasterror = wxSTREAM_NOERROR;
|
||||
if (! ::ReadFile(m_hInput, buffer, len, &bytesRead, NULL) ) {
|
||||
if (GetLastError() == ERROR_BROKEN_PIPE)
|
||||
m_lasterror = wxSTREAM_EOF;
|
||||
else
|
||||
m_lasterror = wxSTREAM_READ_ERROR;
|
||||
}
|
||||
return bytesRead;
|
||||
}
|
||||
|
||||
// ==================
|
||||
// wxPipeOutputStream
|
||||
// ==================
|
||||
|
||||
wxPipeOutputStream::wxPipeOutputStream(HANDLE hOutput)
|
||||
{
|
||||
m_hOutput = hOutput;
|
||||
}
|
||||
|
||||
wxPipeOutputStream::~wxPipeOutputStream()
|
||||
{
|
||||
::CloseHandle(m_hOutput);
|
||||
}
|
||||
|
||||
size_t wxPipeOutputStream::OnSysWrite(const void *buffer, size_t len)
|
||||
{
|
||||
DWORD bytesRead;
|
||||
|
||||
m_lasterror = wxSTREAM_NOERROR;
|
||||
if (! ::WriteFile(m_hOutput, buffer, len, &bytesRead, NULL) ) {
|
||||
if (GetLastError() == ERROR_BROKEN_PIPE)
|
||||
m_lasterror = wxSTREAM_EOF;
|
||||
else
|
||||
m_lasterror = wxSTREAM_READ_ERROR;
|
||||
}
|
||||
return bytesRead;
|
||||
}
|
||||
|
||||
#endif // __WIN32__
|
||||
|
||||
// ============================================================================
|
||||
// implementation
|
||||
// ============================================================================
|
||||
|
||||
#ifdef __WIN32__
|
||||
static DWORD wxExecuteThread(wxExecuteData *data)
|
||||
{
|
||||
WaitForSingleObject(data->hProcess, INFINITE);
|
||||
|
||||
// get the exit code
|
||||
if ( !GetExitCodeProcess(data->hProcess, &data->dwExitCode) )
|
||||
{
|
||||
wxLogLastError("GetExitCodeProcess");
|
||||
}
|
||||
|
||||
wxASSERT_MSG( data->dwExitCode != STILL_ACTIVE,
|
||||
wxT("process should have terminated") );
|
||||
|
||||
// send a message indicating process termination to the window
|
||||
SendMessage(data->hWnd, wxWM_PROC_TERMINATED, 0, (LPARAM)data);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
// window procedure of a hidden window which is created just to receive
|
||||
// the notification message when a process exits
|
||||
LRESULT APIENTRY _EXPORT wxExecuteWindowCbk(HWND hWnd, UINT message,
|
||||
WPARAM wParam, LPARAM lParam)
|
||||
{
|
||||
if ( message == wxWM_PROC_TERMINATED )
|
||||
{
|
||||
DestroyWindow(hWnd); // we don't need it any more
|
||||
|
||||
wxExecuteData *data = (wxExecuteData *)lParam;
|
||||
if ( data->handler )
|
||||
{
|
||||
data->handler->OnTerminate((int)data->dwProcessId,
|
||||
(int)data->dwExitCode);
|
||||
}
|
||||
|
||||
if ( data->state )
|
||||
{
|
||||
// we're executing synchronously, tell the waiting thread
|
||||
// that the process finished
|
||||
data->state = 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
// asynchronous execution - we should do the clean up
|
||||
delete data;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
return DefWindowProc(hWnd, message, wParam, lParam);
|
||||
}
|
||||
}
|
||||
#endif // Win32
|
||||
|
||||
long wxExecute(const wxString& cmd, bool sync, wxProcess *handler)
|
||||
{
|
||||
wxCHECK_MSG( !!cmd, 0, wxT("empty command in wxExecute") );
|
||||
|
||||
wxString command;
|
||||
#if wxUSE_IPC
|
||||
// DDE hack: this is really not pretty, but we need to allow this for
|
||||
// transparent handling of DDE servers in wxMimeTypesManager. Usually it
|
||||
// returns the command which should be run to view/open/... a file of the
|
||||
// given type. Sometimes, however, this command just launches the server
|
||||
// and an additional DDE request must be made to really open the file. To
|
||||
// keep all this well hidden from the application, we allow a special form
|
||||
// of command: WX_DDE:<command>:DDE_SERVER:DDE_TOPIC:DDE_COMMAND in which
|
||||
// case we execute just <command> and process the rest below
|
||||
wxString ddeServer, ddeTopic, ddeCommand;
|
||||
static const size_t lenDdePrefix = 7; // strlen("WX_DDE:")
|
||||
if ( cmd.Left(lenDdePrefix) == _T("WX_DDE#") )
|
||||
{
|
||||
const wxChar *p = cmd.c_str() + 7;
|
||||
while ( *p && *p != _T('#') )
|
||||
{
|
||||
command += *p++;
|
||||
}
|
||||
|
||||
if ( *p )
|
||||
{
|
||||
// skip '#'
|
||||
p++;
|
||||
}
|
||||
else
|
||||
{
|
||||
wxFAIL_MSG(_T("invalid WX_DDE command in wxExecute"));
|
||||
}
|
||||
|
||||
while ( *p && *p != _T('#') )
|
||||
{
|
||||
ddeServer += *p++;
|
||||
}
|
||||
|
||||
if ( *p )
|
||||
{
|
||||
// skip '#'
|
||||
p++;
|
||||
}
|
||||
else
|
||||
{
|
||||
wxFAIL_MSG(_T("invalid WX_DDE command in wxExecute"));
|
||||
}
|
||||
|
||||
while ( *p && *p != _T('#') )
|
||||
{
|
||||
ddeTopic += *p++;
|
||||
}
|
||||
|
||||
if ( *p )
|
||||
{
|
||||
// skip '#'
|
||||
p++;
|
||||
}
|
||||
else
|
||||
{
|
||||
wxFAIL_MSG(_T("invalid WX_DDE command in wxExecute"));
|
||||
}
|
||||
|
||||
while ( *p )
|
||||
{
|
||||
ddeCommand += *p++;
|
||||
}
|
||||
}
|
||||
else
|
||||
#endif // wxUSE_IPC
|
||||
{
|
||||
// no DDE
|
||||
command = cmd;
|
||||
}
|
||||
|
||||
#if defined(__WIN32__) && !defined(__TWIN32__)
|
||||
// the old code is disabled because we really need a process handle
|
||||
// if we want to execute it asynchronously or even just get its
|
||||
// return code and for this we must use CreateProcess() and not
|
||||
// ShellExecute()
|
||||
#if 0
|
||||
// isolate command and arguments
|
||||
wxString commandName;
|
||||
bool insideQuotes = FALSE;
|
||||
const char *pc;
|
||||
for ( pc = command.c_str(); *pc != '\0'; pc++ )
|
||||
{
|
||||
switch ( *pc )
|
||||
{
|
||||
case ' ':
|
||||
case '\t':
|
||||
if ( !insideQuotes )
|
||||
break;
|
||||
// fall through
|
||||
|
||||
case '"':
|
||||
insideQuotes = !insideQuotes;
|
||||
// fall through
|
||||
|
||||
default:
|
||||
commandName += *pc;
|
||||
continue; // skip the next break
|
||||
}
|
||||
|
||||
// only reached for space not inside quotes
|
||||
break;
|
||||
}
|
||||
wxString commandArgs = pc;
|
||||
|
||||
wxWindow *winTop = wxTheApp->GetTopWindow();
|
||||
HWND hwndTop = (HWND)(winTop ? winTop->GetHWND() : 0);
|
||||
|
||||
HANDLE result;
|
||||
#ifdef __GNUWIN32__
|
||||
result = ShellExecute(hwndTop,
|
||||
(const wchar_t)"open",
|
||||
(const wchar_t)commandName,
|
||||
(const wchar_t)commandArgs,
|
||||
(const wchar_t)NULL,
|
||||
SW_SHOWNORMAL);
|
||||
#else // !GNUWIN32
|
||||
result = ShellExecute(hwndTop, "open", commandName,
|
||||
commandArgs, NULL, SW_SHOWNORMAL);
|
||||
#endif // GNUWIN32
|
||||
|
||||
if ( ((long)result) <= 32 )
|
||||
wxLogSysError(_("Can't execute command '%s'"), command.c_str());
|
||||
|
||||
return result;
|
||||
#else // 1
|
||||
|
||||
HANDLE h_readPipe[2];
|
||||
HANDLE h_writePipe[2];
|
||||
HANDLE h_oldreadPipe;
|
||||
HANDLE h_oldwritePipe;
|
||||
BOOL inheritHandles;
|
||||
|
||||
// ------------------------------------
|
||||
// Pipe handling
|
||||
// We are in the case of opening a pipe
|
||||
inheritHandles = FALSE;
|
||||
if (handler && handler->NeedPipe()) {
|
||||
SECURITY_ATTRIBUTES security;
|
||||
|
||||
security.nLength = sizeof(security);
|
||||
security.lpSecurityDescriptor = NULL;
|
||||
security.bInheritHandle = TRUE;
|
||||
|
||||
if (! ::CreatePipe(&h_readPipe[0], &h_readPipe[1], &security, 0) ) {
|
||||
wxLogSysError(_T("Can't create the inter-process read pipe"));
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (! ::CreatePipe(&h_writePipe[0], &h_writePipe[1], &security, 0) ) {
|
||||
wxLogSysError(_T("Can't create the inter-process read pipe"));
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
// We need to save the old stdio handles to restore them after the call
|
||||
// to CreateProcess
|
||||
h_oldreadPipe = GetStdHandle(STD_INPUT_HANDLE);
|
||||
h_oldwritePipe = GetStdHandle(STD_OUTPUT_HANDLE);
|
||||
|
||||
SetStdHandle(STD_INPUT_HANDLE, h_readPipe[0]);
|
||||
SetStdHandle(STD_OUTPUT_HANDLE, h_writePipe[1]);
|
||||
|
||||
inheritHandles = TRUE;
|
||||
}
|
||||
|
||||
// create the process
|
||||
STARTUPINFO si;
|
||||
wxZeroMemory(si);
|
||||
|
||||
si.cb = sizeof(si);
|
||||
|
||||
PROCESS_INFORMATION pi;
|
||||
|
||||
if ( ::CreateProcess(
|
||||
NULL, // application name (use only cmd line)
|
||||
(wxChar *)command.c_str(), // full command line
|
||||
NULL, // security attributes: defaults for both
|
||||
NULL, // the process and its main thread
|
||||
inheritHandles, // don't inherit handles
|
||||
CREATE_DEFAULT_ERROR_MODE |
|
||||
CREATE_SUSPENDED, // flags
|
||||
NULL, // environment (use the same)
|
||||
NULL, // current directory (use the same)
|
||||
&si, // startup info (unused here)
|
||||
&pi // process info
|
||||
) == 0 )
|
||||
{
|
||||
if (inheritHandles) {
|
||||
::CloseHandle(h_writePipe[0]);
|
||||
::CloseHandle(h_writePipe[1]);
|
||||
::CloseHandle(h_readPipe[0]);
|
||||
::CloseHandle(h_readPipe[1]);
|
||||
}
|
||||
wxLogSysError(_("Execution of command '%s' failed"), command.c_str());
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
// Restore the old stdio handles
|
||||
if (inheritHandles) {
|
||||
SetStdHandle(STD_INPUT_HANDLE, h_oldreadPipe);
|
||||
SetStdHandle(STD_OUTPUT_HANDLE, h_oldwritePipe);
|
||||
|
||||
::CloseHandle(h_writePipe[1]);
|
||||
::CloseHandle(h_readPipe[0]);
|
||||
// We can now initialize the wxStreams
|
||||
wxInputStream *processOutput = new wxPipeInputStream(h_writePipe[0]);
|
||||
wxOutputStream *processInput = new wxPipeOutputStream(h_readPipe[1]);
|
||||
|
||||
handler->SetPipeStreams(processOutput, processInput);
|
||||
}
|
||||
|
||||
// register the class for the hidden window used for the notifications
|
||||
if ( !gs_classForHiddenWindow )
|
||||
{
|
||||
gs_classForHiddenWindow = _T("wxHiddenWindow");
|
||||
|
||||
WNDCLASS wndclass;
|
||||
wxZeroMemory(wndclass);
|
||||
wndclass.lpfnWndProc = (WNDPROC)wxExecuteWindowCbk;
|
||||
wndclass.hInstance = wxGetInstance();
|
||||
wndclass.lpszClassName = gs_classForHiddenWindow;
|
||||
|
||||
if ( !::RegisterClass(&wndclass) )
|
||||
{
|
||||
wxLogLastError("RegisterClass(hidden window)");
|
||||
}
|
||||
}
|
||||
|
||||
// create a hidden window to receive notification about process
|
||||
// termination
|
||||
HWND hwnd = ::CreateWindow(gs_classForHiddenWindow, NULL,
|
||||
WS_OVERLAPPEDWINDOW,
|
||||
0, 0, 0, 0, NULL,
|
||||
(HMENU)NULL, wxGetInstance(), 0);
|
||||
wxASSERT_MSG( hwnd, wxT("can't create a hidden window for wxExecute") );
|
||||
|
||||
// Alloc data
|
||||
wxExecuteData *data = new wxExecuteData;
|
||||
data->hProcess = pi.hProcess;
|
||||
data->dwProcessId = pi.dwProcessId;
|
||||
data->hWnd = hwnd;
|
||||
data->state = sync;
|
||||
if ( sync )
|
||||
{
|
||||
wxASSERT_MSG( !handler, wxT("wxProcess param ignored for sync execution") );
|
||||
|
||||
data->handler = NULL;
|
||||
}
|
||||
else
|
||||
{
|
||||
// may be NULL or not
|
||||
data->handler = handler;
|
||||
}
|
||||
|
||||
DWORD tid;
|
||||
HANDLE hThread = ::CreateThread(NULL,
|
||||
0,
|
||||
(LPTHREAD_START_ROUTINE)wxExecuteThread,
|
||||
(void *)data,
|
||||
0,
|
||||
&tid);
|
||||
|
||||
// resume process we created now - whether the thread creation succeeded or
|
||||
// not
|
||||
if ( ::ResumeThread(pi.hThread) == (DWORD)-1 )
|
||||
{
|
||||
// ignore it - what can we do?
|
||||
wxLogLastError("ResumeThread in wxExecute");
|
||||
}
|
||||
|
||||
// close unneeded handle
|
||||
if ( !::CloseHandle(pi.hThread) )
|
||||
wxLogLastError("CloseHandle(hThread)");
|
||||
|
||||
if ( !hThread )
|
||||
{
|
||||
wxLogLastError("CreateThread in wxExecute");
|
||||
|
||||
DestroyWindow(hwnd);
|
||||
delete data;
|
||||
|
||||
// the process still started up successfully...
|
||||
return pi.dwProcessId;
|
||||
}
|
||||
|
||||
#if wxUSE_IPC
|
||||
// second part of DDE hack: now establish the DDE conversation with the
|
||||
// just launched process
|
||||
if ( !!ddeServer )
|
||||
{
|
||||
wxDDEClient client;
|
||||
wxConnectionBase *conn = client.MakeConnection(_T(""),
|
||||
ddeServer,
|
||||
ddeTopic);
|
||||
if ( !conn || !conn->Execute(ddeCommand) )
|
||||
{
|
||||
wxLogError(_("Couldn't launch DDE server '%s'."), command.c_str());
|
||||
}
|
||||
}
|
||||
#endif // wxUSE_IPC
|
||||
|
||||
if ( !sync )
|
||||
{
|
||||
// clean up will be done when the process terminates
|
||||
|
||||
// return the pid
|
||||
return pi.dwProcessId;
|
||||
}
|
||||
|
||||
// waiting until command executed (disable everything while doing it)
|
||||
#if wxUSE_GUI
|
||||
wxBeginBusyCursor();
|
||||
wxEnableTopLevelWindows(FALSE);
|
||||
#endif // wxUSE_GUI
|
||||
|
||||
while ( data->state )
|
||||
wxYield();
|
||||
|
||||
#if wxUSE_GUI
|
||||
wxEnableTopLevelWindows(TRUE);
|
||||
wxEndBusyCursor();
|
||||
#endif // wxUSE_GUI
|
||||
|
||||
DWORD dwExitCode = data->dwExitCode;
|
||||
delete data;
|
||||
|
||||
// return the exit code
|
||||
return dwExitCode;
|
||||
#endif // 0/1
|
||||
#else // Win16
|
||||
long instanceID = WinExec((LPCSTR) WXSTRINGCAST command, SW_SHOW);
|
||||
if (instanceID < 32) return(0);
|
||||
|
||||
if (sync) {
|
||||
int running;
|
||||
do {
|
||||
wxYield();
|
||||
running = GetModuleUsage((HINSTANCE)instanceID);
|
||||
} while (running);
|
||||
}
|
||||
|
||||
return(instanceID);
|
||||
#endif // Win16/32
|
||||
}
|
||||
|
||||
long wxExecute(char **argv, bool sync, wxProcess *handler)
|
||||
{
|
||||
wxString command;
|
||||
|
||||
while ( *argv != NULL )
|
||||
{
|
||||
command << *argv++ << ' ';
|
||||
}
|
||||
|
||||
command.RemoveLast();
|
||||
|
||||
return wxExecute(command, sync, handler);
|
||||
}
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// Metafile helpers
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
extern void PixelToHIMETRIC(LONG *x, LONG *y)
|
||||
{
|
||||
ScreenHDC hdcRef;
|
||||
|
||||
int iWidthMM = GetDeviceCaps(hdcRef, HORZSIZE),
|
||||
iHeightMM = GetDeviceCaps(hdcRef, VERTSIZE),
|
||||
iWidthPels = GetDeviceCaps(hdcRef, HORZRES),
|
||||
iHeightPels = GetDeviceCaps(hdcRef, VERTRES);
|
||||
|
||||
*x *= (iWidthMM * 100);
|
||||
*x /= iWidthPels;
|
||||
*y *= (iHeightMM * 100);
|
||||
*y /= iHeightPels;
|
||||
}
|
||||
|
||||
extern void HIMETRICToPixel(LONG *x, LONG *y)
|
||||
{
|
||||
ScreenHDC hdcRef;
|
||||
|
||||
int iWidthMM = GetDeviceCaps(hdcRef, HORZSIZE),
|
||||
iHeightMM = GetDeviceCaps(hdcRef, VERTSIZE),
|
||||
iWidthPels = GetDeviceCaps(hdcRef, HORZRES),
|
||||
iHeightPels = GetDeviceCaps(hdcRef, VERTRES);
|
||||
|
||||
*x *= iWidthPels;
|
||||
*x /= (iWidthMM * 100);
|
||||
*y *= iHeightPels;
|
||||
*y /= (iHeightMM * 100);
|
||||
}
|
||||
Loading…
Reference in New Issue
Block a user