public SQLFieldMapping(string field, string propertyname, Delegates.ReadValue reader)
{
this.Table = string.Empty;
this.Field = field;
this.PropertyName = propertyname;
this.Reader = reader;
}
public void DelegateFromSaticMethod()
{
Delegates target = new Delegates();
Int32Action action = new Int32Action(Delegates.StaticRob);
action.Invoke(7);
}
public SearchRouteArgs(Delegates.UpdateInformationAboutSearching delegateToUpdatingInformationAboutSearching,
Delegates.DeliverResults delegateToDeliverResultsToView, SearchArgs userSearchArgs)
{
DelegateToUpdatingInformationAboutSearching = delegateToUpdatingInformationAboutSearching;
UserSearchArgs = userSearchArgs;
DelegateToDeliverResultsToView = delegateToDeliverResultsToView;
}
/// <summary>
/// Gets the bus lines.
/// </summary>
/// <returns>List of bus lines</returns>
public List<Line> GetBusLines(Delegates.UpdateInformationAboutProgresForTheUser updateDelegate)
{
string indexSite = _htmlSitePath;
List<Line> lines = new List<Line>();
List<string>[] linksAndNames;
HtmlDocument doc = new HtmlDocument();
// preparing html document
StreamReader reader = new StreamReader(WebRequest.Create(_htmlSitePath).GetResponse().GetResponseStream(), Encoding.UTF8); //put your encoding
doc.Load(reader);
linksAndNames = CollectLinesLinksAndNamesFromIndexSite(doc);
try
{
for (int i = 0; i < linksAndNames[0].Count; ++i)
{
NavigateTo(indexSite);
ChangeSite(linksAndNames[0][i]);
// from line tracks site
Line tmpline = GetBusLine(_htmlSitePath, linksAndNames[1][i]);
updateDelegate((double)(i * 100.0 / linksAndNames[0].Count));
if (tmpline != null)
lines.Add(tmpline);
}
}
catch
{
return null;
}
return lines;
}
public AS(Dictionary<string, ITlPlugin> plugins, Delegates.AcreCall<AnimeEntry[]> saveproc, Delegates.AcreCall<AnimeEntry> manualupdate)
{
this.plugins = plugins;
this.manualupdate = manualupdate;
proc = saveproc;
InitializeComponent();
}
public Square(Delegates.SelectCharacter characterPass, int X, int Y)
{
this.X = X;
this.Y = Y;
PassCharacter += characterPass;
this.MouseLeftButtonDown += selectCharacter;
this.MouseRightButtonDown += r_GMContextMenu;
}
public void SingleDelegateMethodFromMethod()
{
Delegates target = new Delegates("John");
Int32Action action = new Int32Action(target.RandomRob);
action.Invoke(5);
action(6);
}
public VariableValueBus(Delegates.Function<string, string> variableValueGetter, string[] suppresedVariables)
{
if (variableValueGetter == null)
throw new ArgumentNullException("Variable value getter method is required.");
this.variableValueGetter = variableValueGetter;
foreach (string varName in suppresedVariables)
this.suppresedVariables.Add(varName, varName);
}
public static bool InstanceDelegateWithStruct() {
Delegates delegates = new Delegates();
SimpleStruct simpleStruct = new SimpleStruct();
simpleStruct.i = 2;
simpleStruct.j = 3;
StructDel sd = new StructDel(delegates.StructAsArgument);
int result = sd(simpleStruct);
return result == 5 ? true : false;
}
public Serveur(int Port, Delegates.WriteLineDelegate WriteLine, Delegates.WriteDelegate Write)
{
this.Port = Port;
Running = false;
game = new Game1(this,WriteLine);
CliManagement = new ClientsManagement(new ServeurListener(Port),WriteLine,Write);
this.WriteLineDelegate = WriteLine;
}
public void BindCommandHandlers(Delegates.HookCommandDelegate remotingCommand)
{
try
{
remoteControl.BindCommandHandler(remotingCommand);
}
catch (Exception ex)
{
Tools.Instance.Logger.LogError(ex.ToString());
}
}
public ClientsManagement(ServeurListener ServListener, Delegates.WriteLineDelegate WriteLine, Delegates.WriteDelegate Write)
{
this.WriteLineDelegate = WriteLine;
this.WriteDelegate = Write;
this.ConexionState = true;
this.ServListener = ServListener;
ServListener.ClientConnected += new ServeurListener.ClientConnectedEventHandler(ServListener_ClientConnected);
Client_List = new Dictionary<string, Client>();
ClientMsg_Queue = new Queue<NetMessage>();
}
public static IntPtr CreateStreamKHR(IntPtr dpy, int[] attrib_list)
{
IntPtr retValue;
unsafe
{
fixed(int *p_attrib_list = attrib_list)
{
Debug.Assert(Delegates.peglCreateStreamKHR != null, "peglCreateStreamKHR not implemented");
retValue = Delegates.peglCreateStreamKHR(dpy, p_attrib_list);
LogCommand("eglCreateStreamKHR", retValue, dpy, attrib_list);
}
}
DebugCheckErrors(retValue);
return(retValue);
}
public static bool QueryStreamKHR(IntPtr dpy, IntPtr stream, uint attribute, UInt64[] value)
{
bool retValue;
unsafe
{
fixed(UInt64 *p_value = value)
{
Debug.Assert(Delegates.peglQueryStreamu64KHR != null, "peglQueryStreamu64KHR not implemented");
retValue = Delegates.peglQueryStreamu64KHR(dpy, stream, attribute, p_value);
LogCommand("eglQueryStreamu64KHR", retValue, dpy, stream, attribute, value);
}
}
DebugCheckErrors(retValue);
return(retValue);
}
public static IntPtr CreateAssociatedContextAttribsAMD(UInt32 id, IntPtr share_context, int[] attribList)
{
IntPtr retValue;
unsafe
{
fixed(int *p_attribList = attribList)
{
Debug.Assert(Delegates.pglXCreateAssociatedContextAttribsAMD != null, "pglXCreateAssociatedContextAttribsAMD not implemented");
retValue = Delegates.pglXCreateAssociatedContextAttribsAMD(id, share_context, p_attribList);
LogCommand("glXCreateAssociatedContextAttribsAMD", retValue, id, share_context, attribList);
}
}
DebugCheckErrors(retValue);
return(retValue);
}
public static int GetFBConfigAttribSGIX(IntPtr dpy, IntPtr config, int attribute, [Out] int[] value)
{
int retValue;
unsafe
{
fixed(int *p_value = value)
{
Debug.Assert(Delegates.pglXGetFBConfigAttribSGIX != null, "pglXGetFBConfigAttribSGIX not implemented");
retValue = Delegates.pglXGetFBConfigAttribSGIX(dpy, config, attribute, p_value);
LogCommand("glXGetFBConfigAttribSGIX", retValue, dpy, config, attribute, value);
}
}
DebugCheckErrors(retValue);
return(retValue);
}
public static IntPtr GetPlatformDisplay(uint platform, IntPtr native_display, IntPtr[] attrib_list)
{
IntPtr retValue;
unsafe
{
fixed(IntPtr *p_attrib_list = attrib_list)
{
Debug.Assert(Delegates.peglGetPlatformDisplay != null, "peglGetPlatformDisplay not implemented");
retValue = Delegates.peglGetPlatformDisplay(platform, native_display, p_attrib_list);
LogCommand("eglGetPlatformDisplay", retValue, platform, native_display, attrib_list);
}
}
DebugCheckErrors(retValue);
return(retValue);
}
public static bool StreamConsumerReleaseAttribKHR(IntPtr dpy, IntPtr stream, IntPtr[] attrib_list)
{
bool retValue;
unsafe
{
fixed(IntPtr *p_attrib_list = attrib_list)
{
Debug.Assert(Delegates.peglStreamConsumerReleaseAttribKHR != null, "peglStreamConsumerReleaseAttribKHR not implemented");
retValue = Delegates.peglStreamConsumerReleaseAttribKHR(dpy, stream, p_attrib_list);
LogCommand("eglStreamConsumerReleaseAttribKHR", retValue, dpy, stream, attrib_list);
}
}
DebugCheckErrors(retValue);
return(retValue);
}
public static bool GetSyncAttrib(IntPtr dpy, IntPtr sync, int attribute, [Out] IntPtr[] value)
{
bool retValue;
unsafe
{
fixed(IntPtr *p_value = value)
{
Debug.Assert(Delegates.peglGetSyncAttrib != null, "peglGetSyncAttrib not implemented");
retValue = Delegates.peglGetSyncAttrib(dpy, sync, attribute, p_value);
LogCommand("eglGetSyncAttrib", retValue, dpy, sync, attribute, value);
}
}
DebugCheckErrors(retValue);
return(retValue);
}
public static UInt32 EnumerateVideoCaptureDevicesNV(IntPtr hDc, IntPtr[] phDeviceList)
{
UInt32 retValue;
unsafe
{
fixed(IntPtr *p_phDeviceList = phDeviceList)
{
Debug.Assert(Delegates.pwglEnumerateVideoCaptureDevicesNV != null, "pwglEnumerateVideoCaptureDevicesNV not implemented");
retValue = Delegates.pwglEnumerateVideoCaptureDevicesNV(hDc, p_phDeviceList);
LogCommand("wglEnumerateVideoCaptureDevicesNV", retValue, hDc, phDeviceList);
}
}
DebugCheckErrors(retValue);
return(retValue);
}
public static int EnumerateVideoDevicesNV(IntPtr hDC, IntPtr[] phDeviceList)
{
int retValue;
unsafe
{
fixed(IntPtr *p_phDeviceList = phDeviceList)
{
Debug.Assert(Delegates.pwglEnumerateVideoDevicesNV != null, "pwglEnumerateVideoDevicesNV not implemented");
retValue = Delegates.pwglEnumerateVideoDevicesNV(hDC, p_phDeviceList);
LogFunction("wglEnumerateVideoDevicesNV(0x{0}, {1}) = {2}", hDC.ToString("X8"), LogValue(phDeviceList), retValue);
}
}
DebugCheckErrors(retValue);
return(retValue);
}
public static IntPtr CreateGLXPbufferSGIX(IntPtr dpy, IntPtr config, UInt32 width, UInt32 height, int[] attrib_list)
{
IntPtr retValue;
unsafe
{
fixed(int *p_attrib_list = attrib_list)
{
Debug.Assert(Delegates.pglXCreateGLXPbufferSGIX != null, "pglXCreateGLXPbufferSGIX not implemented");
retValue = Delegates.pglXCreateGLXPbufferSGIX(dpy, config, width, height, p_attrib_list);
LogCommand("glXCreateGLXPbufferSGIX", retValue, dpy, config, width, height, attrib_list);
}
}
DebugCheckErrors(retValue);
return(retValue);
}
public static bool QueryCurrentContextNV(int iAttribute, int[] piValue)
{
bool retValue;
unsafe
{
fixed(int *p_piValue = piValue)
{
Debug.Assert(Delegates.pwglQueryCurrentContextNV != null, "pwglQueryCurrentContextNV not implemented");
retValue = Delegates.pwglQueryCurrentContextNV(iAttribute, p_piValue);
LogFunction("wglQueryCurrentContextNV({0}, {1}) = {2}", iAttribute, LogValue(piValue), retValue);
}
}
DebugCheckErrors(retValue);
return(retValue);
}
public static bool SwapBuffersWithDamageKHR(IntPtr dpy, IntPtr surface, int[] rects, int n_rects)
{
bool retValue;
unsafe
{
fixed(int *p_rects = rects)
{
Debug.Assert(Delegates.peglSwapBuffersWithDamageKHR != null, "peglSwapBuffersWithDamageKHR not implemented");
retValue = Delegates.peglSwapBuffersWithDamageKHR(dpy, surface, p_rects, n_rects);
LogCommand("eglSwapBuffersWithDamageKHR", retValue, dpy, surface, rects, n_rects);
}
}
DebugCheckErrors(retValue);
return(retValue);
}
public static IntPtr CreatePlatformPixmapSurface(IntPtr dpy, IntPtr config, IntPtr native_pixmap, IntPtr[] attrib_list)
{
IntPtr retValue;
unsafe
{
fixed(IntPtr *p_attrib_list = attrib_list)
{
Debug.Assert(Delegates.peglCreatePlatformPixmapSurface != null, "peglCreatePlatformPixmapSurface not implemented");
retValue = Delegates.peglCreatePlatformPixmapSurface(dpy, config, native_pixmap, p_attrib_list);
LogCommand("eglCreatePlatformPixmapSurface", retValue, dpy, config, native_pixmap, attrib_list);
}
}
DebugCheckErrors(retValue);
return(retValue);
}
public static IntPtr VDPAURegisterOutputSurfaceNV(IntPtr vdpSurface, int target, uint[] textureNames)
{
IntPtr retValue;
unsafe
{
fixed(uint *p_textureNames = textureNames)
{
Debug.Assert(Delegates.pglVDPAURegisterOutputSurfaceNV != null, "pglVDPAURegisterOutputSurfaceNV not implemented");
retValue = Delegates.pglVDPAURegisterOutputSurfaceNV(vdpSurface, target, textureNames.Length, p_textureNames);
LogCommand("glVDPAURegisterOutputSurfaceNV", retValue, vdpSurface, target, textureNames.Length, textureNames);
}
}
DebugCheckErrors(retValue);
return(retValue);
}
public static IntPtr CreateSync(IntPtr dpy, uint type, IntPtr[] attrib_list)
{
IntPtr retValue;
unsafe
{
fixed(IntPtr *p_attrib_list = attrib_list)
{
Debug.Assert(Delegates.peglCreateSync != null, "peglCreateSync not implemented");
retValue = Delegates.peglCreateSync(dpy, type, p_attrib_list);
LogCommand("eglCreateSync", retValue, dpy, type, attrib_list);
}
}
DebugCheckErrors(retValue);
return(retValue);
}
public static bool QueryVideoCaptureDeviceNV(IntPtr hDc, IntPtr hDevice, int iAttribute, int[] piValue)
{
bool retValue;
unsafe
{
fixed(int *p_piValue = piValue)
{
Debug.Assert(Delegates.pwglQueryVideoCaptureDeviceNV != null, "pwglQueryVideoCaptureDeviceNV not implemented");
retValue = Delegates.pwglQueryVideoCaptureDeviceNV(hDc, hDevice, iAttribute, p_piValue);
LogCommand("wglQueryVideoCaptureDeviceNV", retValue, hDc, hDevice, iAttribute, piValue);
}
}
DebugCheckErrors(retValue);
return(retValue);
}
public static IntPtr CreateImageKHR(IntPtr dpy, IntPtr ctx, uint target, IntPtr buffer, int[] attrib_list)
{
IntPtr retValue;
unsafe
{
fixed(int *p_attrib_list = attrib_list)
{
Debug.Assert(Delegates.peglCreateImageKHR != null, "peglCreateImageKHR not implemented");
retValue = Delegates.peglCreateImageKHR(dpy, ctx, target, buffer, p_attrib_list);
LogFunction("eglCreateImageKHR(0x{0}, 0x{1}, {2}, 0x{3}, {4}) = {5}", dpy.ToString("X8"), ctx.ToString("X8"), target, buffer.ToString("X8"), LogValue(attrib_list), retValue.ToString("X8"));
}
}
DebugCheckErrors(retValue);
return(retValue);
}
public static bool BindVideoDeviceNV(IntPtr hDC, UInt32 uVideoSlot, IntPtr hVideoDevice, int[] piAttribList)
{
bool retValue;
unsafe
{
fixed(int *p_piAttribList = piAttribList)
{
Debug.Assert(Delegates.pwglBindVideoDeviceNV != null, "pwglBindVideoDeviceNV not implemented");
retValue = Delegates.pwglBindVideoDeviceNV(hDC, uVideoSlot, hVideoDevice, p_piAttribList);
LogFunction("wglBindVideoDeviceNV(0x{0}, {1}, 0x{2}, {3}) = {4}", hDC.ToString("X8"), uVideoSlot, hVideoDevice.ToString("X8"), LogValue(piAttribList), retValue);
}
}
DebugCheckErrors(retValue);
return(retValue);
}
public static IntPtr CreateImage(IntPtr dpy, IntPtr ctx, uint target, IntPtr buffer, IntPtr[] attrib_list)
{
IntPtr retValue;
unsafe
{
fixed(IntPtr *p_attrib_list = attrib_list)
{
Debug.Assert(Delegates.peglCreateImage != null, "peglCreateImage not implemented");
retValue = Delegates.peglCreateImage(dpy, ctx, target, buffer, p_attrib_list);
LogCommand("eglCreateImage", retValue, dpy, ctx, target, buffer, attrib_list);
}
}
DebugCheckErrors(retValue);
return(retValue);
}
public static IntPtr CreateStreamSyncNV(IntPtr dpy, IntPtr stream, uint type, int[] attrib_list)
{
IntPtr retValue;
unsafe
{
fixed(int *p_attrib_list = attrib_list)
{
Debug.Assert(Delegates.peglCreateStreamSyncNV != null, "peglCreateStreamSyncNV not implemented");
retValue = Delegates.peglCreateStreamSyncNV(dpy, stream, type, p_attrib_list);
LogCommand("eglCreateStreamSyncNV", retValue, dpy, stream, type, attrib_list);
}
}
DebugCheckErrors(retValue);
return(retValue);
}
public static bool Query(IntPtr dpy, int[] errorb, int[] @event)
{
bool retValue;
unsafe
{
fixed(int *p_errorb = errorb)
fixed(int *p_event = @event)
{
Debug.Assert(Delegates.pglXQueryExtension != null, "pglXQueryExtension not implemented");
retValue = Delegates.pglXQueryExtension(dpy, p_errorb, p_event);
LogFunction("glXQueryExtension(0x{0}, {1}, {2}) = {3}", dpy.ToString("X8"), LogValue(errorb), LogValue(@event), retValue);
}
}
return(retValue);
}
public static Int32 GetTransparentIndexSUN(IntPtr dpy, IntPtr overlay, IntPtr underlay, [Out] long [] pTransparentIndex)
{
Int32 retValue;
unsafe
{
fixed(long *p_pTransparentIndex = pTransparentIndex)
{
Debug.Assert(Delegates.pglXGetTransparentIndexSUN != null, "pglXGetTransparentIndexSUN not implemented");
retValue = Delegates.pglXGetTransparentIndexSUN(dpy, overlay, underlay, p_pTransparentIndex);
LogCommand("glXGetTransparentIndexSUN", retValue, dpy, overlay, underlay, pTransparentIndex);
}
}
DebugCheckErrors(retValue);
return(retValue);
}
public static bool QueryFrameCountNV(IntPtr dpy, int screen, UInt32[] count)
{
bool retValue;
unsafe
{
fixed(UInt32 *p_count = count)
{
Debug.Assert(Delegates.pglXQueryFrameCountNV != null, "pglXQueryFrameCountNV not implemented");
retValue = Delegates.pglXQueryFrameCountNV(dpy, screen, p_count);
LogCommand("glXQueryFrameCountNV", retValue, dpy, screen, count);
}
}
DebugCheckErrors(retValue);
return(retValue);
}
public static bool QueryFrameCountNV(IntPtr hDC, UInt32[] count)
{
bool retValue;
unsafe
{
fixed(UInt32 *p_count = count)
{
Debug.Assert(Delegates.pwglQueryFrameCountNV != null, "pwglQueryFrameCountNV not implemented");
retValue = Delegates.pwglQueryFrameCountNV(hDC, p_count);
LogCommand("wglQueryFrameCountNV", retValue, hDC, count);
}
}
DebugCheckErrors(retValue);
return(retValue);
}
public static bool DXUnlockObjectsNV(IntPtr hDevice, Int32 count, IntPtr[] hObjects)
{
bool retValue;
unsafe
{
fixed(IntPtr *p_hObjects = hObjects)
{
Debug.Assert(Delegates.pwglDXUnlockObjectsNV != null, "pwglDXUnlockObjectsNV not implemented");
retValue = Delegates.pwglDXUnlockObjectsNV(hDevice, count, p_hObjects);
LogFunction("wglDXUnlockObjectsNV(0x{0}, {1}, {2}) = {3}", hDevice.ToString("X8"), count, LogValue(hObjects), retValue);
}
}
DebugCheckErrors(retValue);
return(retValue);
}
public static bool QueryDeviceAttribEXT(IntPtr device, int attribute, IntPtr[] value)
{
bool retValue;
unsafe
{
fixed(IntPtr *p_value = value)
{
Debug.Assert(Delegates.peglQueryDeviceAttribEXT != null, "peglQueryDeviceAttribEXT not implemented");
retValue = Delegates.peglQueryDeviceAttribEXT(device, attribute, p_value);
LogCommand("eglQueryDeviceAttribEXT", retValue, device, attribute, value);
}
}
DebugCheckErrors(retValue);
return(retValue);
}
public static IntPtr CreateDRMImageMESA(IntPtr dpy, int[] attrib_list)
{
IntPtr retValue;
unsafe
{
fixed(int *p_attrib_list = attrib_list)
{
Debug.Assert(Delegates.peglCreateDRMImageMESA != null, "peglCreateDRMImageMESA not implemented");
retValue = Delegates.peglCreateDRMImageMESA(dpy, p_attrib_list);
LogFunction("eglCreateDRMImageMESA(0x{0}, {1}) = {2}", dpy.ToString("X8"), LogValue(attrib_list), retValue.ToString("X8"));
}
}
DebugCheckErrors(retValue);
return(retValue);
}
public static bool QueryVersion(IntPtr dpy, int[] maj, int[] min)
{
bool retValue;
unsafe
{
fixed(int *p_maj = maj)
fixed(int *p_min = min)
{
Debug.Assert(Delegates.pglXQueryVersion != null, "pglXQueryVersion not implemented");
retValue = Delegates.pglXQueryVersion(dpy, p_maj, p_min);
LogFunction("glXQueryVersion(0x{0}, {1}, {2}) = {3}", dpy.ToString("X8"), LogValue(maj), LogValue(min), retValue);
}
}
return(retValue);
}
public static UInt32 GetAMD(UInt32 maxCount, [Out] UInt32[] ids)
{
UInt32 retValue;
unsafe
{
fixed(UInt32 *p_ids = ids)
{
Debug.Assert(Delegates.pglXGetGPUIDsAMD != null, "pglXGetGPUIDsAMD not implemented");
retValue = Delegates.pglXGetGPUIDsAMD(maxCount, p_ids);
LogCommand("glXGetGPUIDsAMD", retValue, maxCount, ids);
}
}
DebugCheckErrors(retValue);
return(retValue);
}
public static int QueryGLXPbufferSGIX(IntPtr dpy, IntPtr pbuf, int attribute, UInt32[] value)
{
int retValue;
unsafe
{
fixed(UInt32 *p_value = value)
{
Debug.Assert(Delegates.pglXQueryGLXPbufferSGIX != null, "pglXQueryGLXPbufferSGIX not implemented");
retValue = Delegates.pglXQueryGLXPbufferSGIX(dpy, pbuf, attribute, p_value);
LogCommand("glXQueryGLXPbufferSGIX", retValue, dpy, pbuf, attribute, value);
}
}
DebugCheckErrors(retValue);
return(retValue);
}
public SQLFieldMapping(string table, string field, string propertyname, Delegates.ReadValue reader)
: this(field, propertyname, reader)
{
this.Table = table;
}
public static void glutTimerFunc(int msecs, Delegates.TimerCallback func, int value)
{
switch (Environment.OSVersion.Platform)
{
case PlatformID.MacOSX:
break;
case PlatformID.Unix:
{
Linux.Methods.glutTimerFunc(msecs, func, value);
return;
}
case PlatformID.Win32NT:
case PlatformID.Win32S:
case PlatformID.Win32Windows:
case PlatformID.WinCE:
{
Windows.Methods.glutTimerFunc(msecs, func, value);
return;
}
case PlatformID.Xbox:
break;
}
throw new PlatformNotSupportedException();
}
public SQLFieldMapping(string table, string field, string propertyname, Delegates.ParameterizedReadValue reader, object parameter)
: this(table, field, propertyname, null)
{
this.ParameterizedReader = reader;
this.Parameter = parameter;
}
//---------------------------------------------------------------------
public static void Initialize(double[,] establishProbabilities,
SeedingAlgorithm seedingAlgorithm,
Delegates.AddNewCohort addNewCohort)
{
Reproduction.establishProbabilities = establishProbabilities;
seeding = new Seeding(seedingAlgorithm);
Reproduction.addNewCohort = addNewCohort;
cohorts = Model.Core.SuccessionCohorts as AgeCohort.ILandscapeCohorts;
if (cohorts == null)
throw new ApplicationException("The succession plug-in's cohorts don't support age-cohort interface");
speciesDataset = Model.Core.Species;
int speciesCount = speciesDataset.Count;
resprout = Model.Core.Landscape.NewSiteVar<BitArray>();
serotiny = Model.Core.Landscape.NewSiteVar<BitArray>();
foreach (ActiveSite site in Model.Core.Landscape.ActiveSites) {
resprout[site] = new BitArray(speciesCount);
serotiny[site] = new BitArray(speciesCount);
}
planting = new Planting();
}
public ExternalSiteReaderParameters(Delegates.ReadValue reader, string site)
: this()
{
this.Reader = reader;
this.Site = site;
}
public ScriptBuilder RegisterStepStartingHandler(Delegates.ScriptStepEvent handler)
{
script.StepStarting += handler;
return this;
}
public static extern int ADL_Main_Control_Create(Delegates.ADL_Main_Memory_Alloc callback, int enumConnectedAdapters);
public static bool InstanceDelegateNoArguments() {
Delegates delegates = new Delegates();
NoArgDel c = new NoArgDel(delegates.NoArguments);
int result = c();
return result == 0 ? true : false;
}
public static bool InstanceDelegate() {
Delegates delegates = new Delegates();
Calculate addDelegate = new Calculate(delegates.Add);
int result = addDelegate(2, 3);
return result == 5 ? true : false;
}
public ScriptBuilder RegisterStepErrorHandler(Delegates.ScriptStepError handler)
{
script.StepError += handler;
return this;
}
public ScriptBuilder RegisterScriptFinishedHandler(Delegates.ScriptFinishedEvent handler)
{
script.ScriptFinished += handler;
return this;
}
public ScriptBuilder RegisterStepSkippedHandler(Delegates.ScriptStepEvent handler)
{
script.StepSkipped += handler;
return this;
}
public void BindCommandHandler(Delegates.HookCommandDelegate remotingCommand)
{
_remotingCommand = remotingCommand;
}
public PainterApp( Delegates.LogCallback logcb )
{
this.m_painter = PainterApp.GetPainter8Window();
this.m_log_cb = logcb;
}
public void SingleMethodInterface()
{
IInt32Action action = new Delegates();
action .DoIt(10);
}
/// <summary>
/// Sets the passive motion callbacks for the current window.
/// </summary>
/// <param name="func">The new passive motion callback function. See Tao.FreeGlut.Glut.PassiveMotionCallback.</param>
/// <remarks>
/// glutPassiveMotionFunc sets the passive motion callback for the current window.
/// The passive motion callback for a window is called when the mouse moves within
/// the window while no mouse buttons are pressed.
/// The x and y callback parameters indicate the mouse location in window relative
/// coordinates.
/// Passing null to glutPassiveMotionFunc disables the generation of the passive
/// motion callback.
/// </remarks>
public static void glutPassiveMotionFunc(Delegates.PassiveMotionCallback func)
{
switch (Environment.OSVersion.Platform)
{
case PlatformID.MacOSX:
break;
case PlatformID.Unix:
Linux.Methods.glutPassiveMotionFunc(func);
return;
case PlatformID.Win32NT:
case PlatformID.Win32S:
case PlatformID.Win32Windows:
case PlatformID.WinCE:
Windows.Methods.glutPassiveMotionFunc(func);
return;
case PlatformID.Xbox:
break;
}
throw new PlatformNotSupportedException();
}
internal static extern IntPtr SetWindowsHookEx( int idHook, Delegates.KeyboardHookProc callback, IntPtr hInstance, uint threadId);
//---------------------------------------------------------------------
//public static void Initialize(double[,] establishProbabilities,
public static void Initialize(SeedingAlgorithm seedingAlgorithm,
Delegates.AddNewCohort addNewCohort)
{
// Reproduction.establishProbabilities = establishProbabilities;
seeding = new Seeding(seedingAlgorithm);
Reproduction.addNewCohort = addNewCohort;
SiteVars.Cohorts = Model.Core.GetSiteVar<SiteCohorts>("Succession.Cohorts");
speciesDataset = Model.Core.Species;
int speciesCount = speciesDataset.Count;
resprout = Model.Core.Landscape.NewSiteVar<BitArray>();
serotiny = Model.Core.Landscape.NewSiteVar<BitArray>();
noEstablish = Model.Core.Landscape.NewSiteVar<bool>();
foreach (ActiveSite site in Model.Core.Landscape.ActiveSites) {
resprout[site] = new BitArray(speciesCount);
serotiny[site] = new BitArray(speciesCount);
}
noEstablish.ActiveSiteValues = false;
planting = new Planting();
}
