Make launched process on top

BlitzMax Forums/BlitzMax Programming/Make launched process on top

JoshK

(Posted 2012) [#1]

I am using freeprocess to launch and communicate with an external EXE, but the launched window won't activate/become foreground, on top of main program window.

My launched process has window activation code like below, but it doesn't work when the process is launched from my main application:

	void Window::Activate()
	{
		BringWindowToTop(hwnd);
		SetWindowPos(hwnd,NULL,0,0,0,0,SWP_NOMOVE|SWP_NOSIZE);
		SetForegroundWindow(hwnd);
		SetActiveWindow(hwnd);
		SetFocus(hwnd);
		current = this;
	}

My main application also calls AllowSetForegroundWindow(), to try to give the launched process permission to take the foreground, but it doesn't seem to do anything:

		process=CreateProcess("~q"+procpath+"~q "+parameters)
?win32
		AllowSetForegroundWindow(process.handle)
?

How can I allow the window of my launched process to become the topmost window?

col	(Posted 2012) [#2]

Out of curiousity have you tried

SetWindowPos(hwnd,-1,0,0,0,0,SWP_NOMOVE|SWP_NOSIZE);

?

The -1 sets the window to HWND_TOPMOST.

JoshK

(Posted 2012) [#3]

Yes, but that is not the behavior I want. Even when I do, the window still gets deactivated after a few seconds, and is non-active and forced on top. I want the window to be activated and appear on top, as if I click on it.

col	(Posted 2012) [#4]

I understand.
I don't know why it would get deactivated after a few seconds though :/
I'd look into what's causing that, suspecting something in the initial process is activating the initial window again.

Other things come to mind to try -
Is it a completely fresh new window you're creating, ie no parent? Have you tried making it a child of the initial 'parent' window? If it can be a modeless window then how about using CreateDialog instead of CreateWindow(Ex)?

JoshK

(Posted 2012) [#5]

I added this to the start of my main program:

?win32
Extern "win32"
	Function AllowSetForegroundWindow:Int(process:Int)
EndExtern
AllowSetForegroundWindow(-1)
?

And it makes no difference. I also tried calling it after CreateProcess().

Last edited 2012

JoshK

(Posted 2012) [#6]

I solved this by calling AllowSetForegroundWindow(-1) directly AFTER the process is created.

I want to add this code in the pub.freeprocess module so that it creates a suspended process, calls AllowSetForegroundWindow(-1), and then resumes the process thread. I have it working except that the linker fails because it can't find the AllowSetForegroundWindow function. I included <windows.h> at the top of the freeprocess.c file, but it still doesn't work:

// freeprocess.c

#include <brl.mod/blitz.mod/blitz.h>
#include <stdio.h>

#ifdef _WIN32
	#include <Windows.h>
#endif

#define HIDECONSOLE 1

#if __APPLE__ || __linux

#include <sys/ioctl.h>
#include <unistd.h>
#include <sys/wait.h>

int fdClose(int fd) {return close(fd);}
int fdRead(int fd,char *buffer,int count) {return read(fd,buffer,count);}
int fdWrite(int fd,char *buffer,int count) {return write(fd,buffer,count);}
int fdAvail(int fd) {int avail;if (ioctl(fd,FIONREAD,&avail)) avail=avail;return avail;}
int fdFlush(int fd) {}//flush(fd);}

///return 1 for running, 0 for finished
//
int fdProcessStatus( int pid ){

	int status=0;
	return !waitpid( pid,&status,WNOHANG );
}

//returns 0 for success, -1 for error
//
int fdTerminateProcess(int pid){

	if( !killpg( pid,SIGTERM ) ){
		int status=0;
		waitpid( pid,&status,0 );
		return 0;
	}
	return -1;
}

static char **makeargv( const char *cmd ){
	int n,c;
	char *p;
	static char *args,**argv;
	
	if( args ) free( args );
	if( argv ) free( argv );
	args=(char*)malloc( strlen(cmd)+1 );
	strcpy( args,cmd );
	
	n=0;
	p=args;
	while( c=*p++ ){
		if( c==' ' ){
			continue;
		}else if( c=='\"' ){
			while( *p && *p!='\"' ) ++p;
		}else{
			while( *p && *p!=' ' ) ++p;
		}
		if( *p ) ++p;
		++n;
	}
	argv=(char**)malloc( (n+1)*sizeof(char*) );
	n=0;
	p=args;
	while( c=*p++ ){
		if( c==' ' ){
			continue;
		}else if( c=='\"' ){
			argv[n]=p;
			while( *p && *p!='\"' ) ++p;
		}else{
			argv[n]=p-1;
			while( *p && *p!=' ' ) ++p;
		}
		if( *p ) *p++=0;
		++n;
	}
	argv[n]=0;
	return argv;
}

#define PIPEREAD 0
#define PIPEWRITE 1

static int in[2],out[2],errfd[2];

int fdProcess( BBString *bbcmd,int *procin,int *procout,int *procerr,int flags)
{
	char 	*const*argv;
	int   	procid;
	
	const char *cmd=bbTmpUTF8String(bbcmd);
	
	//Set-up interprocess communication
	if (pipe(in)) return 0;
  	if (pipe(out)) return 0;
  	if (pipe(errfd)) return 0;
	
	//Fork process (returned value used to distinguish between child and parent process)
	procid=vfork();	//vfork() avoids memory overhead of fork()
	
	//Child process
	if (procid==0)
	{
		#if __linux
			setsid(); //Linux doesn't mind setsid()
		#else
			setpgid(0,0);	//but OS X doesn't like it, therefore resort to using setpgid().
		#endif
		
		dup2(out[PIPEREAD],STDIN_FILENO);
		close(out[PIPEWRITE]);
		
		dup2(in[PIPEWRITE],STDOUT_FILENO);
		close(in[PIPEREAD]);
		
		dup2(errfd[PIPEWRITE],STDERR_FILENO);		
		close(errfd[PIPEREAD]);
		
		argv=makeargv(cmd);
		execvp(argv[0],argv);
		
		_exit( -1 );
		
		return 0;	//Supposedly, we need this for some compilers.
		
	}
	
	//Parent process
	
	if(procid==-1) return 0;	//Return if child process couldn't be started.
	
	close(out[PIPEREAD]);		//Close the end of the pipes in that the child
	close(in[PIPEWRITE]);		//process is using.
	close(errfd[PIPEWRITE]);
	
	*procin=in[PIPEREAD];		//And return the end of the pipes that we should
	*procout=out[PIPEWRITE];	//be using.
	*procerr=errfd[PIPEREAD];
	
	return procid;
}

#endif

#ifdef _WIN32

extern int _bbusew;

#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#include <tlhelp32.h>

int TerminateProcessGroup(HANDLE prochandle,int procid)
{
	HANDLE snapshot,child;
	PROCESSENTRY32 procinfo;
	int gotinfo,res;

	snapshot=CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS,0);
	if (snapshot!=INVALID_HANDLE_VALUE)
	{
		procinfo.dwSize=sizeof(procinfo);
		gotinfo=Process32First(snapshot,&procinfo);
		while (gotinfo)
		{
			if (procinfo.th32ParentProcessID==procid)
			{
//				printf("process=%x parent=%x module=%x path=%s\n",procinfo.th32ProcessID,procinfo.th32ParentProcessID,procinfo.th32ModuleID,procinfo.szExeFile);
				child=OpenProcess(PROCESS_ALL_ACCESS,0,procinfo.th32ProcessID);
				if (child)
				{
					res=TerminateProcess(child,-1);
					CloseHandle(child);
				}
			}
			gotinfo=Process32Next(snapshot,&procinfo);
		}
		CloseHandle(snapshot);
	}
	res=TerminateProcess(prochandle,-1);
	return res;
}

int fdClose(int fd)
{
	return CloseHandle((HANDLE)fd);
}

int fdRead(int fd,char *buffer,int bytes)
{
	int		res; 
	long	count;
	res=ReadFile((HANDLE)fd,buffer,bytes,&count,0);
	if (res) return count;
	return 0;
}

int fdWrite(int fd,char *buffer,int bytes)
{
	int		res;
	long	count;
	res=WriteFile((HANDLE)fd,buffer,bytes,&count,0);
	if (res) return count;
	return 0;
}

int fdFlush(int fd)
{
	int		res;
	res=FlushFileBuffers((HANDLE)fd);
	return res;
}

int fdAvail(int fd) 
{
	int		res;
	long	avail;
	res=PeekNamedPipe((HANDLE)fd,0,0,0,&avail,0);
	if (res) return avail;
	return 0;
}

//Returns Win32 process handle
int fdProcessGetHandle(int pid)
{
	PROCESS_INFORMATION *pi=(PROCESS_INFORMATION *)pid;
	return (int)pi->hProcess;
}

//returns 1 for running, 0 for finished
int fdProcessStatus( int pid ){

	PROCESS_INFORMATION *pi=(PROCESS_INFORMATION *)pid;
	
	long exitcode;
	
	if( GetExitCodeProcess( pi->hProcess,&exitcode ) ){

		if( exitcode==STILL_ACTIVE ) return 1;
		
		CloseHandle( pi->hProcess );
		free( pi );
	}
	return 0;
}

//returns 0 for success
int fdTerminateProcess( int pid ){

	PROCESS_INFORMATION *pi=(PROCESS_INFORMATION *)pid;
	
	int res=TerminateProcessGroup( pi->hProcess,pi->dwProcessId );
	
	CloseHandle( pi->hProcess );
	free( pi );

	return res;
}

DWORD GetMainThreadId(DWORD pId)
{
    LPVOID lpThId;
 	
    HANDLE hProcess = OpenProcess(PROCESS_VM_READ, FALSE, pId);
    if(hProcess == NULL)
        return NULL;
 
    DWORD tId;
    if(ReadProcessMemory(hProcess, lpThId, &tId, sizeof(tId), NULL) == FALSE)
    {
        CloseHandle(hProcess);
        return NULL;
    }
 
    CloseHandle(hProcess);
 
    return tId;
}

int fdProcess( BBString *cmd,int *procin,int *procout,int *procerr,int flags)
{
	int res;
	int pflags=CREATE_NEW_PROCESS_GROUP;
	PROCESS_INFORMATION *pi;
	SECURITY_ATTRIBUTES sa={sizeof(sa),0,1};
	HANDLE istr,p_ostr;	//our in-stream, process out-stream
	HANDLE ostr,p_istr;	//our out-stream, process in-stream
	HANDLE estr,p_estr;			//our errin-stream, process errout-stream

	if( !CreatePipe( &istr,&p_ostr,&sa,0 ) ){
		//unable to create pipe
		return 0;
	}

	if( !CreatePipe( &p_istr,&ostr,&sa,0 ) ){
		CloseHandle( istr );
		CloseHandle( p_ostr );
		//ditto
		return 0;
	}

	if (!CreatePipe(&estr,&p_estr,&sa,0)) {
		CloseHandle( istr );
		CloseHandle( p_ostr );
		CloseHandle( ostr );
		CloseHandle( p_istr );
		//unable to create pipe
		return 0;
	}

	pi=(PROCESS_INFORMATION*)calloc(1,sizeof(PROCESS_INFORMATION));
	
	if( _bbusew ){
		STARTUPINFOW si={sizeof(si)};

		si.dwFlags=STARTF_USESTDHANDLES;
		si.wShowWindow=SW_HIDE;
		si.hStdInput=p_istr;
		si.hStdOutput=p_ostr;
		si.hStdError=p_estr;
		if (flags&HIDECONSOLE) {
			si.dwFlags|=STARTF_USESHOWWINDOW;
			si.wShowWindow=SW_HIDE;
		}
		else {
			pflags|=DETACHED_PROCESS;
		}
		pflags|=CREATE_SUSPENDED;
		res=CreateProcessW( 0,bbTmpWString(cmd),0,0,-1,pflags,0,0,&si,pi );
		
	}else{
		STARTUPINFO si={sizeof(si)};

		si.dwFlags=STARTF_USESTDHANDLES;
		si.wShowWindow=SW_HIDE;
		si.hStdInput=p_istr;
		si.hStdOutput=p_ostr;
		si.hStdError=p_estr;
		if (flags&HIDECONSOLE) {
			si.dwFlags|=STARTF_USESHOWWINDOW;
			si.wShowWindow=SW_HIDE;
		}
		else {
			pflags|=DETACHED_PROCESS;
		}
		pflags|=CREATE_SUSPENDED;
		res=CreateProcess( 0,bbTmpCString(cmd),0,0,-1,pflags,0,0,&si,pi );
	}
	
	if( !res ){
		CloseHandle( istr );
		CloseHandle( ostr );
		CloseHandle( estr );
		CloseHandle( p_istr );
		CloseHandle( p_ostr );
		CloseHandle( p_estr );
		return 0;
	}
	
	AllowSetForegroundWindow(-1);
	ResumeThread(pi->hThread);	
	
	CloseHandle( pi->hThread );
	
	*procin=(int)istr;
	*procout=(int)ostr;
	*procerr=(int)estr;

	CloseHandle( p_istr );
	CloseHandle( p_ostr );
	CloseHandle( p_estr );
	
	return (int)pi;
}

#endif

C:/BlitzMax/mod/pub.mod/freeprocess.mod/freeprocess.debug.win32.x86.a(freeprocess.c.debug.win32.x86.o):freeprocess.c:(.text+0x665): undefined reference to `AllowSetForegroundWindow'

Last edited 2012

col	(Posted 2012) [#7]

Swapping out that extra

#ifdef _WIN32
include <window.h>
#endif

for

extern BOOL WINAPI AllowSetForegroundWindow(DWORD dwProcessId);

should fix the linker error.

Last edited 2012

JoshK

(Posted 2012) [#8]

Thanks, here's the complete fix:
http://www.blitzmax.com/Community/posts.php?topic=99022

col	(Posted 2012) [#9]

Nice one, thanks, this will come in handy for sure.

Oh god - I just remembered! The process.handle inside BMax TProcess isn't the real cpu process id handle. It's a handle to a PROCESS_INFORMATION structure that has the real handle instance inside it. So the command may have worked from BMax, it's just it had the wrong variable given to it.

Last edited 2012