C# wrapper 2.0 - RELEASE

using System;
using System.Collections;
using AcknexWrapper;

namespace panelExampleTwo
{
    class Program
    {
        private static PANEL testPanel = null;
        private static FONT testFont = null;
        private static BMAP background = null;
        private static BMAP knob = null;

        //the main method, called by the scheduler
        private static IEnumerable myMainMethod()
        {
            double dummyVariable = 0;

            //create an empty panel
            testPanel = PANEL.pan_create(null, 0);
            //make the panel visible
            testPanel.SHOW = true;

            //create a font
            testFont = FONT.font_create("Arial#40");

            //display the dummyVariable
            testPanel.pan_setdigits(
                0,
                200,
                400,
                "dummyVariable = %2.f",
                testFont,
                1,
                () => dummyVariable);

            //create a background
            background =
                BMAP.bmap_createblack(200, 50, 128);

            //create a knob
            knob =
                BMAP.bmap_createblack(25, 25, 32);

            //make the knob white
            knob.bmap_fill(
                new Color(255, 255, 255), 100);

            dummyVariable = 75;

            //create a slider which sets the dummyVariable
            testPanel.pan_setslider(
                0,
                50,
                50,
                background,
                knob,
                0,
                100,
                (double x) => dummyVariable = x,
                null);

            //activate mouse
            EngVar.mouse_mode = 4;

            yield return 1;
        }

        static void Main(string[] args)
        {
            //open the engine
            EngFun.engine_open(null, null);

            //create/load an empty level
            EngFun.level_load(null);

            //start the scheduler
            Scheduler.StartScheduler(myMainMethod);
        }
    }
}

private void changeTextButton_Click(object sender, EventArgs e)
{
    //add this function THREAD SAFE to the scheduler
    Scheduler.AddEventVoidThreadSafe(createEntity);
}
static ENTITY dummy = null;
private IEnumerable changeText()
{
    dummy = ENTITY.ent_create("some entity", new Vector(), null);
    yield return 1;
}

private IEnumerable bla()
{
yield return 1;
}

private IEnumerable<ScheduleMethod> bla()
{
yield return 1;
//or: yield return ScheduleMethod.wait(1);
//or: yield return ScheduleMethod.waitForFrames(1);
//ALL these three calls are equivalent !
}

private IEnumerable bla()
{
yield return 1;
yield return Scheduler.PROC_MODE.PROC_EARLIEST;
yield return 1;
}

private IEnumerable<ScheduleMethod> bla()
{
yield return 1;
yield return ScheduleMethod.PROC_EARLIEST;
yield return 1;
}

After adding AW 2.21 get ERROR:

error CS0308: The non-generic type 'System.Collections.IEnumerable' cannot be used with type arguments


using:
private IEnumerable<ScheduleMethod> myMainMethod() //ERROR:
{

	//....
       //yield return 1;
       yield return ScheduleMethod.wait( 1 );

}

and:
        private IEnumerable<ScheduleMethod> SizeWindow() //ERROR:
        {
            /*wait until the form is being resized*/
            while (ResizingNow == false)
            {
                //yield return 1;
                yield return ScheduleMethod.wait( 1 );
            }
            /*change the resolution*/
            EngFun.video_window(null, new Vector((this.panel_acknexWindow.Width),
                                                  this.panel_acknexWindow.Height, 0), 0, null);
            IsChangingSize = false;   //reset flag
            //yield return 1;
            yield return ScheduleMethod.wait( 1 );
        }

private IEnumerable<ScheduleMethod> myMainMethod()
{
   //...
   while (true)
   {
      CameraFunc();

      //HeavyFunc();

      yield return ScheduleMethod.wait(1);
   }
}

void ShowEditorCam()
{
   EngVar.Camera.x += 5 * time_step;
}

class Controller
{
  public Controller()
  {
    StartGamepad();
  }

  public IEnumerable<ScheduleMethod> StartGamepad()
  {
    //do stuff
    while(true)
    {
      yield return ScheduleMethod.wait(1);
    }
  }
}

