A while ago I showed you how to access Acknex with C# and C++.

Today I will show you, how you can host your Acknex or Lite-C Application inside a Windows Forms Application.

First at all we need some function from the user32.dll, here are three of them:

Code:

---

  
internal static class Win32
{
[DllImport("user32.dll", SetLastError = true)]
        public static extern long SetParent(IntPtr hWndChild, IntPtr hWndNewParent);

[DllImport("user32.dll", EntryPoint = "SetWindowLongA", SetLastError = true)]
        public static extern long SetWindowLong(IntPtr hwnd, int nIndex, long dwNewLong);

[DllImport("user32.dll", SetLastError = true)]
        public static extern bool MoveWindow(IntPtr hwnd, int x, int y, int cx, int cy, bool repaint);

public const int GWL_STYLE = (-16);
public const int WS_VISIBLE = 0x10000000;
}

---

SetParent is required to change the MainWindowHandle of Acknex.
SetWindowLong is required to change the Style of the window.
and MoveWindow is required to move and resize the window.

The next step is to create a new WinForms Control, though a Panel on a Form would be enough as well.

Now we have to start the process and to change its window handle.

First at all we create a new process and start it. Then we wait until our new process enters an idle state and copy the window handle of the process to a IntPtr handle in our class.

The last step is to change the window handle, we call our SetParent function from our user32.dll interface and change it. MoveWindow resizes the window and moves it to a 0,0 position so it is fully visible.

Code:

---

 
if (!mCreated)
            {
                mCreated = true;

                mAppWnd = IntPtr.Zero;

                Process p = null;

                try
                {
                    p = Process.Start("acknex.exe", "work/mandelbrot_pure.c");

                    p.WaitForInputIdle();

                    mAppWnd = p.MainWindowHandle;

                    Win32.SetParent(mAppWnd, this.Handle);

                    Win32.SetWindowLong(mAppWnd, deWin32.GWL_STYLE, deWin32.WS_VISIBLE);

                    Win32.MoveWindow(mAppWnd, 0, 0, this.Width, this.Height, true);
                }
                catch(Exception ex)
                {
                    MessageBox.Show(ex.Message, "Our Application", MessageBoxButtons.OK, MessageBoxIcon.Error);
                } 
            }
 

---

And here a screenshot:

Screenshot

This works with basically every other application, too.

Michael

edit: I recommend you to add Thread.Sleep(TimeSpan.FromSeconds(1)) after p.WaitForInputIdle() to avoid an engine crash.

Looks nice

Thanks,

I tested some of the other examples, too. Here are the results:

OpenGL example:


Physics example

Sorry for the bad quality of the physics example, but I forgot to change the resolution.

Michael

How about native?

JCL recently pointed me towards this, and we discussed its implementation a little.
http://manual.conitec.net/hWndTarget.htm

It's only available in A6 betas and the current liteC though. Hopefully it comes through to release soon (pokes JCL).

C++
Code:

---

ev = engine_open(cmdline);
*ev->d3d_lockable = _VAR(1);
engine_frame();
ev->hWndTarget = hWnd; // hWnd = target window

---

C# (some utility functions not included here, see my other post in higher languages for C# wrapper snippets)
Code:

---

IntPtr evPtr = engine_open(cmdline, 0);
EngineVars ev = Marshal.PtrToStructure(evPtr, typeof(EngineVars));
ev.d3d_lockable.SetValue(1);
engine_frame();
ev.hWnd.SetValue(hWnd); //(pass IntPtr Handle of the window/control as hWnd)

---

-Rhuarc

Yes, that's the better way indeed.