internal Cursor(CursorInfo cursorInfo) { if (cursorInfo == null) throw new ArgumentNullException("cursorInfo"); CursorInfo = cursorInfo; State = new CursorState(this); }
private static void DeclareCursors(IQuery query) { var queryExp1 = (SqlQueryExpression)SqlExpression.Parse("SELECT * FROM APP.test_table"); query.Context.DeclareCursor("c1", queryExp1); var queryExp2 = (SqlQueryExpression)SqlExpression.Parse("SELECT * FROM APP.test_table WHERE a > :a"); var cursorInfo = new CursorInfo("c2", queryExp2); cursorInfo.Parameters.Add(new CursorParameter("a", PrimitiveTypes.Integer())); query.Context.DeclareCursor(cursorInfo); }
public static void DeclareCursor(this IRequest context, CursorInfo cursorInfo) { var queryPlan = context.Context.QueryPlanner().PlanQuery(new QueryInfo(context, cursorInfo.QueryExpression)); var selectedTables = queryPlan.DiscoverTableNames(); foreach (var tableName in selectedTables) { if (!context.Query.UserCanSelectFromTable(tableName)) throw new MissingPrivilegesException(context.Query.UserName(), tableName, Privileges.Select); } context.Context.DeclareCursor(cursorInfo); }
public void DeclareCursor(CursorInfo cursorInfo) { if (cursorInfo == null) throw new ArgumentNullException("cursorInfo"); lock (this) { var cursorName = cursorInfo.CursorName; if (cursors.Any(x => x.CursorInfo.CursorName.Equals(cursorName, StringComparison.OrdinalIgnoreCase))) throw new ArgumentException(String.Format("Cursor '{0}' was already declared.", cursorName)); var cursor = new Cursor(cursorInfo); cursors.Add(cursor); } }
public static bool DeclareCursor(this IContext context, CursorInfo cursorInfo) { if (context.CursorExists(cursorInfo.CursorName)) throw new InvalidOperationException(String.Format("A cursor named '{0}' was already defined in the context.", cursorInfo.CursorName)); var currentContext = context; while (currentContext != null) { if (currentContext is ICursorScope) { var scope = (ICursorScope)currentContext; scope.DeclareCursor(cursorInfo); return true; } currentContext = currentContext.Parent; } return false; }
public override void SimulationStep() { base.SimulationStep(); var mouseRayValid = !UIView.IsInsideUI() && Cursor.visible && !cursorInSecondaryPanel; if (mouseRayValid) { var mouseRay = Camera.main.ScreenPointToRay(Input.mousePosition); var mouseRayLength = Camera.main.farClipPlane; var rayRight = Camera.main.transform.TransformDirection(Vector3.right); var defaultService = new ToolBase.RaycastService(ItemClass.Service.Road, ItemClass.SubService.None, ItemClass.Layer.Default); var input = new ToolBase.RaycastInput(mouseRay, mouseRayLength) { m_rayRight = rayRight, m_netService = defaultService, m_ignoreNodeFlags = NetNode.Flags.None, m_ignoreSegmentFlags = NetSegment.Flags.Untouchable }; RaycastOutput output; if (!RayCast(input, out output)) { _hoveredSegmentIdx = 0; _hoveredNetNodeIdx = 0; return; } _hoveredNetNodeIdx = output.m_netNode; _hoveredSegmentIdx = output.m_netSegment; } if (toolMode == ToolMode.None) { ToolCursor = null; } else { NetTool netTool = null; foreach (var tool in ToolsModifierControl.toolController.Tools) { NetTool nt = tool as NetTool; if (nt != null && nt.m_prefab != null) { netTool = nt; break; } } if (netTool != null && mouseRayValid) { ToolCursor = netTool.m_upgradeCursor; } } }
/// <summary> /// Takes a screenshot of th entire area and add to the list, plus add to the list the position and icon of the cursor. /// </summary> private void timerCapWithCursorFull_Tick(object sender, EventArgs e) { _cursorInfo = new CursorInfo { Icon = _capture.CaptureIconCursor(ref _posCursor), Position = _posCursor, Clicked = _recordClicked }; //saves to list the actual icon and position of the cursor _listCursor.Add(_cursorInfo); //Take a screenshot of the area. _gr.CopyFromScreen(0, 0, 0, 0, _sizeResolution, CopyPixelOperation.SourceCopy); //Add the bitmap to a list _addDel.BeginInvoke(String.Format("{0}{1}.bmp", _pathTemp, _frameCount), new Bitmap(_bt), CallBack, null); this.Invoke((Action)(() => this.Text = String.Format("Screen To Gif • {0}", _frameCount))); _frameCount++; }
public static void DeclareCursor(this ICursorScope scope, CursorInfo cursorInfo) { scope.CursorManager.DeclareCursor(cursorInfo); }
public static extern bool GetCursorInfo(out CursorInfo info);
public Task SendCursorChange(CursorInfo cursor, string viewerID) { return(ViewerHubContext.Clients.Client(viewerID).SendAsync("CursorChange", cursor)); }
bool IDisplayHandler.OnCursorChange(IWebBrowser chromiumWebBrowser, IBrowser browser, IntPtr cursor, CursorType type, CursorInfo customCursorInfo) { return(false); }
public static Bitmap CaptureImageCursor(ref Point point) { try { var cursorInfo = new CursorInfo(); cursorInfo.cbSize = Marshal.SizeOf(cursorInfo); if (!GetCursorInfo(out cursorInfo)) { return(null); } if (cursorInfo.flags != CursorShowing) { return(null); } var hicon = CopyIcon(cursorInfo.hCursor); if (hicon == IntPtr.Zero) { return(null); } IconInfo iconInfo; if (!GetIconInfo(hicon, out iconInfo)) { DestroyIcon(hicon); return(null); } point.X = cursorInfo.ptScreenPos.X - iconInfo.xHotspot; point.Y = cursorInfo.ptScreenPos.Y - iconInfo.yHotspot; using (var maskBitmap = Image.FromHbitmap(iconInfo.hbmMask)) { //Is this a monochrome cursor? if (maskBitmap.Height == maskBitmap.Width * 2 && iconInfo.hbmColor == IntPtr.Zero) { var final = new Bitmap(maskBitmap.Width, maskBitmap.Width); var hDesktop = GetDesktopWindow(); var dcDesktop = GetWindowDC(hDesktop); using (var resultGraphics = Graphics.FromImage(final)) { var resultHdc = resultGraphics.GetHdc(); BitBlt( resultHdc, 0, 0, final.Width, final.Height, dcDesktop, (int)point.X + 3, (int)point.Y + 3, CopyPixelOperation.SourceCopy ); DrawIconEx(resultHdc, 0, 0, cursorInfo.hCursor, 0, 0, 0, IntPtr.Zero, 0x0003); //TODO: I have to try removing the background of this cursor capture. //Native.BitBlt(resultHdc, 0, 0, final.Width, final.Height, dcDesktop, (int)point.X + 3, (int)point.Y + 3, Native.CopyPixelOperation.SourceErase); resultGraphics.ReleaseHdc(resultHdc); ReleaseDC(hDesktop, dcDesktop); } DeleteObject(iconInfo.hbmMask); DeleteDC(dcDesktop); DestroyIcon(hicon); return(final); } DeleteObject(iconInfo.hbmColor); DeleteObject(iconInfo.hbmMask); DestroyIcon(hicon); } var icon = Icon.FromHandle(hicon); return(icon.ToBitmap()); } catch (Exception ex) { //You should catch exception with your method here. //LogWriter.Log(ex, "Impossible to get the cursor."); } return(null); }
public async Task SendCursorChange(CursorInfo cursorInfo) { await SendToViewer(() => RtcSession.SendCursorChange(cursorInfo), () => CasterSocket.SendCursorChange(cursorInfo, ViewerConnectionID)); }
protected override void OnAfterSetup(string testName) { var tableName = ObjectName.Parse("APP.test_table"); AdminQuery.Access().CreateTable(tableBuilder => tableBuilder .Named(tableName) .WithColumn("a", PrimitiveTypes.Integer()) .WithColumn("b", PrimitiveTypes.String())); var table = AdminQuery.Access().GetMutableTable(tableName); for (int i = 0; i < 10; i++) { var row = table.NewRow(); row.SetValue(0, i); row.SetValue(1, String.Format("ID: {0}", i)); table.AddRow(row); } var query = (SqlQueryExpression)SqlExpression.Parse("SELECT * FROM APP.test_table"); var cursorInfo = new CursorInfo("c1", query); cursorInfo.Flags = CursorFlags.Scroll; AdminQuery.Access().CreateObject(cursorInfo); var c1 = (Cursor)AdminQuery.Access().GetObject(DbObjectType.Cursor, new ObjectName("c1")); c1.Open(AdminQuery); if (testName.StartsWith("FetchInto")) { var query2 = (SqlQueryExpression)SqlExpression.Parse("SELECT a FROM APP.test_table"); var cursorInfo2 = new CursorInfo("c2", query2); cursorInfo2.Flags = CursorFlags.Scroll; AdminQuery.Access().CreateObject(cursorInfo2); var c2 = (Cursor)AdminQuery.Access().GetObject(DbObjectType.Cursor, new ObjectName("c2")); c2.Open(AdminQuery); AdminQuery.Access().CreateObject(new VariableInfo("var1", PrimitiveTypes.BigInt(), false)); AdminQuery.Access().CreateObject(new VariableInfo("var2", PrimitiveTypes.String(), false)); } }
public async Task SendCursorChange(CursorInfo cursor, List <string> viewerIDs) { await RCBrowserHub.Clients.Clients(viewerIDs).SendAsync("CursorChange", cursor); }
/// <summary> /// Do the actual frame capture /// </summary> private void CaptureFrame() { int MSBETWEENCAPTURES = 1000 / framesPerSecond; int msToNextCapture = MSBETWEENCAPTURES; stopwatch.Reset(); while (!stop) { stopwatch.Start(); Point captureLocation; if (recordingWindow != null) { recordingWindow.Reset(); captureLocation = recordingWindow.Location; } else { captureLocation = new Point(recordingRectangle.X, recordingRectangle.Y); } // "Capture" GDI32.BitBlt(hDCDest, 0, 0, recordingSize.Width, recordingSize.Height, hDCDesktop, captureLocation.X, captureLocation.Y, CopyPixelOperation.SourceCopy); //GDI32.BitBlt(hDCDest, 0, 0, recordingSize.Width, recordingSize.Height, hDCDesktop, captureLocation.X, captureLocation.Y, CopyPixelOperation.SourceCopy | CopyPixelOperation.CaptureBlt); // Mouse if (RecordMouse) { CursorInfo cursorInfo = new CursorInfo(); cursorInfo.cbSize = Marshal.SizeOf(cursorInfo); Point mouseLocation = Cursor.Position; mouseLocation.Offset(-captureLocation.X, -captureLocation.Y); if (User32.GetCursorInfo(out cursorInfo)) { User32.DrawIcon(hDCDest, mouseLocation.X, mouseLocation.Y, cursorInfo.hCursor); } } // add to avi try { aviWriter.AddLowLevelFrame(bits0); } catch (Exception) { LOG.Error("Error adding frame to avi, stopping capturing."); break; } int restTime = (int)(msToNextCapture - stopwatch.ElapsedMilliseconds); // Set time to next capture, we correct it if needed later. msToNextCapture = MSBETWEENCAPTURES; if (restTime > 0) { // We were fast enough, we wait for next capture Thread.Sleep(restTime); } else if (restTime < 0) { // Compensating, as we took to long int framesToSkip = ((-restTime) / MSBETWEENCAPTURES); int leftoverMillis = (-restTime) % MSBETWEENCAPTURES; //LOG.InfoFormat("Adding {0} empty frames to avi, leftover millis is {1}, sleeping {2} (of {3} total)", framesToSkip, leftover, sleepMillis, MSBETWEENCAPTURES); aviWriter.AddEmptyFrames(framesToSkip); // check how bad it is, if we only missed our target by a few millis we hope the next capture corrects this if (leftoverMillis > 0 && leftoverMillis <= 2) { // subtract the leftover from the millis to next capture, do nothing else msToNextCapture -= leftoverMillis; } else if (leftoverMillis > 0) { // it's more, we add an empty frame aviWriter.AddEmptyFrames(1); // we sleep to the next time and int sleepMillis = MSBETWEENCAPTURES - leftoverMillis; // Sleep to next capture Thread.Sleep(sleepMillis); } } stopwatch.Reset(); } Cleanup(); }
/// <summary> /// Draws this overlay. /// </summary> /// <param name="G">A <see cref="Graphics"/> object to draw upon.</param> /// <param name="Transform">Point Transform Function.</param> public static void Draw(Graphics G, Func <Point, Point> Transform = null) { // ReSharper disable once RedundantAssignment // ReSharper disable once InlineOutVariableDeclaration var cursorInfo = new CursorInfo { cbSize = Marshal.SizeOf <CursorInfo>() }; if (!User32.GetCursorInfo(out cursorInfo)) { return; } if (cursorInfo.flags != CursorShowing) { return; } Bitmap icon; Point hotspot; if (Cursors.ContainsKey(cursorInfo.hCursor)) { var tuple = Cursors[cursorInfo.hCursor]; icon = tuple.Item1; hotspot = tuple.Item2; } else { var hIcon = User32.CopyIcon(cursorInfo.hCursor); if (hIcon == IntPtr.Zero) { return; } if (!User32.GetIconInfo(hIcon, out var icInfo)) { return; } icon = Icon.FromHandle(hIcon).ToBitmap(); hotspot = new Point(icInfo.xHotspot, icInfo.yHotspot); Cursors.Add(cursorInfo.hCursor, Tuple.Create(icon, hotspot)); User32.DestroyIcon(hIcon); Gdi32.DeleteObject(icInfo.hbmColor); Gdi32.DeleteObject(icInfo.hbmMask); } var location = new Point(cursorInfo.ptScreenPos.X - hotspot.X, cursorInfo.ptScreenPos.Y - hotspot.Y); if (Transform != null) { location = Transform(location); } try { G.DrawImage(icon, new Rectangle(location, icon.Size)); } catch (ArgumentException) { } }
protected virtual void OnCursorChange(IntPtr cursor, CursorType type, CursorInfo customCursorInfo) { RenderHandler?.OnCursorChange(cursor, type, customCursorInfo); }
public void OnCursorChange(IntPtr cursor, CursorType type, CursorInfo customCursorInfo) { CursorChange?.Invoke(this, new CursorChangeEventArgs(cursor, type, customCursorInfo)); }
public async Task SendCursorChange(CursorInfo cursor, List <string> viewerIDs) { await Connection.SendAsync("SendCursorChange", cursor, viewerIDs); }
/// <summary> /// Called when the browser's cursor has changed. /// </summary> /// <param name="cursor">If type is Custom then customCursorInfo will be populated with the custom cursor information</param> /// <param name="type">cursor type</param> /// <param name="customCursorInfo">custom cursor Information</param> public virtual void OnCursorChange(IntPtr cursor, CursorType type, CursorInfo customCursorInfo) { }
private static extern bool GetCursorInfo(out CursorInfo pci);
// TODO: assert access to the resources protected override void ExecuteStatement(ExecutionContext context) { var cursorInfo = new CursorInfo(CursorName, Flags, QueryExpression); if (Parameters != null) { foreach (var parameter in Parameters) { cursorInfo.Parameters.Add(parameter); } } // TODO: //var queryPlan = context.Request.Context.QueryPlanner().PlanQuery(new QueryInfo(context.Request, QueryExpression)); //var selectedTables = queryPlan.DiscoverAccessedResources(); //foreach (var tableName in selectedTables) { // if (!context.User.CanSelectFromTable(tableName)) // throw new MissingPrivilegesException(context.User.Name, tableName, Privileges.Select); //} context.Request.Context.DeclareCursor(cursorInfo); }
public static extern bool GetCursorInfo(ref CursorInfo cursorInfo);
protected GLControl() { cursorInfo = new CursorInfo(this); }
void IRenderWebBrowser.OnCursorChange(IntPtr cursor, CursorType type, CursorInfo customCursorInfo) { target.Cursor = new Cursor(cursor); }
private static extern bool GetCursorInfo(ref CursorInfo cursorInfo);
static void GetIcon(Func <Point, Point> Transform, out Bitmap Icon, out Point Location) { Icon = null; Location = Point.Empty; // ReSharper disable once RedundantAssignment // ReSharper disable once InlineOutVariableDeclaration var cursorInfo = new CursorInfo { cbSize = Marshal.SizeOf <CursorInfo>() }; if (!User32.GetCursorInfo(out cursorInfo)) { return; } if (cursorInfo.flags != CursorShowing) { return; } Point hotspot; if (Cursors.ContainsKey(cursorInfo.hCursor)) { var tuple = Cursors[cursorInfo.hCursor]; Icon = tuple.Item1; hotspot = tuple.Item2; } else { var hIcon = User32.CopyIcon(cursorInfo.hCursor); if (hIcon == IntPtr.Zero) { return; } if (!User32.GetIconInfo(hIcon, out var icInfo)) { return; } Icon = System.Drawing.Icon.FromHandle(hIcon).ToBitmap(); hotspot = new Point(icInfo.xHotspot, icInfo.yHotspot); Cursors.Add(cursorInfo.hCursor, Tuple.Create(Icon, hotspot)); User32.DestroyIcon(hIcon); Gdi32.DeleteObject(icInfo.hbmColor); Gdi32.DeleteObject(icInfo.hbmMask); } Location = new Point(cursorInfo.ptScreenPos.X - hotspot.X, cursorInfo.ptScreenPos.Y - hotspot.Y); if (Transform != null) { Location = Transform(Location); } }
protected override void Awake() { Log.debug("Create Button"); toggleButton = ReportButton.Create(); toggleButton.eventClick += OnButtonToggled; Log.debug("Create UI..."); ui = ReportUI.Create(); ui.enabled = false; ui.absolutePosition = new Vector2(-1000, 0); ui.eventHighlightType += (String s) => { SetHighlight(s); }; Log.debug("Create Analyzer..."); analyzer = new TrafficAnalyzer(); analyzer.OnReport += OnGotReport; Log.debug("Create Path Controller..."); paths = new PathController(this); Log.info("Load Cursor..."); m_cursor = CursorInfo.CreateInstance<CursorInfo>(); m_cursor.m_texture = ResourceLoader.loadTexture("Materials/Cursor.png"); m_cursor.m_hotspot = new Vector2(0, 0); loadingCursor = CursorInfo.CreateInstance<CursorInfo>(); loadingCursor.m_texture = ResourceLoader.loadTexture("Materials/Hourglass.png"); Log.info("QueryTool awoken"); base.Awake(); }
protected override void ExecuteStatement(ExecutionContext context) { var cursorInfo = new CursorInfo(CursorName, Flags, QueryExpression); if (Parameters != null) { foreach (var parameter in Parameters) { cursorInfo.Parameters.Add(parameter); } } context.Request.Query.DeclareCursor(cursorInfo); }
/// <summary> /// Takes a screenshot of desired area and add to the list, plus add to the list the position and icon of the cursor. /// </summary> private void timerCapWithCursor_Tick(object sender, EventArgs e) { _cursorInfo = new CursorInfo { IconImage = _capture.CaptureImageCursor(ref _posCursor), Position = panelTransparent.PointToClient(_posCursor), Clicked = _recordClicked, }; //Get actual icon of the cursor _listCursor.Add(_cursorInfo); //Get the actual position of the form. Point lefttop = new Point(this.Location.X + panelTransparent.Location.X, this.Location.Y + panelTransparent.Location.Y); //Take a screenshot of the area. _gr.CopyFromScreen(lefttop.X, lefttop.Y, 0, 0, panelTransparent.Bounds.Size, CopyPixelOperation.SourceCopy); //Add the bitmap to a list _addDel.BeginInvoke(String.Format("{0}{1}.bmp", _pathTemp, _frameCount), new Bitmap(_bt), CallBack, null); this.Invoke((Action)(() => this.Text = String.Format("Screen To Gif • {0}", _frameCount))); _frameCount++; GC.Collect(1); }
public static MyCursor CaptureCursor() { CursorInfo cursorInfo = new CursorInfo(); cursorInfo.cbSize = Marshal.SizeOf(cursorInfo); if (GetCursorInfo(out cursorInfo) && cursorInfo.flags == CURSOR_SHOWING) { cursorInfo.ptScreenPos = NativeMethods.ConvertPoint(Cursor.Position); IntPtr hicon = CopyIcon(cursorInfo.hCursor); if (hicon != IntPtr.Zero) { IconInfo iconInfo; if (GetIconInfo(hicon, out iconInfo)) { Point position = new Point(cursorInfo.ptScreenPos.X - iconInfo.xHotspot, cursorInfo.ptScreenPos.Y - iconInfo.yHotspot); using (Bitmap maskBitmap = Bitmap.FromHbitmap(iconInfo.hbmMask)) { Bitmap resultBitmap = null; if (IsCursorMonochrome(maskBitmap)) { resultBitmap = new Bitmap(maskBitmap.Width, maskBitmap.Width); Graphics desktopGraphics = Graphics.FromHwnd(GetDesktopWindow()); IntPtr desktopHdc = desktopGraphics.GetHdc(); IntPtr maskHdc = GDI.CreateCompatibleDC(desktopHdc); IntPtr oldPtr = GDI.SelectObject(maskHdc, maskBitmap.GetHbitmap()); using (Graphics resultGraphics = Graphics.FromImage(resultBitmap)) { IntPtr resultHdc = resultGraphics.GetHdc(); // These two operation will result in a black cursor over a white background. // Later in the code, a call to MakeTransparent() will get rid of the white background. GDI.BitBlt(resultHdc, 0, 0, 32, 32, maskHdc, 0, 32, CopyPixelOperation.SourceCopy); GDI.BitBlt(resultHdc, 0, 0, 32, 32, maskHdc, 0, 0, CopyPixelOperation.SourceInvert); resultGraphics.ReleaseHdc(resultHdc); } IntPtr newPtr = GDI.SelectObject(maskHdc, oldPtr); GDI.DeleteDC(newPtr); GDI.DeleteDC(maskHdc); desktopGraphics.ReleaseHdc(desktopHdc); // Remove the white background from the BitBlt calls, // resulting in a black cursor over a transparent background. resultBitmap.MakeTransparent(Color.White); } else { resultBitmap = Icon.FromHandle(hicon).ToBitmap(); } return new MyCursor(new Cursor(cursorInfo.hCursor), position, resultBitmap); } } } } return new MyCursor(); }
void IRenderHandler.OnCursorChange(IntPtr cursor, CursorType type, CursorInfo customCursorInfo) { }
internal static extern bool GetCursorInfo(ref CursorInfo Info);
public bool OnCursorChange(IWebBrowser chromiumWebBrowser, IBrowser browser, IntPtr cursor, CursorType type, CursorInfo customCursorInfo) { return(false); }
public CursorChangeEventArgs(IntPtr cursor, CursorType type, CursorInfo customCursorInfo) { Cursor = cursor; Type = type; CustomCursorInfo = customCursorInfo; }
/// <summary> /// Takes a screenshot of desired area and add to the list, plus add to the list the position and icon of the cursor. /// </summary> private void timerCapWithCursor_Tick(object sender, EventArgs e) { _cursorInfo = new CursorInfo { Icon = _capture.CaptureIconCursor(ref _posCursor), Position = panelTransparent.PointToClient(_posCursor) }; //saves to list the actual icon and position of the cursor _listCursor.Add(_cursorInfo); //Get the actual position of the form. Point lefttop = new Point(_caller.Location.X + _offsetX, _caller.Location.Y + _offsetY); //Take a screenshot of the area. _gr.CopyFromScreen(lefttop.X, lefttop.Y, 0, 0, panelTransparent.Bounds.Size, CopyPixelOperation.SourceCopy); //Add the bitmap to a list _listBitmap.Add((Bitmap)_bt.Clone()); }
/// <summary> /// Called when the browser's cursor has changed. . /// </summary> /// <param name="cursor">If type is Custom then customCursorInfo will be populated with the custom cursor information</param> /// <param name="type">cursor type</param> /// <param name="customCursorInfo">custom cursor Information</param> void IRenderWebBrowser.OnCursorChange(IntPtr cursor, CursorType type, CursorInfo customCursorInfo) { RenderHandler?.OnCursorChange(cursor, type, customCursorInfo); }
public static extern bool GetCursorInfo(out CursorInfo pci);
public GameCursor() { _tooltip = new Tooltip(); for (int i = 0; i < 2; i++) { for (int j = 0; j < 16; j++) { ushort id = _cursorData[i, j]; //Texture2D texture = FileManager.Art.GetTexture(id); ushort[] pixels = FileManager.Art.ReadStaticArt(id, out short w, out short h, out _); if (i == 0) { if (pixels != null && pixels.Length > 0) { float offX = 0; float offY = 0; float dw = w; float dh = h; if (id == 0x206A) { offX = -4f; } else if (id == 0x206B) { offX = -dw + 3f; } else if (id == 0x206C) { offX = -dw + 3f; offY = -(dh / 2f); } else if (id == 0x206D) { offX = -dw; offY = -dh; } else if (id == 0x206E) { offX = -(dw * 0.66f); offY = -dh; } else if (id == 0x206F) { offY = -dh + 4f; } else if (id == 0x2070) { offY = -dh + 4f; } else if (id == 0x2075) { offY = -4f; } else if (id == 0x2076) { offX = -12f; offY = -14f; } else if (id == 0x2077) { offX = -(dw / 2f); offY = -(dh / 2f); } else if (id == 0x2078) { offY = -(dh * 0.66f); } else if (id == 0x2079) { offY = -(dh / 2f); } switch (id) { case 0x206B: offX = -29; offY = -1; break; case 0x206C: offX = -41; offY = -9; break; case 0x206D: offX = -36; offY = -25; break; case 0x206E: offX = -14; offY = -33; break; case 0x206F: offX = -2; offY = -26; break; case 0x2070: offX = -3; offY = -8; break; case 0x2071: offX = -1; offY = -1; break; case 0x206A: offX = -4; offY = -2; break; case 0x2075: offX = -2; offY = -10; break; } _cursorOffset[0, j] = (int)offX; _cursorOffset[1, j] = (int)offY; } else { _cursorOffset[0, j] = 0; _cursorOffset[1, j] = 0; } } if (pixels != null && pixels.Length > 0) { _cursorPixels[i, j] = new CursorInfo() { Width = w, Height = h, Pixels = pixels }; } } } }