StartGamepad();

Scheduler.AddEventVoid(StartGamePad);

using System;
using System.Collections.Generic;
using AcknexWrapper;

namespace ShaderTest
{
    class Program
    {
        static void Main(string[] args)
        {
            EngFun.engine_open(null, null);

            Scheduler.StartScheduler(MyMainMethod);
        }

        private static IEnumerable<ScheduleMethod> MyMainMethod()
        {
            // load an empty level
            EngFun.level_load(null);

            // create a cube (_CUBE.mdl is a predefined model - CUBE_MDL in lite-c)
            ENTITY cube =
                ENTITY.ent_create(
                    "_CUBE.mdl",
                    new Vector(60, -20, 0),
                    CubeMethod);

            yield break;
        }

        private static IEnumerable<ScheduleMethod> CubeMethod(IntPtr p)
        {
            ENTITY cube =
                ENTITY.createFromPointer(p);

            // now assign the standard metal material
            cube.material =
                EngVar.mtl_metal;

            // change the ambient vector of the standard metal material
            EngVar.mtl_metal.ambient_red = 255;

            while (true)
            {
                // rotate the cube
                cube.pan += 2 * EngVar.time_step;
                cube.tilt += 1.5 * EngVar.time_step;

                // wait one frame
                yield return 1;
            }
        }
    }
}

class SomeClass
    {
        private string storedParameter1;
        private int storedParameter2;

        public SomeClass(string parameter1, int parameter2)
        {
            this.storedParameter1 = parameter1;
            this.storedParameter2 = parameter2;

            Scheduler.AddEventVoid(SomeFun);
        }

        private IEnumerable<ScheduleMethod> SomeFun()
        {
            Console.WriteLine(storedParameter1 + storedParameter2);
            yield break;
        }
    }

Old way:
Vector direction = new Vector(activeCCharacter.Position);
direction.vec_sub(EngVar.target);
direction.vec_normalize(5);

New Way:
Vector direction = new Vector(activeCCharacter.Position).vec_sub(EngVar.target).vec_normalize(5);

vec_set(a,vec_rotate(b,vec_normalize(c,5)));

private static IEnumerable<ScheduleMethod> onMouseLeftMethod(double value)
{
    yield return 1;
}

static void Main(string[] args)
{
    EngFun.engine_open(null, null);
    EngFun.level_load(null);

    // ....

    // register this method on the event
    EngVar.on_mouse_left += onMouseLeftMethod;

    // ....

    // unregister this method on the event
    EngVar.on_mouse_left -= onMouseLeftMethod;

    // clear all registered method on this event...
    EngVar.on_mouse_left.Events.Clear();
}

// the method to be called when the panel is clicked
    static void PanelEvent(IntPtr p)
    {
        // get the clicked panel
        PANEL thisPanel =
            PANEL.createFromPointer(p);

        // change the color of the clicked panel
        thisPanel.bmap.bmap_fill(new Color(200, 0, 0), 50);
    }

// the main method called by the scheduler
    private static IEnumerable<ScheduleMethod> MyMainMethod()
    {
        // create a red panel and make it visible...
        PANEL p =
            PANEL.pan_create(null, 24);
        
        p.SHOW = true;
        p.size_x = 100;
        p.size_y = 100;
        p.pos_x = 300;
        p.pos_y = 300;
        p.bmap =
            BMAP.bmap_createblack(100, 100, 32);
        p.bmap.bmap_fill(new Color(0, 0, 255), 50);

        // assign the method to be called when the panel is clicked..
        p.event_ =
            PanelEvent;

        // use the mouse !!
        EngVar.mouse_mode = 4;
}

// the entry point of the program
    static void Main(string[] args)
    {
        // load an empty level
        EngFun.engine_open(null, null);
        EngFun.level_load(null);

        // start the scheduler
        Scheduler.StartScheduler(MyMainMethod);
    }

