예제 #1
0
 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;
        }
예제 #5
0
파일: AS.xaml.cs 프로젝트: Kraitical/Acre
 public AS(Dictionary<string, ITlPlugin> plugins, Delegates.AcreCall<AnimeEntry[]> saveproc, Delegates.AcreCall<AnimeEntry> manualupdate)
 {
     this.plugins = plugins;
     this.manualupdate = manualupdate;
     proc = saveproc;
     InitializeComponent();
 }
예제 #6
0
파일: Square.cs 프로젝트: Nayshlok/Zombie
 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);
        }
예제 #8
0
        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);
        }
예제 #9
0
 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;
 }
예제 #10
0
        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;
        }
예제 #11
0
 public void BindCommandHandlers(Delegates.HookCommandDelegate remotingCommand)
 {
     try
     {
         remoteControl.BindCommandHandler(remotingCommand);
     }
     catch (Exception ex)
     {
         Tools.Instance.Logger.LogError(ex.ToString());
     }
 }
예제 #12
0
        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>();
        }
예제 #13
0
        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);
        }
예제 #14
0
        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);
        }
예제 #15
0
        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);
        }
예제 #16
0
        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);
        }
예제 #17
0
        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);
        }
예제 #18
0
        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);
        }
예제 #19
0
        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);
        }
예제 #20
0
        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);
        }
예제 #21
0
        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);
        }
예제 #22
0
        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);
        }
예제 #23
0
        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);
        }
예제 #25
0
        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);
        }
예제 #26
0
        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);
        }
예제 #27
0
        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);
        }
예제 #28
0
        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);
        }
예제 #29
0
        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);
        }
예제 #30
0
        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);
        }
예제 #31
0
        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);
        }
예제 #32
0
        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);
        }
예제 #33
0
        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);
        }
예제 #35
0
        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);
        }
예제 #36
0
        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);
        }
예제 #37
0
        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);
        }
예제 #38
0
        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);
        }
예제 #39
0
        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);
        }
예제 #40
0
        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);
        }
예제 #41
0
        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);
        }
예제 #42
0
        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);
        }
예제 #43
0
 public SQLFieldMapping(string table, string field, string propertyname, Delegates.ReadValue reader)
     : this(field, propertyname, reader)
 {
     this.Table = table;
 }
예제 #44
0
 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();
 }
예제 #45
0
 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();
        }
예제 #47
0
 public ExternalSiteReaderParameters(Delegates.ReadValue reader, string site)
     : this()
 {
     this.Reader = reader;
     this.Site = site;
 }
예제 #48
0
 public ScriptBuilder RegisterStepStartingHandler(Delegates.ScriptStepEvent handler)
 {
     script.StepStarting += handler;
     return this;
 }
예제 #49
0
 public static extern int ADL_Main_Control_Create(Delegates.ADL_Main_Memory_Alloc callback, int enumConnectedAdapters);
예제 #50
0
 public static bool InstanceDelegateNoArguments() {
   Delegates delegates = new Delegates();
   NoArgDel c = new NoArgDel(delegates.NoArguments);
   int result = c();
   return result == 0 ? true : false;
 }
예제 #51
0
 public static bool InstanceDelegate() {
   Delegates delegates = new Delegates();
   Calculate addDelegate = new Calculate(delegates.Add);
   int result = addDelegate(2, 3);
   return result == 5 ? true : false;
 }
예제 #52
0
 public ScriptBuilder RegisterStepErrorHandler(Delegates.ScriptStepError handler)
 {
     script.StepError += handler;
     return this;
 }
예제 #53
0
 public ScriptBuilder RegisterScriptFinishedHandler(Delegates.ScriptFinishedEvent handler)
 {
     script.ScriptFinished += handler;
     return this;
 }
예제 #54
0
 public ScriptBuilder RegisterStepSkippedHandler(Delegates.ScriptStepEvent handler)
 {
     script.StepSkipped += handler;
     return this;
 }
예제 #55
0
 public void BindCommandHandler(Delegates.HookCommandDelegate remotingCommand)
 {
     _remotingCommand = remotingCommand;
 }
예제 #56
0
		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);
 }
예제 #58
0
 /// <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();
 }
예제 #59
0
        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();
        }