// here's some sample code

        private static PANEL p;

        private static IEnumerable<ScheduleMethod> switchStateOfButtonUsingButtonState()
        {
            // first get old state... -1 means DON'T change state of the button
            double oldState =
                p.button_state(1, -1);

            // then switch the state, according to the return value
            if (oldState == 0)
            {
                // switch to on
                p.button_state(1, 1);
            }
            else
            {
                // switch to off
                p.button_state(1, 0);
            }

            yield break;
        }

        public static IEnumerable<ScheduleMethod> myMainMethod()
        {
            // use mouse !!
            EngVar.mouse_mode = 4;

            p =
                PANEL.pan_create(null, 1);
            p.SHOW = true;
            p.pos_x = 100;
            p.pos_y = 100;
            p.size_x = 500;
            p.size_y = 500;

            BMAP on =
                BMAP.bmap_createblack(200, 200, 32);
            on.bmap_fill(new Color(0, 255, 0), 50);
            BMAP off =
                BMAP.bmap_createblack(200, 200, 32);
            off.bmap_fill(new Color(0, 0, 255), 50);
            BMAP over =
                BMAP.bmap_createblack(200, 200, 32);
            over.bmap_fill(new Color(200, 200, 20), 50);

            p.pan_setbutton(
                0,
                2,
                50,
                50,
                on,
                off,
                over,
                over,
                null,
                null,
                null);

            EngVar.on_space +=
                switchStateOfButtonUsingButtonState;

            yield break;
        }

        static void Main(string[] args)
        {
            EngFun.engine_open(null, null);
            EngFun.level_load(null);

            Scheduler.StartScheduler(myMainMethod);
        }

class MyGraphic
    {
        private static void ParticleLine(PARTICLE p)
        {

        }

        public static void DrawLine3DEx(Vector AFrom, Vector ATo, Color AColor, int AAlpha, int ASize)
        {
            PARTICLE.effect(ParticleLine, 1, AFrom, ATo);
        }


    }

class MyGraphic
    {
        private static void ParticleLine(IntPtr p)
        {

        }

        public static void DrawLine3DEx(Vector AFrom, Vector ATo, Color AColor, int AAlpha, int ASize)
        {
            PARTICLE.effect(ParticleLine, 1, AFrom, ATo);
        }


    }

private static void ParticleLineEvent(IntPtr AP)
        {
            PARTICLE P = PARTICLE.createFromPointer(AP);
            P.lifespan = 0;
        }

        private static void ParticleLine(IntPtr AP)
        {
            PARTICLE P = PARTICLE.createFromPointer(AP);
            P.lifespan = 1;
            P.event_ = ParticleLineEvent;
        }

        public static void DrawLine3DEx(Vector AFrom, Vector ATo, Color AColor, int AAlpha, int ASize)
        {
            PARTICLE.effect(ParticleLine, 1, AFrom, (Vector) ATo.vec_sub(AFrom));
        }

// create a delegate for the particle method and store it, if you use instance
// methods etc... you have to store them in another way, but using only static
// methods, this should work too !
private static readonly WrapperDelegateParticle StoredDelegateForParticles = ParticleLineEvent;

private static void ParticleLineEvent(IntPtr AP)
        {
            PARTICLE P = PARTICLE.createFromPointer(AP);
            P.lifespan = 0;
        }

        private static void ParticleLine(IntPtr AP)
        {
            PARTICLE P = PARTICLE.createFromPointer(AP);
            P.lifespan = 1;
            P.event_ = ParticleLineEvent;
        }

        public static void DrawLine3DEx(Vector AFrom, Vector ATo, Color AColor, int AAlpha, int ASize)
        {
            // call the effect method, already with the stored delegate
            PARTICLE.effect(StoredDelegateForParticles, 1, AFrom, (Vector) ATo.vec_sub(AFrom));
        }

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using AcknexWrapper;

namespace Test
{
    class Program
    {
        //the main method, called by the scheduler
        private static IEnumerable<ScheduleMethod> myMainMethod()
        {
            EngFun.level_load(null);

            yield return 1;

            ENTITY terrain =             
                ENTITY.ent_createterrain(null, new Vector(100, 0, -5), 10, 10, 5);

            // wait a frame, before changing the terrain !
            yield return 1;

            CONTACT c =
                terrain.ent_getvertex(null, 7);

            c.z += 10;  // increase the vertex height
            c.v = null; // c.x,y,z was changed, instead of c.v      
            terrain.ent_setvertex(c, 7);    // update the mesh

            terrain.ent_fixnormals(0);
        }

        static void Main(string[] args)
        {
            //open the engine
            EngFun.engine_open(null, null);

            //start the scheduler
            Scheduler.StartScheduler(myMainMethod);
        }
    }
}

// we can't use default.c because there f1 - f4 are already preset with some other stuff !

#include <acknex.h>

ENTITY *demoTerrain;
ENTITY *demoModel;

void MorphTerrain()
{
	int i;
	
	for (i = 0; i < ent_status(demoTerrain, 0); i++)
	{
		CONTACT *c = ent_getvertex(demoTerrain, NULL, i);
		c.z += random(10);
		c.v = NULL;
		ent_setvertex(demoTerrain, c, i);
	}
}

void MorphModel()
{
	int i;
	
	for (i = 0; i < ent_status(demoModel, 0); i++)
	{
		CONTACT *c = ent_getvertex(demoModel, NULL, i);
		c.z += random(10);
		c.v = NULL;
		ent_setvertex(demoModel, c, i);
	}
}

void FixNormalsTerrain()
{
	ent_fixnormals(demoTerrain, 0);
}

void FixNormalsModel()
{
	ent_fixnormals(demoModel, 0);
}

void SetUpDemo()
{
	camera.x = -1676;
	camera.y = 432;
	camera.z = 1126;
	camera.pan = 0;
	camera.tilt = -35;
	
	BMAP *grey = bmap_createblack(512, 512, 24);
	bmap_fill(grey, vector(128,128,128), 100);
	demoTerrain = ent_createterrain(grey, vector(0,0,0), 16, 16, 64);
	
	demoModel = ent_create("plane.mdl", vector(0, 1040, 0), NULL);
}

int main()
{
	mouse_mode = 4;
	mouse_pointer = 2;
	mouse_sync = 1;
	video_switch(10, 32, 2);
	wait(1);
	level_load(NULL);
	sun_light = 100;
	sun_pos.x = 80;
	sun_pos.y = 154;
	sun_pos.z = 0;
	SetUpDemo();
	
	on_f1 = MorphTerrain;
	on_f2 = FixNormalsTerrain;
	on_f3 = MorphModel;
	on_f4 = FixNormalsModel;
}

Vector temp = new Vector(2, 3, 4);
entity.xyz = temp;

temp.x = 2000;

// I would expect entity.x now to be 2000 ! but it wouldn't be that way !

EngFun.video_window(null, null, 256, null);
EngFun.video_set(panelEngine.Width,panelEngine.Height,0,0);
EngVar.hWndTarget = panelEngine.Handle;
EngVar.hWndParent = this.Handle;

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using AcknexWrapper;

namespace eventExample
{
    class Program
    {
        private static IEnumerable<ScheduleMethod> testEntity2Method(IntPtr e)
        {
            ENTITY me =
                ENTITY.createFromPointer(e);
            Vector originalPos =
                new Vector(me.xyz);
            double originalYPos =
                me.y;

            // cube should be red
            me.LIGHT = true;
            me.red = 255;
            me.blue = 0;
            me.green = 0;
            me.lightrange = 0;

            // low push value
            me.push = 10;

            double timeValue = 0;
            double newYForce;
            
            while (true)
            {
                // increase by 1 every second and limit to 0...1.999
                timeValue += EngVar.time_step / 16;
                timeValue %= 2;

                if (timeValue > 1.5)
                {
                    // 1/4 of time, move away
                    newYForce = 2.5 * EngVar.time_step;
                }
                else
                {
                    // 3/4 of time move to cube -> to cause an impact !
                    newYForce = -2.5 * EngVar.time_step;
                }

                // c_move to new position to trigger impact event !
                me.c_move(
                    new Vector(0, newYForce, 0),
                    new Vector(0, 0, 0),
                    Flags.GLIDE);

                yield return 1;
            }
        }

        private static IEnumerable<ScheduleMethod> testEntityMethodEvent()
        {
            if (EngVar.event_type == Flags.EVENT_CLICK)
            {
                Console.WriteLine("Flags.EVENT_CLICK");
            }
            if (EngVar.event_type == Flags.EVENT_IMPACT)
            {
                Console.WriteLine("Flags.EVENT_IMPACT");
            }
            if (EngVar.event_type == Flags.EVENT_FRAME)
            {
                Console.WriteLine("Flags.EVENT_FRAME");
            }

            // there's nothing to wait for...
            yield break;
        }

        private static IEnumerable<ScheduleMethod> testEntityMethod(IntPtr e)
        {
            ENTITY me =
                ENTITY.createFromPointer(e);

            // cube should be blue
            me.LIGHT = true;
            me.red = 0;
            me.blue = 255;
            me.green = 0;
            me.lightrange = 0;

            // enable some events...
            me.ENABLE_FRAME = true;
            me.ENABLE_IMPACT = true;
            me.ENABLE_CLICK = true;

            // high push value
            me.push = 1000;

            me.event_ = testEntityMethodEvent;

            // nothing to wait for here...
            yield break;
        }
 
        //the main method, called by the scheduler
        private static IEnumerable<ScheduleMethod> myMainMethod()
        {
            // limit frame rate
            EngVar.fps_max = 60;

            // load an empty level
            EngFun.level_load(null);

            // use mouse
            EngVar.mouse_mode = 4;

            ENTITY testEntity =
                ENTITY.ent_create("_CUBE.MDL", new Vector(200, -25, 0), testEntityMethod);

            ENTITY testEntity2 =
                ENTITY.ent_create("_CUBE.MDL", new Vector(200, 25, 0), testEntity2Method);
 
            yield return ScheduleMethod.wait(1);
        }

        static void Main(string[] args)
        {
            //open the engine
            EngFun.engine_open(null, null);

            //start the scheduler
            Scheduler.StartScheduler(myMainMethod);
        }
    }
}

BMAP someBmap = BMAP.bmap_create("someBmap.bmp");

AcknexWrapper.Native.NativeBMAP nativeBmapStruct =
    (AcknexWrapper.Native.NativeBMAP)System.Runtime.InteropServices.Marshal.PtrToStructure(someBmap.getIntPtr(), typeof(AcknexWrapper.Native.NativeBMAP));

IntPtr final_bits = nativeBmapStruct.finalbits;

IntPtr newFinalBitsValue = (IntPtr)234234;
IntPtr positionOfFinalBitsInStruct =
  System.Runtime.InteropServices.Marshal.OffsetOf(typeof(AcknexWrapper.Native.NativeBMAP), "finalbits");

// destination to write to = the pointer to the struct in unmanaged memory + the offset of the finalbits variable in the struct
IntPtr positionToWriteTo =
  (IntPtr)(
    (int)someBmap.getIntPtr() +
    (int)positionOfFinalBitsInStruct);
            
// write the new value to the position in the memory where the finalbit part of the
// struct is stored
System.Runtime.InteropServices.Marshal.WriteIntPtr(positionToWriteTo, newFinalBitsValue);

typedef struct BMAP {
...
void	*finalbits;	// bitmap content when locked, otherwise NULL
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using AcknexWrapper;

namespace eventExample
{
    using AcknexWrapper.Native;
    using System.Runtime.InteropServices;

    public static class FinalBit
    {
        public static IntPtr GetFinalBit(BMAP toGetFinalBitOf)
        {
            NativeBMAP nativeBmapStruct =
                (NativeBMAP)Marshal.PtrToStructure(
                    toGetFinalBitOf.getIntPtr(),
                    typeof(NativeBMAP));

            return
                nativeBmapStruct.finalbits;
        }

        public static void SetFinalBit(BMAP toSetFinalBitOf, IntPtr valueToSet)
        {
            IntPtr positionOfFinalBitsInStruct =
              Marshal.OffsetOf(typeof(NativeBMAP), "finalbits");

            // destination to write to = the pointer to the struct in unmanaged memory + the offset of the finalbits variable in the struct
            IntPtr positionToWriteTo =
              (IntPtr)(
                (int)toSetFinalBitOf.getIntPtr() +
                (int)positionOfFinalBitsInStruct);

            // write the new value to the position in the memory where the finalbit part of the
            // struct is stored
            Marshal.WriteIntPtr(
                positionToWriteTo,
                valueToSet);
        }
    }


    class Program
    { 
        //the main method, called by the scheduler
        private static IEnumerable<ScheduleMethod> myMainMethod()
        {
            // limit frame rate
            EngVar.fps_max = 60;

            // load an empty level
            EngFun.level_load(null);

            BMAP bla =
                BMAP.bmap_createblack(300, 300, 32);

            // print current value
            Console.WriteLine(FinalBit.GetFinalBit(bla));

            // change the finalbit value
            FinalBit.SetFinalBit(bla, (IntPtr)12345);

            // print current value
            Console.WriteLine(FinalBit.GetFinalBit(bla));

            yield return ScheduleMethod.wait(1);
        }

        static void Main(string[] args)
        {
            //open the engine
            EngFun.engine_open(null, null);

            //start the scheduler
            Scheduler.StartScheduler(myMainMethod);
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using AcknexWrapper;

namespace eventExample
{
    using AcknexWrapper.Native;
    using System.Runtime.InteropServices;

    public static class FinalBit
    {
        private static IntPtr GetPointerToFinalBit(BMAP bitmap)
        {
            return
                (IntPtr)(
                    (int)bitmap.getIntPtr() +
                    (int)Marshal.OffsetOf(typeof(NativeBMAP), "finalbits"));
        }

        public static IntPtr GetValue(BMAP bmap)
        {
            return
                Conversion.getIntPtrFromIntPtr(
                    FinalBit.GetPointerToFinalBit(bmap));
        }

        public static void SetValue(BMAP bmap, IntPtr value)
        {
            Conversion.setIntPtrFromIntPtr(
                FinalBit.GetPointerToFinalBit(bmap),
                value);
        }
    }

    class Program
    { 
        //the main method, called by the scheduler
        private static IEnumerable<ScheduleMethod> myMainMethod()
        {
            // limit frame rate
            EngVar.fps_max = 60;

            // load an empty level
            EngFun.level_load(null);

            yield return 1;

            BMAP bla =
                BMAP.bmap_createblack(300, 300, 32);

            // print current value
            Console.WriteLine(FinalBit.GetValue(bla));

            // change the finalbit to Zero and storing the current value
            IntPtr currentFinalBitValue =
                FinalBit.GetValue(bla);
            FinalBit.SetValue(bla, IntPtr.Zero);

            // print current value
            Console.WriteLine(FinalBit.GetValue(bla));

            // change the finalbit from Zero to the stored value
            FinalBit.SetValue(bla, currentFinalBitValue);

            // print current value
            Console.WriteLine(FinalBit.GetValue(bla));

            yield return ScheduleMethod.wait(1);
        }

        static void Main(string[] args)
        {
            //open the engine
            EngFun.engine_open(null, null);

            //start the scheduler
            Scheduler.StartScheduler(myMainMethod);
        }
    }
}

extern "C" __declspec(dllexport) void setFinalBits(BMAP* bmap,byte* data,int size)
{
	bmap_lock(bmap,0);
	memcpy(bmap->finalbits,data,size);
	bmap_unlock(bmap);
}

namespace AcknexWrapper
{
    namespace Native
    {
        [StructLayout(LayoutKind.Sequential)]
        internal struct NativeBMAP
        {
            public NativeC_LINK link;
            public int width, height;
            public int bytespp;
            public IntPtr ptr;
            public IntPtr pixels;
            public int flags;
            public IntPtr d3dtex;
            public double u1, v1, u2, v2;
            public int u, v;
            public int refcount;
            public int finalwidth, finalheight, finalbytespp;
            public int pitch, finalpitch;
            public int miplevels;
            public int finalformat;
            public IntPtr finalbits;
        }
    }
}

namespace AcknexWrapper
{
    namespace Native
    {
        [StructLayout(LayoutKind.Sequential)]
        internal struct NativeBMAP
        {
            public NativeC_LINK link;
            public int width, height;
            public int bytespp;
            public IntPtr ptr;
            public IntPtr pixels;
            public int flags;
            public IntPtr d3dtex;
            public float u1, v1, u2, v2;
            public int u, v;
            public int refcount;
            public int finalwidth, finalheight, finalbytespp;
            public int pitch, finalpitch;
            public int miplevels;
            public int finalformat;
            public IntPtr finalbits;
        }
    }
}

// skill1 == skills[0] - compare to Gamestudio Manual skill1 ... skill100 entry !
tempEntity.skill75 = 71;
Console.WriteLine(tempEntity.skill75);
Console.WriteLine(tempEntity.skills[74]);

tempEntity.skills[74] = 17;
Console.WriteLine(tempEntity.skill75);
Console.WriteLine(tempEntity.skills[74]);

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using AcknexWrapper;

namespace ButtonExample
{
    class Program
    {
        private static BMAP button1On;
        private static BMAP button1Off;
        private static BMAP button1Over;
        private static PANEL mainPanel;

        private static IEnumerable<ScheduleMethod> buttonClick(double p)
        {
            Console.Write("button clicked");
            yield break;
        }

        private static IEnumerable<ScheduleMethod> buttonLeave(double p)
        {
            Console.WriteLine("mouse left button");
            yield break;
        }

        private static IEnumerable<ScheduleMethod> buttonOver(double p)
        {
            Console.WriteLine("mouse is over the button");
            yield break;
        }

        private static void CreatePushButton()
        {
            // create BMAPS for button (and change their color)
            Program.button1On =
                BMAP.bmap_createblack(200, 200, 32);
            Program.button1Off =
                BMAP.bmap_createblack(200, 200, 32);
            Program.button1Over =
                BMAP.bmap_createblack(200, 200, 32);

            Program.button1On.bmap_fill(new Color(200, 0, 0), 100);
            Program.button1Off.bmap_fill(new Color(100, 0, 0), 100);
            Program.button1Over.bmap_fill(new Color(150, 0, 0), 100);

            // create a button in the panel
            Program.mainPanel.pan_setbutton(
                0,
                1,
                50,
                50,
                Program.button1On,
                Program.button1Off,
                Program.button1Over,
                Program.button1On,
                Program.buttonClick,
                Program.buttonLeave,
                Program.buttonOver);
        }

        //the main method, called by the scheduler
        private static IEnumerable<ScheduleMethod> myMainMethod()
        {
            // create the main panel and make it visible
            Program.mainPanel =
                PANEL.pan_create(null, 1);
            Program.mainPanel.SHOW = true;
            Program.mainPanel.size_x = EngVar.screen_size.x;
            Program.mainPanel.size_y = EngVar.screen_size.y;

            // Shows how to create a simple push button and assign functions to it
            Program.CreatePushButton();

            // use mouse !!
            EngVar.mouse_mode = 4;

            yield break;
        }

        static void Main(string[] args)
        {
            //open the engine
            EngFun.engine_open(null, null);

            //start the scheduler
            Scheduler.StartScheduler(myMainMethod);
        }
    }
}