Example #1
0
        /// <summary>
        /// Gets the icon as an <see cref="ImageSource"/> for the specified path.
        /// </summary>
        /// <param name="path">The path.</param>
        /// <param name="info">The shell file info.</param>
        /// <returns>The icon as an <see cref="ImageSource"/> for the specified path.</returns>
        public static ImageSource GetImageSource(string path, out Win32.SHFILEINFO info)
        {
            info = new Win32.SHFILEINFO();

            int attr;
            if (Directory.Exists(path))
                attr = (int)Win32.FILE_ATTRIBUTE_DIRECTORY;
            else if (File.Exists(path))
                attr = (int)Win32.FILE_ATTRIBUTE_NORMAL;
            else if (path.Length == 3) // drive not ready
                attr = (int)Win32.FILE_ATTRIBUTE_DIRECTORY;
            else
                return null;

            Win32.SHGetFileInfo(path, attr, out info, (uint)Marshal.SizeOf(typeof(Win32.SHFILEINFO)), Win32.SHGFI_DISPLAYNAME | Win32.SHGFI_ICON | Win32.SHGFI_TYPENAME | Win32.SHGFI_SMALLICON | Win32.SHGFI_USEFILEATTRIBUTES);

            ImageSource img = null;
            if (info.hIcon != IntPtr.Zero)
            {
                using (Icon icon = Icon.FromHandle(info.hIcon))
                {
                    img = Imaging.CreateBitmapSourceFromHIcon(icon.Handle, new Int32Rect(0, 0, icon.Width, icon.Height), BitmapSizeOptions.FromEmptyOptions());
                }

                Win32.DestroyIcon(info.hIcon);
            }

            return img;
        }
 public Monitor(Win32.DISPLAY_DEVICE device, Win32.DEVMODE currentDisplaySettings, List<Win32.DEVMODE> availableDisplaySettings)
 {
     Device = device;
     AvailableDisplaySettings = availableDisplaySettings;
     CurrentDisplaySettings = currentDisplaySettings;
     IsPrimary = CurrentDisplaySettings.dmPositionX == 0 && CurrentDisplaySettings.dmPositionY == 0;
 }
        bool GetPreferences(string section, out Win32.RECT rect, out long style, out long exStyle)
        {
            rect = new Win32.RECT();
            style = 0;
            exStyle = 0;

            if (!Preferences.HasSection(section))
            {
                return false;
            }
            string[] keys = { "rectLeft", "rectTop", "rectRight", "rectBottom", "style", "exStyle" };
            foreach (string key in keys)
            {
                if (!Preferences[section].HasKey(key))
                {
                    return false;
                }
            }
            if (!int.TryParse(Preferences[section]["rectLeft"].Value, out rect.Left)) { return false; }
            if (!int.TryParse(Preferences[section]["rectTop"].Value, out rect.Top)) { return false; }
            if (!int.TryParse(Preferences[section]["rectRight"].Value, out rect.Right)) { return false; }
            if (!int.TryParse(Preferences[section]["rectBottom"].Value, out rect.Bottom)) { return false; }
            if (!long.TryParse(Preferences[section]["style"].Value, out style)) { return false; }
            if (!long.TryParse(Preferences[section]["exStyle"].Value, out exStyle)) { return false; }
            return true;
        }
Example #4
0
        private Tree CaptureWindow(IntPtr hwnd, Win32.WINDOWINFO windowinfo, bool usePrintWindow, bool fixedSize = false)
        {
            BoundingBox windowRect = new BoundingBox(windowinfo.rcWindow.left, windowinfo.rcWindow.top,
                            windowinfo.rcWindow.right - windowinfo.rcWindow.left + 1, windowinfo.rcWindow.bottom - windowinfo.rcWindow.top + 1);

            var attributes = GetWindowAttributes(hwnd, windowinfo);

            if (windowRect.Width > 0 && windowRect.Height > 0)
            {
                System.Drawing.Bitmap bmp;
                int width = windowRect.Width;
                int height = windowRect.Height;

                if(fixedSize)
                {
                    width = (int)System.Windows.SystemParameters.VirtualScreenWidth;
                    height = (int)System.Windows.SystemParameters.VirtualScreenHeight;
                }

                if (!usePrintWindow)
                    bmp = GetBitmapFromScreen(hwnd, null, width, height);
                else
                    bmp = GetBitmapFromPrintWindow(hwnd, null, width, height);

                Tree window = _bitmapToTree.GetScreenshotAndCreateTree(windowRect.Width, windowRect.Height, bmp, attributes);
                //_pool.ReturnInstance(bmp);
                return window;
            }

            return null;
        }
Example #5
0
 // Methods
 public ColorOperation()
 {
     this.mouseAreaControl = null;
     this.translatePath = new GraphicsPath();
     this.scalePath = new GraphicsPath();
     this.rotatePath = new GraphicsPath();
     this.equalPath = new GraphicsPath();
     this.skewxPath = new GraphicsPath();
     this.skewyPath = new GraphicsPath();
     this.anglescalePath = new GraphicsPath();
     this.vscalPath = new GraphicsPath();
     this.controlPoints = null;
     this.reversePath = new GraphicsPath();
     this.startPoint = PointF.Empty;
     this.win32 = new Win32();
     this.ratiomatrix = new Matrix();
     this.graphMatrix = new Matrix();
     this.selectMatrix = new Matrix();
     this.gradientMatrix = new Matrix();
     this.gradientPath = new GraphicsPath();
     this.gradientheight = 1f;
     this.centerPoint = PointF.Empty;
     this.gradientstr = string.Empty;
     this.colorpickerstr = string.Empty;
     this.gradientstr = DrawAreaConfig.GetLabelForName("gradienttransform").Trim();
     this.colorpickerstr = DrawAreaConfig.GetLabelForName("colorpicker").Trim();
 }
Example #6
0
		static bool HandleCtrl(Win32.CtrlTypes type)
		{
			var name = Enum.GetName(type.GetType(), type);
			Console.WriteLine("\nExiting due to {0} event from system!\n", name);

			if (f != null)
				f.TerminateBots();
			return true;
		}
 public static bool Click(Win32.Point point)
 {
     if (bshandle == IntPtr.Zero)
         bshandle = GetBlueStackWindowHandle();
     if (bshandle == IntPtr.Zero)
         return false;
     MouseHelper.ClickOnPoint(bshandle, point);
     return true;
 }
Example #8
0
 // Methods
 public ViewOperation()
 {
     this.mouseAreaControl = null;
     this.startPoint = Point.Empty;
     this.oldleft = 0f;
     this.oldtop = 0f;
     this.reversePath =new GraphicsPath();
     this.win32 = new Win32();
 }
 bool SetPreferences(string section, Win32.RECT rect, long style, long exStyle)
 {
     Preferences[section]["rectLeft"].Value = rect.Left.ToString();
     Preferences[section]["rectTop"].Value = rect.Top.ToString();
     Preferences[section]["rectRight"].Value = rect.Right.ToString();
     Preferences[section]["rectBottom"].Value = rect.Bottom.ToString();
     Preferences[section]["style"].Value = style.ToString();
     Preferences[section]["exStyle"].Value = exStyle.ToString();
     return true;
 }
Example #10
0
 public static int DwmExtendFrameIntoClientArea(IntPtr hwnd, ref Win32.MARGINS margins)
 {
     IntPtr hModule = Win32.LoadLibrary("dwmapi");
       if (hModule == IntPtr.Zero)
     return 0;
       IntPtr procAddress = Win32.GetProcAddress(hModule, "DwmExtendFrameIntoClientArea");
       if (procAddress == IntPtr.Zero)
     return 0;
       else
     return ((Win32.DwmExtendFrameIntoClientAreaDelegate) Marshal.GetDelegateForFunctionPointer(procAddress, typeof (Win32.DwmExtendFrameIntoClientAreaDelegate)))(hwnd, ref margins);
 }
Example #11
0
 internal DrawOperation(MouseArea mousecontrol)
     : this()
 {
     this.mouseAreaControl = mousecontrol;
     this.win32 = this.mouseAreaControl.win32;
     this.openFileDialog1 = new OpenFileDialog();
     string text1 = DrawAreaConfig.GetLabelForName("filefilter").Trim();
     this.openFileDialog1.Filter = text1;
     this.openFileDialog1.Title = DrawAreaConfig.GetLabelForName("imagedialog").Trim();
     this.openFileDialog1.FileOk += new CancelEventHandler(this.openFileDialog1_FileOk);
 }
 private IntPtr EnumWindowByName(Win32.EnumWindowsProc filter)
 {
     IntPtr WindowHwnd = IntPtr.Zero;
     Win32.EnumWindows(delegate(IntPtr hwnd, IntPtr lparam)
     {
         if (filter(hwnd, lparam))
         {
             WindowHwnd = hwnd;
             return false;
         }
         return true;
     }, IntPtr.Zero);
     return WindowHwnd;
 }
Example #13
0
 // Methods
 public DrawOperation()
 {
     this.mouseAreaControl = null;
     this.win32 = new Win32();
     this.tempPath = new GraphicsPath();
     this.drawPath = null;
     this.showdialog = false;
     this.filename = string.Empty;
     this.haveTextActive = false;
     this.startPoint = Point.Empty;
     this.mouseDown = false;
     this.reversePath = new GraphicsPath();
     this.first = true;
     this.list = new ArrayList();
     this.tooltips = new Hashtable();
     this.finish = false;
     this.redPath =new GraphicsPath();
 }
Example #14
0
 /// <summary>
 /// ������
 /// </summary>
 /// <param name="mc"></param>
 public DistanceOperation(MouseArea mc)
 {
     this.reversePath = new GraphicsPath();
     this.graph = null;
     this.points = new ArrayList();
     this.moveindex = -1;
     this.startpoint = PointF.Empty;
     this.prePoint = PointF.Empty;
     this.nextPoint = PointF.Empty;
     this.insertindex = -1;
     this.tooltips = new Hashtable(0x10);
     this.oldpoints = string.Empty;
     this.mousedown = false;
     this.mouseAreaControl = mc;
     this.win32 = mc.win32;
     this.mouseAreaControl.DefaultCursor = SpecialCursors.MeasureCursor;
     this.tempPath=new GraphicsPath();
     this.connectPoint=PointF.Empty;
 }
        private IntPtr EnumChildWindowByName(IntPtr parent, Win32.EnumWindowsProc filter)
        {
            IntPtr WindowHwnd = IntPtr.Zero;
            Win32.EnumChildWindows(parent, delegate(IntPtr hwnd, IntPtr lparam)
            {
                if (filter(hwnd, lparam))
                {
                    WindowHwnd = hwnd;
                    return false;
                }
                else
                {
                    EnumChildWindowByName(hwnd, filter);

                }
                return true;
            }, IntPtr.Zero);
            return WindowHwnd;
        }
Example #16
0
 // Methods
 public SelectOperation()
 {
     this.mouseAreaControl = null;
     this.toBeSelectedGraph = null;
     this.toBeSelectedPath = null;
     this.currentMousePoint = MousePoint.None;
     this.reversePath = new GraphicsPath();
     this.oriPath = new GraphicsPath();
     this.startpoint = PointF.Empty;
     this.movePoint = PointF.Empty;
     this.selectMatrix = new Matrix();
     this.totalmatrix = new Matrix();
     this.controlPoint = PointF.Empty;
     this.selectAreaPath = new GraphicsPath();
     this.win32 = new Win32();
     this.AreaPoints = new ArrayList(0x10);
     this.ps = new PointF[8];
     this.rotateindex = 0;
     this.selectCollection = new SvgElementCollection();
     this.tooltips = new Hashtable(0x10);
     this.rotatepath = new GraphicsPath();
 }
Example #17
0
        int Hooked(int code, IntPtr wparam, ref Win32.CWPSTRUCT cwp)
        {
            switch(code) {
                case 0:
                switch(cwp.message) {
                    case Win32.WM_CREATE:
                        string s = string.Empty;
                        char[] className = new char[10];
                        int length = Win32.GetClassName( cwp.hwnd, className, 9 );
                        for( int i = 0; i < length; i++ )
                            s += className[i];
                        if( s == "#32768" ) { // System class for menu
                            defaultWndProc = Win32.SetWindowLong( cwp.hwnd, (-4), subWndProc );
                            //int old = Win32.GetWindowLong( cwp.hwnd, (-20) );
                            //Win32.SetWindowLong2( cwp.hwnd,  (-20)/*GWL_EXSTYLE=(-20)*/, 0x20/*WS_EX_TRANSPARENT=0x20*/ );
                        }

                        break;
                }
                break;
            }
            return Win32.CallNextHookEx(hookHandle,code,wparam, ref cwp);
        }
Example #18
0
        private Dictionary<string, object> GetWindowAttributes(IntPtr hwnd, Win32.WINDOWINFO windowinfo)
        {
           
            Dictionary<string, object> attributes = new Dictionary<string, object>();
            attributes["handle"] = hwnd;


            ExpensiveWindowInfo expensiveInfo;

            if (!_windowInfo.TryGetValue(hwnd, out expensiveInfo))
            {
                expensiveInfo = new ExpensiveWindowInfo(Win32.GetClassName(hwnd), Win32.GetWindowText(hwnd), Win32.GetProcessPathFromWindowHandle(hwnd));
                _windowInfo.Add(hwnd, expensiveInfo);
            }

            attributes["processfilename"] = expensiveInfo.ProcessFilePath;
            attributes["title"] = expensiveInfo.Title;
            attributes["classname"] = expensiveInfo.ClassName;
            attributes["style"] = windowinfo.dwStyle;
            attributes["exstyle"] = windowinfo.dwExStyle;

            return attributes;
        }
Example #19
0
 // Methods
 public PolyOperation(MouseArea mc)
 {
     this.mouseAreaControl = null;
     this.win32 = null;
     this.reversePath = new GraphicsPath();
     this.graph = null;
     this.operate = PolyOperate.Draw;
     this.points = new PointF[0];
     this.moveindex = -1;
     this.startpoint = PointF.Empty;
     this.prePoint = PointF.Empty;
     this.nextPoint = PointF.Empty;
     this.insertindex = -1;
     this.tooltips = new Hashtable(0x10);
     this.oldpoints = string.Empty;
     this.mousedown = false;
     this.AreaPoints=new ArrayList();
     this.mouseAreaControl = mc;
     this.win32 = mc.win32;
     this.mouseAreaControl.PicturePanel.GraphChanged += new EventHandler(this.ChangeGraph);
     this.mouseAreaControl.SVGDocument.SelectCollection.OnCollectionChangedEvent += new OnCollectionChangedEventHandler(this.ChangeSelect);
     this.mouseAreaControl.DefaultCursor = SpecialCursors.bezierCursor;
 }
 internal IntPtr addHook(Win32.HookingIDs hID, WinAPI.LowLevelMouseProc callback)
 {
     if (ModuleHandle == IntPtr.Zero) {
         using (var curProcess = Process.GetCurrentProcess())
         using (var curModule = curProcess.MainModule) {
             IntPtr ret = WinAPI.SetWindowsHookEx((int)hID, callback, WinAPI.GetModuleHandle(curModule.ModuleName), 0);
             HookInfo info = new HookInfo();
             info.hookID = ret;
             info.callback = callback;
             info.hID = hID;
             hookIDs.Add(info);
             return ret;
         }
     } else {
         IntPtr ret = WinAPI.SetWindowsHookEx((int)hID, callback, ModuleHandle, 0);
         HookInfo info = new HookInfo();
         info.hookID = ret;
         info.callback = callback;
         info.hID = hID;
         hookIDs.Add(info);
         hookIDs.Add(info);
         return ret;
     }
 }
Example #21
0
        /// <summary>
        ///     The callback for the Keyboard hook
        /// </summary>
        /// <param name="code"></param>
        /// <param name="wParam"></param>
        /// <param name="lParam"></param>
        /// <returns></returns>
        private int HookProc(int code, int wParam, ref Win32.KBDLLHOOKSTRUCT lParam)
        {
            if (code >= 0)
            {
                Key key = System.Windows.Input.KeyInterop.KeyFromVirtualKey(lParam.vkCode);

                //if (HookedKeys.Contains(key))
                {
                    KeyboardHookEventArgs kea = new KeyboardHookEventArgs(key, true);
                    if ((wParam == (int)Win32.WindowsMessages.WM_KEYDOWN || wParam == (int)Win32.WindowsMessages.WM_SYSKEYDOWN) && (KeyDown != null))
                    {
                        KeyDown(this, kea);
                    }
                    else if ((wParam == (int)Win32.WindowsMessages.WM_KEYUP || wParam == (int)Win32.WindowsMessages.WM_SYSKEYUP) && (KeyUp != null))
                    {
                        kea.IsDown = false;
                        KeyUp(this, kea);
                    }
                    if (kea.Handled)
                        return 1;
                }
            }
            return Win32.CallNextHookEx(m_hHook, code, wParam, ref lParam);
        }
Example #22
0
        public static String Get(HTTP.UpdateProgressDelegate progressDelegate, HTTP.FuncBool cancellingDelegate, bool timeout,
                                 HTTP.DataCopiedDelegate dataRxDelegate, IXenConnection connection, XenRef <Task> task, ref Session session, string path,
                                 string hostname, Delegate f, params object[] p)
        {
            log.DebugFormat("HTTP GETTING file from {0} to {1}", hostname, path);

            // Cannot use ref param in anonymous method, so save it here and restore it later
            Session _session = session;

            HTTP.DataCopiedDelegate dataCopiedDelegate = delegate(long bytes)
            {
                if (progressDelegate != null)
                {
                    int progress = (int)(100 * (double)Task.DoWithSessionRetry(connection, ref _session,
                                                                               (Task.TaskProgressOp)Task.get_progress, task.opaque_ref));

                    progressDelegate(progress);
                }

                if (dataRxDelegate != null)
                {
                    dataRxDelegate(bytes);
                }
            };

            HTTP.FuncBool cancellingDelegate2 = (HTTP.FuncBool) delegate()
            {
                return(XenAdminConfigManager.Provider.ForcedExiting ||
                       cancellingDelegate != null && cancellingDelegate());
            };

            try
            {
                List <object> args = new List <object>();
                args.Add(dataCopiedDelegate);
                args.Add(cancellingDelegate2);
                args.Add(XenAdminConfigManager.Provider.GetProxyTimeout(timeout));
                args.Add(hostname);
                args.Add(XenAdminConfigManager.Provider.GetProxyFromSettings(connection));
                args.Add(path);
                args.Add(task.opaque_ref);  // task_id
                args.AddRange(p);
                f.DynamicInvoke(args.ToArray());
            }
            catch (Exception e)
            {
                log.DebugFormat("Caught exception doing HTTP GET from {0} to {1}", hostname, path);
                log.Debug(e, e);

                if (e is WebException && e.InnerException is IOException && Win32.GetHResult(e.InnerException as IOException) == Win32.ERROR_DISK_FULL)
                {
                    throw e.InnerException;
                }
                else if (e is CancelledException || e.InnerException is CancelledException)
                {
                    throw new XenAdmin.CancelledException();
                }
                else if (e.InnerException.Message == "Received error code HTTP/1.1 403 Forbidden\r\n from the server")
                {
                    // RBAC Failure
                    List <Role> roles = connection.Session.Roles;
                    roles.Sort();
                    throw new Exception(String.Format(Messages.RBAC_HTTP_FAILURE, roles[0].FriendlyName), e);
                }
                else
                {
                    throw e.InnerException;
                }
            }

            return(PollTaskForResult(connection, ref session, cancellingDelegate2, task));
        }
Example #23
0
        private void CreateHook()
        {
            uint threadId = Win32.GetWindowThreadProcessId(hWnd, IntPtr.Zero);

            hHook = Win32.SetWindowsHookEx(Win32.HookType.WH_CALLWNDPROC, wndProcDelegate, IntPtr.Zero, threadId);
        }
        /// <summary>
        /// Creates the render context provider. Must also create the OpenGL extensions.
        /// </summary>
        /// <param name="openGLVersion">The desired OpenGL version.</param>
        /// <param name="gl">The OpenGL context.</param>
        /// <param name="width">The width.</param>
        /// <param name="height">The height.</param>
        /// <param name="bitDepth">The bit depth.</param>
        /// <param name="parameter">The parameter</param>
        /// <returns></returns>
        public override bool Create(OpenGLVersion openGLVersion, OpenGL gl, int width, int height, int bitDepth, object parameter)
        {
            //  Call the base.
            base.Create(openGLVersion, gl, width, height, bitDepth, parameter);

            //    Create a new window class, as basic as possible.
            wndClass = new Win32.WNDCLASSEX();
            wndClass.Init();
            wndClass.style         = Win32.ClassStyles.HorizontalRedraw | Win32.ClassStyles.VerticalRedraw | Win32.ClassStyles.OwnDC;
            wndClass.lpfnWndProc   = wndProcDelegate;
            wndClass.cbClsExtra    = 0;
            wndClass.cbWndExtra    = 0;
            wndClass.hInstance     = IntPtr.Zero;
            wndClass.hIcon         = IntPtr.Zero;
            wndClass.hCursor       = IntPtr.Zero;
            wndClass.hbrBackground = IntPtr.Zero;
            wndClass.lpszMenuName  = null;
            wndClass.lpszClassName = "SharpGLRenderWindow";
            wndClass.hIconSm       = IntPtr.Zero;
            Win32.RegisterClassEx(ref wndClass);

            //    Create the window. Position and size it.
            windowHandle = Win32.CreateWindowEx(0,
                                                "SharpGLRenderWindow",
                                                "",
                                                Win32.WindowStyles.WS_CLIPCHILDREN | Win32.WindowStyles.WS_CLIPSIBLINGS | Win32.WindowStyles.WS_POPUP,
                                                0, 0, width, height,
                                                IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero);

            //    Get the window device context.
            deviceContextHandle = Win32.GetDC(windowHandle);

            //    Setup a pixel format.
            Win32.PIXELFORMATDESCRIPTOR pfd = new Win32.PIXELFORMATDESCRIPTOR();
            pfd.Init();
            pfd.nVersion     = 1;
            pfd.dwFlags      = Win32.PFD_DRAW_TO_WINDOW | Win32.PFD_SUPPORT_OPENGL | Win32.PFD_DOUBLEBUFFER;
            pfd.iPixelType   = Win32.PFD_TYPE_RGBA;
            pfd.cColorBits   = (byte)bitDepth;
            pfd.cDepthBits   = 16;
            pfd.cStencilBits = 8;
            pfd.iLayerType   = Win32.PFD_MAIN_PLANE;

            //    Match an appropriate pixel format
            int iPixelformat;

            if ((iPixelformat = Win32.ChoosePixelFormat(deviceContextHandle, pfd)) == 0)
            {
                return(false);
            }

            //    Sets the pixel format
            if (Win32.SetPixelFormat(deviceContextHandle, iPixelformat, pfd) == 0)
            {
                return(false);
            }

            //    Create the render context.
            renderContextHandle = Win32.wglCreateContext(deviceContextHandle);

            //  Make the context current.
            MakeCurrent();

            //  Update the context if required.
            UpdateContextVersion(gl);

            //  Return success.
            return(true);
        }
Example #25
0
        public static VerifyResult VerifyFile(string fileName, out string signerName)
        {
            VerifyResult result = VerifyResult.NoSignature;

            using (MemoryAlloc strMem = new MemoryAlloc(fileName.Length * 2 + 2))
            {
                WintrustFileInfo fileInfo = new WintrustFileInfo();

                strMem.WriteUnicodeString(0, fileName);
                strMem.WriteInt16(fileName.Length * 2, 0);

                fileInfo.Size     = Marshal.SizeOf(fileInfo);
                fileInfo.FilePath = strMem;

                WintrustData trustData = new WintrustData();

                trustData.Size             = Marshal.SizeOf(typeof(WintrustData));
                trustData.UIChoice         = 2; // WTD_UI_NONE
                trustData.UnionChoice      = 1; // WTD_CHOICE_FILE
                trustData.RevocationChecks = WtdRevocationChecks.None;
                trustData.ProvFlags        = WtdProvFlags.Safer;
                trustData.StateAction      = WtdStateAction.Verify;

                if (OSVersion.IsAboveOrEqual(WindowsVersion.Vista))
                {
                    trustData.ProvFlags |= WtdProvFlags.CacheOnlyUrlRetrieval;
                }

                using (MemoryAlloc mem = new MemoryAlloc(fileInfo.Size))
                {
                    mem.WriteStruct <WintrustFileInfo>(fileInfo);
                    trustData.UnionData = mem;

                    uint winTrustResult = Win32.WinVerifyTrust(IntPtr.Zero, WintrustActionGenericVerifyV2, ref trustData);

                    result = StatusToVerifyResult(winTrustResult);

                    try
                    {
                        if (result != VerifyResult.NoSignature)
                        {
                            signerName = GetSignerNameFromStateData(trustData.StateData);

                            return(result);
                        }
                    }
                    finally
                    {
                        // Close the state data.
                        trustData.StateAction = WtdStateAction.Close;
                        Win32.WinVerifyTrust(IntPtr.Zero, WintrustActionGenericVerifyV2, ref trustData);
                    }
                }
            }

            signerName = null;

            using (FileHandle sourceFile = FileHandle.CreateWin32(fileName, FileAccess.GenericRead, FileShareMode.Read,
                                                                  FileCreationDispositionWin32.OpenExisting))
            {
                byte[] hash       = new byte[256];
                int    hashLength = 256;

                if (!Win32.CryptCATAdminCalcHashFromFileHandle(sourceFile, ref hashLength, hash, 0))
                {
                    hash = new byte[hashLength];

                    if (!Win32.CryptCATAdminCalcHashFromFileHandle(sourceFile, ref hashLength, hash, 0))
                    {
                        return(VerifyResult.NoSignature);
                    }
                }

                StringBuilder memberTag = new StringBuilder(hashLength * 2);

                for (int i = 0; i < hashLength; i++)
                {
                    memberTag.Append(hash[i].ToString("X2"));
                }

                IntPtr catAdmin;

                if (!Win32.CryptCATAdminAcquireContext(out catAdmin, DriverActionVerify, 0))
                {
                    return(VerifyResult.NoSignature);
                }

                IntPtr catInfo = Win32.CryptCATAdminEnumCatalogFromHash(catAdmin, hash, hashLength, 0, IntPtr.Zero);

                if (catInfo == IntPtr.Zero)
                {
                    Win32.CryptCATAdminReleaseContext(catAdmin, 0);
                    return(VerifyResult.NoSignature);
                }

                CatalogInfo ci;

                if (!Win32.CryptCATCatalogInfoFromContext(catInfo, out ci, 0))
                {
                    Win32.CryptCATAdminReleaseCatalogContext(catAdmin, catInfo, 0);
                    Win32.CryptCATAdminReleaseContext(catAdmin, 0);
                    return(VerifyResult.NoSignature);
                }

                WintrustCatalogInfo wci = new WintrustCatalogInfo();

                wci.Size            = Marshal.SizeOf(wci);
                wci.CatalogFilePath = ci.CatalogFile;
                wci.MemberFilePath  = fileName;
                wci.MemberTag       = memberTag.ToString();

                WintrustData trustData = new WintrustData();

                trustData.Size             = Marshal.SizeOf(typeof(WintrustData));
                trustData.UIChoice         = 1;
                trustData.UnionChoice      = 2;
                trustData.RevocationChecks = WtdRevocationChecks.None;
                trustData.StateAction      = WtdStateAction.Verify;

                if (OSVersion.IsAboveOrEqual(WindowsVersion.Vista))
                {
                    trustData.ProvFlags = WtdProvFlags.CacheOnlyUrlRetrieval;
                }

                using (MemoryAlloc mem = new MemoryAlloc(wci.Size))
                {
                    mem.WriteStruct <WintrustCatalogInfo>(wci);

                    try
                    {
                        trustData.UnionData = mem;

                        uint winTrustResult = Win32.WinVerifyTrust(IntPtr.Zero, DriverActionVerify, ref trustData);

                        result = StatusToVerifyResult(winTrustResult);

                        if (result != VerifyResult.NoSignature)
                        {
                            signerName = GetSignerNameFromStateData(trustData.StateData);
                        }
                    }
                    finally
                    {
                        try
                        {
                            // Close the state data.
                            trustData.StateAction = WtdStateAction.Close;
                            Win32.WinVerifyTrust(IntPtr.Zero, DriverActionVerify, ref trustData);
                        }
                        finally
                        {
                            Win32.CryptCATAdminReleaseCatalogContext(catAdmin, catInfo, 0);
                            Win32.CryptCATAdminReleaseContext(catAdmin, 0);
                            mem.DestroyStruct <WintrustCatalogInfo>();
                        }
                    }
                }
            }

            return(result);
        }
Example #26
0
        /// <summary>
        /// Execute a HandBrakeCLI process.
        /// </summary>
        /// <param name="encodeQueueTask">
        /// The encodeQueueTask.
        /// </param>
        /// <param name="enableLogging">
        /// Enable Logging. When Disabled we onlt parse Standard Ouput for progress info. Standard Error log data is ignored.
        /// </param>
        public void Start(QueueTask encodeQueueTask, bool enableLogging)
        {
            try
            {
                QueueTask queueTask = encodeQueueTask;

                if (queueTask == null)
                {
                    throw new ArgumentNullException("QueueTask was null");
                }

                if (IsEncoding)
                {
                    throw new Exception("HandBrake is already encodeing.");
                }

                IsEncoding = true;

                if (enableLogging)
                {
                    try
                    {
                        SetupLogging(queueTask);
                    }
                    catch (Exception)
                    {
                        IsEncoding = false;
                        throw;
                    }
                }

                if (Init.PreventSleep)
                {
                    Win32.PreventSleep();
                }

                string           handbrakeCLIPath = Path.Combine(Application.StartupPath, "HandBrakeCLI.exe");
                ProcessStartInfo cliStart         = new ProcessStartInfo(handbrakeCLIPath, queueTask.Query)
                {
                    RedirectStandardOutput = true,
                    RedirectStandardError  = enableLogging ? true : false,
                    UseShellExecute        = false,
                    CreateNoWindow         = !Init.ShowCliForInGuiEncodeStatus ? true : false
                };

                this.HbProcess = new Process {
                    StartInfo = cliStart
                };

                this.HbProcess.Start();

                if (enableLogging)
                {
                    this.HbProcess.ErrorDataReceived += HbProcErrorDataReceived;
                    this.HbProcess.BeginErrorReadLine();
                }

                this.processId     = HbProcess.Id;
                this.processHandle = HbProcess.Handle;

                // Set the process Priority
                if (this.processId != -1)
                {
                    this.HbProcess.EnableRaisingEvents = true;
                    this.HbProcess.Exited += this.HbProcessExited;
                }

                // Set the Process Priority
                switch (Init.ProcessPriority)
                {
                case "Realtime":
                    this.HbProcess.PriorityClass = ProcessPriorityClass.RealTime;
                    break;

                case "High":
                    this.HbProcess.PriorityClass = ProcessPriorityClass.High;
                    break;

                case "Above Normal":
                    this.HbProcess.PriorityClass = ProcessPriorityClass.AboveNormal;
                    break;

                case "Normal":
                    this.HbProcess.PriorityClass = ProcessPriorityClass.Normal;
                    break;

                case "Low":
                    this.HbProcess.PriorityClass = ProcessPriorityClass.Idle;
                    break;

                default:
                    this.HbProcess.PriorityClass = ProcessPriorityClass.BelowNormal;
                    break;
                }

                // Fire the Encode Started Event
                if (this.EncodeStarted != null)
                {
                    this.EncodeStarted(this, new EventArgs());
                }
            }
            catch (Exception exc)
            {
                if (this.EncodeCompleted != null)
                {
                    this.EncodeCompleted(this, new EncodeCompletedEventArgs(false, exc, "An Error has occured in EncodeService.Run()"));
                }
            }
        }
Example #27
0
 //ISocketWithTimeoutClient これらはこのウィンドウとは別のスレッドで実行されるので慎重に
 public void SuccessfullyExit(object result)
 {
     _result = (ConnectionTag)result;
     //_result.SetServerInfo(((TCPTerminalParam)_result.Param).Host, swt.IPAddress);
     Win32.SendMessage(_savedHWND, GConst.WMG_ASYNCCONNECT, IntPtr.Zero, new IntPtr(1));
 }
Example #28
0
 /// <summary>
 /// Sends a win32 message to set scrollbars position.
 /// </summary>
 /// <param name="point">a POINT conatining H/Vscrollbar scrollpos.</param>
 private unsafe void SetScrollPos(Win32.POINT point)
 {
     IntPtr ptr = new IntPtr(&point);
     Win32.SendMessage(richTextBox1.Handle, Win32.EM_SETSCROLLPOS, 0, ptr);
 }
 public static bool ExistPlayDevice()
 {
     return(Win32.waveOutGetNumDevs() > 0 ? true : false);
 }
Example #30
0
			public void PopulateBITMAPINFOHEADER32(ref Win32.BITMAPINFOHEADER bmih)
			{
				bmih.Init();
				bmih.biPlanes = 1;
				bmih.biBitCount = 32;
				bmih.biHeight = height;
				bmih.biWidth = width;
				bmih.biSizeImage = (uint)(4 * width * height);
			}
Example #31
0
			public static CodecToken TakePossession(Win32.AVICOMPRESSOPTIONS comprOptions)
			{
				CodecToken ret = new CodecToken();
				ret.allocated = true;
				ret.comprOptions = comprOptions;
				ret.codec = Win32.decode_mmioFOURCC(comprOptions.fccHandler);
				return ret;
			}
 public void Dispose() => Win32.UnhookWinEvent(hookId);
 /// <summary>
 /// With this class you are able to listen to global window event(s).
 /// </summary>
 /// <param name="winEvent"><see cref="WINEVENT"/></param>
 /// <param name="dwFlags"><see cref="WINEVENT.WINEVENT_OUTOFCONTEXT"/> | <see cref="WINEVENT.WINEVENT_SKIPOWNPROCESS"/></param>
 public WindowEventListener(uint winEvent, uint dwFlags)
 {
     win32EventHandler = new Win32.WinEventDelegate(desktop_win32EventRaised);
     hookId            = Win32.SetWinEventHook(winEvent, winEvent, IntPtr.Zero, win32EventHandler, 0, 0, dwFlags);
 }
Example #34
0
 public void ConnectionFailed(string message)
 {
     _errorMessage = message;
     Win32.SendMessage(_savedHWND, GConst.WMG_ASYNCCONNECT, IntPtr.Zero, IntPtr.Zero);
 }
 /// <summary>
 /// When overridden in a derived class, executes the code required to free the handle.
 /// </summary>
 /// <returns>
 /// <see langword="true"/> if the handle is released successfully; otherwise, in the event
 /// of a catastrophic failure, <see langword="false"/>. In this case, it generates a
 /// releaseHandleFailed MDA Managed Debugging Assistant.
 /// </returns>
 protected override bool ReleaseHandle()
 {
     return(Win32.FreeLibrary(handle));
 }
Example #36
0
 protected override void DisposeObject(bool disposing)
 {
     Win32.RtlDestroyQueryDebugBuffer(_buffer);
 }
 public static bool ExistRecordDevice()
 {
     return(Win32.waveInGetNumDevs() > 0 ? true : false);
 }
Example #38
0
        /// <summary>
        /// This method will use User32 code to capture the specified captureBounds from the screen
        /// </summary>
        /// <param name="captureBounds">Rectangle with the bounds to capture</param>
        /// <returns>Bitmap which is captured from the screen at the location specified by the captureBounds</returns>
        public static Bitmap CaptureRectangle(Rectangle captureBounds)
        {
            Bitmap returnBitmap = null;

            if (captureBounds.Height <= 0 || captureBounds.Width <= 0)
            {
                LOG.Warn("Nothing to capture, ignoring!");
                return(null);
            }
            else
            {
                LOG.Debug("CaptureRectangle Called!");
            }
            // .NET GDI+ Solution, according to some post this has a GDI+ leak...
            // See http://connect.microsoft.com/VisualStudio/feedback/details/344752/gdi-object-leak-when-calling-graphics-copyfromscreen
            // Bitmap capturedBitmap = new Bitmap(captureBounds.Width, captureBounds.Height);
            // using (Graphics graphics = Graphics.FromImage(capturedBitmap)) {
            //	graphics.CopyFromScreen(captureBounds.Location, Point.Empty, captureBounds.Size, CopyPixelOperation.CaptureBlt);
            // }
            // capture.Image = capturedBitmap;
            // capture.Location = captureBounds.Location;

            using (SafeWindowDCHandle desktopDCHandle = SafeWindowDCHandle.fromDesktop()) {
                if (desktopDCHandle.IsInvalid)
                {
                    // Get Exception before the error is lost
                    Exception exceptionToThrow = CreateCaptureException("desktopDCHandle", captureBounds);
                    // throw exception
                    throw exceptionToThrow;
                }

                // create a device context we can copy to
                using (SafeCompatibleDCHandle safeCompatibleDCHandle = GDI32.CreateCompatibleDC(desktopDCHandle)) {
                    // Check if the device context is there, if not throw an error with as much info as possible!
                    if (safeCompatibleDCHandle.IsInvalid)
                    {
                        // Get Exception before the error is lost
                        Exception exceptionToThrow = CreateCaptureException("CreateCompatibleDC", captureBounds);
                        // throw exception
                        throw exceptionToThrow;
                    }
                    // Create BitmapInfoHeader for CreateDIBSection
                    BitmapInfoHeader bmi = new BitmapInfoHeader(captureBounds.Width, captureBounds.Height, 24);

                    // Make sure the last error is set to 0
                    Win32.SetLastError(0);

                    // create a bitmap we can copy it to, using GetDeviceCaps to get the width/height
                    IntPtr bits0;                     // not used for our purposes. It returns a pointer to the raw bits that make up the bitmap.
                    using (SafeDibSectionHandle safeDibSectionHandle = GDI32.CreateDIBSection(desktopDCHandle, ref bmi, BitmapInfoHeader.DIB_RGB_COLORS, out bits0, IntPtr.Zero, 0)) {
                        if (safeDibSectionHandle.IsInvalid)
                        {
                            // Get Exception before the error is lost
                            Exception exceptionToThrow = CreateCaptureException("CreateDIBSection", captureBounds);
                            exceptionToThrow.Data.Add("hdcDest", safeCompatibleDCHandle.DangerousGetHandle().ToInt32());
                            exceptionToThrow.Data.Add("hdcSrc", desktopDCHandle.DangerousGetHandle().ToInt32());

                            // Throw so people can report the problem
                            throw exceptionToThrow;
                        }
                        else
                        {
                            // select the bitmap object and store the old handle
                            using (SafeSelectObjectHandle selectObject = safeCompatibleDCHandle.SelectObject(safeDibSectionHandle)) {
                                // bitblt over (make copy)
                                GDI32.BitBlt(safeCompatibleDCHandle, 0, 0, captureBounds.Width, captureBounds.Height, desktopDCHandle, captureBounds.X, captureBounds.Y, CopyPixelOperation.SourceCopy | CopyPixelOperation.CaptureBlt);
                            }

                            // get a .NET image object for it
                            // A suggestion for the "A generic error occurred in GDI+." E_FAIL/0×80004005 error is to re-try...
                            bool success = false;
                            ExternalException exception = null;
                            for (int i = 0; i < 3; i++)
                            {
                                try {
                                    // Collect all screens inside this capture
                                    List <Screen> screensInsideCapture = new List <Screen>();
                                    foreach (Screen screen in Screen.AllScreens)
                                    {
                                        if (screen.Bounds.IntersectsWith(captureBounds))
                                        {
                                            screensInsideCapture.Add(screen);
                                        }
                                    }
                                    // Check all all screens are of an equal size
                                    bool offscreenContent = false;
                                    using (Region captureRegion = new Region(captureBounds)) {
                                        // Exclude every visible part
                                        foreach (Screen screen in screensInsideCapture)
                                        {
                                            captureRegion.Exclude(screen.Bounds);
                                        }
                                        // If the region is not empty, we have "offscreenContent"
                                        using (Graphics screenGraphics = Graphics.FromHwnd(User32.GetDesktopWindow())) {
                                            offscreenContent = !captureRegion.IsEmpty(screenGraphics);
                                        }
                                    }
                                    // Check if we need to have a transparent background, needed for offscreen content
                                    if (offscreenContent)
                                    {
                                        using (Bitmap tmpBitmap = Bitmap.FromHbitmap(safeDibSectionHandle.DangerousGetHandle())) {
                                            // Create a new bitmap which has a transparent background
                                            returnBitmap = ImageHelper.CreateEmpty(tmpBitmap.Width, tmpBitmap.Height, PixelFormat.Format32bppArgb, Color.Transparent, tmpBitmap.HorizontalResolution, tmpBitmap.VerticalResolution);
                                            // Content will be copied here
                                            using (Graphics graphics = Graphics.FromImage(returnBitmap)) {
                                                // For all screens copy the content to the new bitmap
                                                foreach (Screen screen in Screen.AllScreens)
                                                {
                                                    Rectangle screenBounds = screen.Bounds;
                                                    // Make sure the bounds are offsetted to the capture bounds
                                                    screenBounds.Offset(-captureBounds.X, -captureBounds.Y);
                                                    graphics.DrawImage(tmpBitmap, screenBounds, screenBounds.X, screenBounds.Y, screenBounds.Width, screenBounds.Height, GraphicsUnit.Pixel);
                                                }
                                            }
                                        }
                                    }
                                    else
                                    {
                                        // All screens, which are inside the capture, are of equal size
                                        // assign image to Capture, the image will be disposed there..
                                        returnBitmap = Bitmap.FromHbitmap(safeDibSectionHandle.DangerousGetHandle());
                                    }
                                    // We got through the capture without exception
                                    success = true;
                                    break;
                                } catch (ExternalException ee) {
                                    LOG.Warn("Problem getting bitmap at try " + i + " : ", ee);
                                    exception = ee;
                                }
                            }
                            if (!success)
                            {
                                LOG.Error("Still couldn't create Bitmap!");
                                throw exception;
                            }
                        }
                    }
                }
            }
            return(returnBitmap);
        }
Example #39
0
 /// <summary>Compares two objects and returns a value indicating whether one is less than, equal to, or greater than the other.</summary>
 /// <returns>A signed integer that indicates the relative values of <paramref name="a" /> and <paramref name="b" />, as shown in the following table.Value Meaning Less than zero<paramref name="a" /> is less than <paramref name="b" />.Zero<paramref name="a" /> equals <paramref name="b" />.Greater than zero<paramref name="a" /> is greater than <paramref name="b" />.</returns>
 /// <param name="a">The first object to compare.</param>
 /// <param name="b">The second object to compare.</param>
 public int Compare(string a, string b)
 {
     return(Win32.StrCmpLogicalW(a, b));
 }
Example #40
0
        internal void DrawControl(Graphics g)
        {
            if (!Visible)
            {
                return;
            }
            //Rectangle TabControlArea = new Rectangle(2, 2, this.Width - 3, this.Height - 2);
            Rectangle TabControlArea = this.ClientRectangle;

            Rectangle TabArea = new Rectangle(3, 24, this.ClientRectangle.Width - 7, this.ClientRectangle.Height - 28);// this.DisplayRectangle;

            //----------------------------
            // fill client area
            Brush br = new SolidBrush(Shared.ControlBackColor);

            g.FillRectangle(br, TabControlArea);

            br.Dispose();
            //----------------------------

            //----------------------------
            // draw border
            int nDelta = SystemInformation.Border3DSize.Width;

            //yuterz
            //Pen border = new Pen(SystemColors.ControlDark);
            Pen border = new Pen(Shared.ControlBorderBackColor);

            //TabArea.Inflate(nDelta, nDelta);
            g.DrawRectangle(border, TabArea);
            // g.FillRectangle(new  this.TabArea);
            border.Dispose();
            //----------------------------


            //----------------------------
            // clip region for drawing tabs
            Region    rsaved = g.Clip;
            Rectangle rreg;

            int nWidth = TabArea.Width + nMargin;

            if (bUpDown)
            {
                // exclude updown control for painting
                if (Win32.IsWindowVisible(scUpDown.Handle))
                {
                    Rectangle rupdown = new Rectangle();
                    Win32.GetWindowRect(scUpDown.Handle, ref rupdown);
                    Rectangle rupdown2 = this.RectangleToClient(rupdown);

                    nWidth = rupdown2.X;
                }
            }

            rreg = new Rectangle(TabArea.Left, TabControlArea.Top, nWidth - nMargin, TabControlArea.Height);

            g.SetClip(rreg);

            // draw tabs
            for (int i = 0; i < this.TabCount; i++)
            {
                DrawTab(g, this.TabPages[i], i);
            }

            g.Clip = rsaved;
            //----------------------------

            //yuterz
            //----------------------------
            // draw background to cover flat border areas
            if (this.SelectedTab != null)
            {
                TabPage tabPage = this.SelectedTab;
                Color   color   = tabPage.BackColor;
                //border = new Pen(color);
                border = new Pen(Color.Green);
                TabArea.Offset(1, 1);
                TabArea.Width  -= 2;
                TabArea.Height -= 2;

                //g.DrawRectangle(border, TabArea);
                TabArea.Width  -= 1;
                TabArea.Height -= 1;
                // g.DrawRectangle(border, TabArea);

                border.Dispose();
            }

            //----------------------------
        }
Example #41
0
        /// ------------------------------------------------------------------------------------
        /// <summary>
        /// Translate mouse buttons received from a Win API mouse message to .NET mouse buttons
        /// </summary>
        /// <param name="winMouseButtons">Windows mouse buttons</param>
        /// <returns>.NET mouse buttons</returns>
        /// ------------------------------------------------------------------------------------
        public static MouseButtons TranslateMouseButtons(Win32.MouseButtons winMouseButtons)
        {
            MouseButtons mouseButton = MouseButtons.None;
            if ((winMouseButtons & Win32.MouseButtons.MK_LBUTTON) == Win32.MouseButtons.MK_LBUTTON)
                mouseButton |= MouseButtons.Left;
            if ((winMouseButtons & Win32.MouseButtons.MK_RBUTTON) == Win32.MouseButtons.MK_RBUTTON)
                mouseButton |= MouseButtons.Right;
            if ((winMouseButtons & Win32.MouseButtons.MK_MBUTTON) == Win32.MouseButtons.MK_MBUTTON)
                mouseButton |= MouseButtons.Middle;
            if ((winMouseButtons & Win32.MouseButtons.MK_XBUTTON1) == Win32.MouseButtons.MK_XBUTTON1)
                mouseButton |= MouseButtons.XButton1;
            if ((winMouseButtons & Win32.MouseButtons.MK_XBUTTON2) == Win32.MouseButtons.MK_XBUTTON2)
                mouseButton |= MouseButtons.XButton2;

            return mouseButton;
        }
    public static Color GetPixelColor(this Control c, int x, int y)
    {
        var screenCoords = c.PointToScreen(new Point(x, y));

        return(Win32.GetPixelColor(screenCoords.X, screenCoords.Y));
    }
Example #43
0
        internal void DrawIcons(Graphics g)
        {
            if ((leftRightImages == null) || (leftRightImages.Images.Count != 4))
            {
                return;
            }

            //----------------------------
            // calc positions
            Rectangle TabControlArea = this.ClientRectangle;

            Rectangle r0 = new Rectangle();

            Win32.GetClientRect(scUpDown.Handle, ref r0);

            // Brush br = new SolidBrush(SystemColors.Control);
            Brush br = new SolidBrush(Shared.ControlBackColor);

            g.FillRectangle(br, r0);
            br.Dispose();

            Pen       border  = new Pen(Shared.ControlBorderBackColor);
            Rectangle rborder = new Rectangle(1, 1, 36, 19);

            rborder.Inflate(-1, -1);
            g.DrawRectangle(border, rborder);
            border.Dispose();

            int nMiddle = (r0.Width / 2);
            int nTop    = (r0.Height - 16) / 2;
            int nLeft   = (nMiddle - 16) / 2;

            Rectangle r1 = new Rectangle(nLeft, nTop, 16, 16);
            Rectangle r2 = new Rectangle(nMiddle + nLeft, nTop, 16, 16);
            //----------------------------

            //----------------------------
            // draw buttons
            Image img = leftRightImages.Images[1];

            if (img != null)
            {
                if (this.TabCount > 0)
                {
                    Rectangle r3 = this.GetTabRect(0);
                    if (r3.Left < TabControlArea.Left)
                    {
                        g.DrawImage(img, r1);
                    }
                    else
                    {
                        img = leftRightImages.Images[3];
                        if (img != null)
                        {
                            g.DrawImage(img, r1);
                        }
                    }
                }
            }

            img = leftRightImages.Images[0];
            if (img != null)
            {
                if (this.TabCount > 0)
                {
                    Rectangle r3 = this.GetTabRect(this.TabCount - 1);
                    if (r3.Right > (TabControlArea.Width - r0.Width))
                    {
                        g.DrawImage(img, r2);
                    }
                    else
                    {
                        img = leftRightImages.Images[2];
                        if (img != null)
                        {
                            g.DrawImage(img, r2);
                        }
                    }
                }
            }
            //----------------------------
        }
Example #44
0
 public Font(int height, string fontName)
 {
     this._hFont = Win32.CreateFont(height, 0, 0, 0, 0, 0U, 0U, 0U, 0U, 2U, 0U, 0U, 0U, fontName);
 }
Example #45
0
        /// <summary>
        /// Retrieves the names of all loaded modules in the process, their base
        /// address and size on disk.
        /// </summary>
        ///
        /// <param name="pid">
        /// Id of the process.
        /// </param>
        private void GetModuleDetails(int pid)
        {
            const Win32.SnapshotFlags flags = Win32.SnapshotFlags.TH32CS_SNAPMODULE |
                                              Win32.SnapshotFlags.TH32CS_SNAPMODULE32;

            var hModuleSnap = Win32.CreateToolhelp32Snapshot(flags, pid);

            if (hModuleSnap == INVALID_HANDLE_VALUE)
            {
                return;
            }

            var modEntry = new Win32.MODULEENTRY32()
            {
                dwSize       = (uint)Marshal.SizeOf(typeof(Win32.MODULEENTRY32)),
                th32ModuleID = 0
            };

            if (!Win32.Module32First(hModuleSnap, ref modEntry))
            {
                Win32.CloseHandle(hModuleSnap);
                return;
            }

            do
            {
                try
                {
                    var modPath = modEntry.szExePath;
                    var modInfo = FileVersionInfo.GetVersionInfo(modPath);
                    var modSize = new FileInfo(modPath).Length;
                    var lvi     = new ListViewItem(modEntry.szModule)
                    {
                        Tag         = modInfo.FileName,
                        ToolTipText = modInfo.FileName + "\n" +
                                      modInfo.LegalCopyright + "\n" +
                                      modInfo.FileDescription + "\n" +
                                      modInfo.ProductVersion
                    };
                    lvi.SubItems.Add("0x" + modEntry.modBaseAddr.ToString("X4"));
                    lvi.SubItems.Add(FormatByteSize(modSize));
                    LV_Module.Items.Add(lvi);
                }
                catch
                {
                    break;
                }
            }while (Win32.Module32Next(hModuleSnap, ref modEntry));

            // Close the object
            Win32.CloseHandle(hModuleSnap);

            /* Sort the items and remove the duplicate module name. The
            ** duplication happens because SnapshotFlags searches for both 32-bit
            ** and 64-bit modules. Therefore, it adds the main module from both
            ** TH32CS_SNAPMODULE and TH32CS_SNAPMODULE32.
            */
            LV_Module.Items[0].ForeColor = Color.Red;
            LV_Module.Sorting            = SortOrder.Ascending;
            for (var i = 0; i < LV_Module.Items.Count - 1; i++)
            {
                if (LV_Module.Items[i].Tag.Equals(LV_Module.Items[i + 1].Tag))
                {
                    LV_Module.Items[i].ForeColor = Color.Red;
                    LV_Module.Items[i + 1].Remove();
                    i--;
                }
                moduleCount = i;
            }

            SetModuleCount();
        }
Example #46
0
        public unsafe Bitmap Apply(Bitmap srcImg)
        {
            int num5;

            if (srcImg.PixelFormat != PixelFormat.Format8bppIndexed)
            {
                throw new ArgumentException();
            }
            int        width      = srcImg.Width;
            int        height     = srcImg.Height;
            BitmapData bitmapdata = srcImg.LockBits(new Rectangle(0, 0, width, height), ImageLockMode.ReadOnly, PixelFormat.Format8bppIndexed);
            Bitmap     bitmap     = GodLesZ.Library.Imaging.Image.CreateGrayscaleImage(width, height);
            BitmapData data2      = bitmap.LockBits(new Rectangle(0, 0, width, height), ImageLockMode.ReadWrite, PixelFormat.Format8bppIndexed);
            int        stride     = data2.Stride;
            int        num4       = stride - width;

            Win32.memset(data2.Scan0, this.bg, stride * height);
            byte *numPtr  = (byte *)bitmapdata.Scan0.ToPointer();
            byte *numPtr2 = (byte *)data2.Scan0.ToPointer();
            byte *numPtr3 = numPtr;
            byte *numPtr4 = numPtr2;

            for (int i = 0; i < height; i++)
            {
                num5 = -1;
                int num7 = 0;
                while (num7 < width)
                {
                    if (num5 == -1)
                    {
                        if (numPtr3[0] == this.fg)
                        {
                            num5 = num7;
                        }
                    }
                    else if (numPtr3[0] != this.fg)
                    {
                        numPtr4[num5 + ((num7 - num5) >> 1)] = this.fg;
                        num5 = -1;
                    }
                    num7++;
                    numPtr3++;
                }
                if (num5 != -1)
                {
                    numPtr4[num5 + ((width - num5) >> 1)] = this.fg;
                }
                numPtr3 += num4;
                numPtr4 += stride;
            }
            for (int j = 0; j < width; j++)
            {
                numPtr3 = numPtr + j;
                numPtr4 = numPtr2 + j;
                num5    = -1;
                int num9 = 0;
                while (num9 < height)
                {
                    if (num5 == -1)
                    {
                        if (numPtr3[0] == this.fg)
                        {
                            num5 = num9;
                        }
                    }
                    else if (numPtr3[0] != this.fg)
                    {
                        numPtr4[stride * (num5 + ((num9 - num5) >> 1))] = this.fg;
                        num5 = -1;
                    }
                    num9++;
                    numPtr3 += stride;
                }
                if (num5 != -1)
                {
                    numPtr4[stride * (num5 + ((height - num5) >> 1))] = this.fg;
                }
            }
            bitmap.UnlockBits(data2);
            srcImg.UnlockBits(bitmapdata);
            return(bitmap);
        }
        private void WmGetMinMaxInfo(IntPtr hwnd, IntPtr lParam)
        {
            // MINMAXINFO structure
            Win32.MINMAXINFO mmi = (Win32.MINMAXINFO)Marshal.PtrToStructure(lParam, typeof(Win32.MINMAXINFO));

            // Get handle for nearest monitor to this window
            WindowInteropHelper wih = new WindowInteropHelper(this);
            IntPtr hMonitor         = Win32.MonitorFromWindow(wih.Handle, Win32.MONITOR_DEFAULTTONEAREST);

            // Get monitor info
            Win32.MONITORINFOEX monitorInfo = new Win32.MONITORINFOEX();
            monitorInfo.cbSize = Marshal.SizeOf(monitorInfo);
            Win32.GetMonitorInfo(new HandleRef(this, hMonitor), monitorInfo);

            // Get HwndSource
            HwndSource source = HwndSource.FromHwnd(wih.Handle);

            if (source == null)
            {
                // Should never be null
                throw new Exception("Cannot get HwndSource instance.");
            }
            if (source.CompositionTarget == null)
            {
                // Should never be null
                throw new Exception("Cannot get HwndTarget instance.");
            }

            // Get transformation matrix

            //取消了DPI相关转换
            //Matrix matrix = source.CompositionTarget.TransformFromDevice;

            // Convert working area
            Win32.RECT workingArea        = monitorInfo.rcWork;
            Point      dpiIndependentSize =
                new Point(//注释DPI转换相关
                    workingArea.Right - workingArea.Left,
                    workingArea.Bottom - workingArea.Top
                    );
            //Point dpiIndependentSize =
            //    matrix.Transform(new Point(
            //            workingArea.Right - workingArea.Left,
            //            workingArea.Bottom - workingArea.Top
            //            ));

            // Convert minimum size
            Point dpiIndenpendentTrackingSize = new Point(//取消DPI相关转换
                this.MinWidth,
                this.MinHeight
                );

            //Point dpiIndenpendentTrackingSize = matrix.Transform(new Point(
            //    this.MinWidth,
            //    this.MinHeight
            //    ));

            // Set the maximized size of the window
            mmi.ptMaxSize.x = (int)dpiIndependentSize.X;
            mmi.ptMaxSize.y = (int)dpiIndependentSize.Y;

            // Set the position of the maximized window
            mmi.ptMaxPosition.x = 0;
            mmi.ptMaxPosition.y = 0;

            // Set the minimum tracking size
            mmi.ptMinTrackSize.x = (int)dpiIndenpendentTrackingSize.X;
            mmi.ptMinTrackSize.y = (int)dpiIndenpendentTrackingSize.Y;

            Marshal.StructureToPtr(mmi, lParam, true);
        }
Example #48
0
        // Thread entry point
        public void WorkerThread()
        {
            // grabber
            Grabber grabber = new Grabber(this);

            // objects
            object graphObj   = null;
            object sourceObj  = null;
            object grabberObj = null;

            // interfaces
            IGraphBuilder  graph       = null;
            IBaseFilter    sourceBase  = null;
            IBaseFilter    grabberBase = null;
            ISampleGrabber sg          = null;
            IMediaControl  mc          = null;

            try
            {
                // Get type for filter graph
                Type srvType = Type.GetTypeFromCLSID(Clsid.FilterGraph);
                if (srvType == null)
                {
                    throw new ApplicationException("Failed creating filter graph");
                }

                // create filter graph
                graphObj = Activator.CreateInstance(srvType);
                graph    = (IGraphBuilder)graphObj;

                // ----
                UCOMIBindCtx bindCtx = null;
                UCOMIMoniker moniker = null;
                int          n       = 0;

                // create bind context
                if (Win32.CreateBindCtx(0, out bindCtx) == 0)
                {
                    // convert moniker`s string to a moniker
                    if (Win32.MkParseDisplayName(bindCtx, source, ref n, out moniker) == 0)
                    {
                        // get device base filter
                        Guid filterId = typeof(IBaseFilter).GUID;
                        moniker.BindToObject(null, null, ref filterId, out sourceObj);

                        Marshal.ReleaseComObject(moniker);
                        moniker = null;
                    }
                    Marshal.ReleaseComObject(bindCtx);
                    bindCtx = null;
                }
                // ----

                if (sourceObj == null)
                {
                    throw new ApplicationException("Failed creating device object for moniker");
                }

                sourceBase = (IBaseFilter)sourceObj;

                // Get type for sample grabber
                srvType = Type.GetTypeFromCLSID(Clsid.SampleGrabber);
                if (srvType == null)
                {
                    throw new ApplicationException("Failed creating sample grabber");
                }

                // create sample grabber
                grabberObj  = Activator.CreateInstance(srvType);
                sg          = (ISampleGrabber)grabberObj;
                grabberBase = (IBaseFilter)grabberObj;

                // add source filter to graph
                graph.AddFilter(sourceBase, "source");
                graph.AddFilter(grabberBase, "grabber");

                // set media type
                AMMediaType mt = new AMMediaType();
                mt.majorType = MediaType.Video;
                mt.subType   = MediaSubType.RGB24;
                sg.SetMediaType(mt);

                // connect pins
                if (graph.Connect(DSTools.GetOutPin(sourceBase, 0), DSTools.GetInPin(grabberBase, 0)) < 0)
                {
                    throw new ApplicationException("Failed connecting filters");
                }

                // get media type
                if (sg.GetConnectedMediaType(mt) == 0)
                {
                    VideoInfoHeader vih = (VideoInfoHeader)Marshal.PtrToStructure(mt.formatPtr, typeof(VideoInfoHeader));

                    System.Diagnostics.Debug.WriteLine("width = " + vih.BmiHeader.Width + ", height = " + vih.BmiHeader.Height);
                    grabber.Width  = vih.BmiHeader.Width;
                    grabber.Height = vih.BmiHeader.Height;
                    mt.Dispose();
                }

                // render
                graph.Render(DSTools.GetOutPin(grabberBase, 0));

                //
                sg.SetBufferSamples(false);
                sg.SetOneShot(false);
                sg.SetCallback(grabber, 1);

                // window
                IVideoWindow win = (IVideoWindow)graphObj;
                win.put_AutoShow(false);
                win = null;


                // get media control
                mc = (IMediaControl)graphObj;

                // run
                mc.Run();

                while (!stopEvent.WaitOne(0, true))
                {
                    Thread.Sleep(100);
                }
                mc.StopWhenReady();
            }
            // catch any exceptions
            catch (Exception e)
            {
                System.Diagnostics.Debug.WriteLine("----: " + e.Message);
            }
            // finalization block
            finally
            {
                // release all objects
                mc          = null;
                graph       = null;
                sourceBase  = null;
                grabberBase = null;
                sg          = null;

                if (graphObj != null)
                {
                    Marshal.ReleaseComObject(graphObj);
                    graphObj = null;
                }
                if (sourceObj != null)
                {
                    Marshal.ReleaseComObject(sourceObj);
                    sourceObj = null;
                }
                if (grabberObj != null)
                {
                    Marshal.ReleaseComObject(grabberObj);
                    grabberObj = null;
                }
            }
        }
 static private IntPtr WndProc(IntPtr hWnd, uint msg, IntPtr wParam, IntPtr lParam)
 {
     return(Win32.DefWindowProc(hWnd, msg, wParam, lParam));
 }
Example #50
0
 public Font(string fontName)
 {
     this._hFont = Win32.CreateFont(0, 0, 0, 0, 0, 0U, 0U, 0U, 0U, 2U, 0U, 0U, 0U, fontName);
 }
Example #51
0
 //发送消息
 private void sendmessage(int msg)
 {
     Win32 mywin32 = new Win32();
     mywin32.SendMsgToMainForm(hwnd.ToInt32(),msg);
 }
Example #52
0
        /// <summary>
        /// Finds the device.
        /// </summary>
        /// <param name="classGuid">The class GUID.</param>
        /// <returns>Device path.</returns>
        private static string FindDevice(Guid classGuid)
        {
            // 0x12 = DIGCF_PRESENT | DIGCF_DEVICEINTERFACE
            IntPtr handle    = Win32.SetupDiGetClassDevs(ref classGuid, 0, IntPtr.Zero, 0x12);
            int    lastError = Marshal.GetLastWin32Error();

            if (handle.ToInt32() == -1)
            {
                throw new Win32Exception(lastError);
            }

            string devicePath = null;

            for (int deviceIndex = 0; ; deviceIndex++)
            {
                Win32.DeviceInfoData deviceInfoData = new Win32.DeviceInfoData();
                deviceInfoData.Size = Marshal.SizeOf(deviceInfoData);

                if (!Win32.SetupDiEnumDeviceInfo(handle, deviceIndex, ref deviceInfoData))
                {
                    // out of devices or do we have an error?
                    lastError = Marshal.GetLastWin32Error();
                    if (lastError != 0x0103 && lastError != 0x007E)
                    {
                        Win32.SetupDiDestroyDeviceInfoList(handle);
                        throw new Win32Exception(lastError);
                    }

                    Win32.SetupDiDestroyDeviceInfoList(handle);
                    break;
                }

                Win32.DeviceInterfaceData deviceInterfaceData = new Win32.DeviceInterfaceData();
                deviceInterfaceData.Size = Marshal.SizeOf(deviceInterfaceData);

                if (!Win32.SetupDiEnumDeviceInterfaces(handle, ref deviceInfoData, ref classGuid, 0, ref deviceInterfaceData))
                {
                    Win32.SetupDiDestroyDeviceInfoList(handle);
                    throw new Win32Exception(Marshal.GetLastWin32Error());
                }

                uint cbData = 0;

                if (!Win32.SetupDiGetDeviceInterfaceDetail(handle, ref deviceInterfaceData, IntPtr.Zero, 0, ref cbData, IntPtr.Zero) && cbData == 0)
                {
                    Win32.SetupDiDestroyDeviceInfoList(handle);
                    throw new Win32Exception(Marshal.GetLastWin32Error());
                }

                Win32.DeviceInterfaceDetailData deviceInterfaceDetailData = new Win32.DeviceInterfaceDetailData
                {
                    Size = 5
                };

                if (!Win32.SetupDiGetDeviceInterfaceDetail(handle, ref deviceInterfaceData, ref deviceInterfaceDetailData, cbData,
                                                           IntPtr.Zero, IntPtr.Zero))
                {
                    Win32.SetupDiDestroyDeviceInfoList(handle);
                    throw new Win32Exception(Marshal.GetLastWin32Error());
                }

                if (deviceInterfaceDetailData.DevicePath.IndexOf(DevicePathVidPid, StringComparison.OrdinalIgnoreCase) != -1)
                {
                    Win32.SetupDiDestroyDeviceInfoList(handle);
                    devicePath = deviceInterfaceDetailData.DevicePath;
                    break;
                }
            }

            return(devicePath);
        }
Example #53
0
			public void PopulateWAVEFORMATEX(ref Win32.WAVEFORMATEX wfex)
			{
				int bytes = 0;
				if (a_bits == 16) bytes = 2;
				else if (a_bits == 8) bytes = 1;
				else throw new InvalidOperationException("only 8/16 bits audio are supported by AviWriter and you chose: " + a_bits);
				if (a_channels == 1) { }
				else if (a_channels == 2) { }
				else throw new InvalidOperationException("only 1/2 channels audio are supported by AviWriter and you chose: " + a_channels);

				wfex.Init();
				wfex.nBlockAlign = (ushort)(bytes * a_channels);
				wfex.nChannels = (ushort)a_channels;
				wfex.wBitsPerSample = (ushort)a_bits;
				wfex.wFormatTag = Win32.WAVE_FORMAT_PCM;
				wfex.nSamplesPerSec = (uint)a_samplerate;
				wfex.nAvgBytesPerSec = (uint)(wfex.nBlockAlign * a_samplerate);
			}
        /// <summary>
        /// Returns account name for the SID
        /// </summary>
        public static string LookupAccount(string systemName, SecurityIdentifier accountSid)
        {
            // parameters validation
            if (accountSid == null)
            {
                throw new ArgumentNullException("accountSid");
            }

            uint   cbAccountName = 256;
            IntPtr pAccountName  = IntPtr.Zero;

            uint   cbDomainName = 256;
            IntPtr pDomainName  = IntPtr.Zero;

            try
            {
                while (true)
                {
                    // allocate buffers
                    pAccountName = Win32.LocalAlloc(Win32.LMEM_FIXED, cbAccountName);
                    pDomainName  = Win32.LocalAlloc(Win32.LMEM_FIXED, cbDomainName);

                    if ((pAccountName == IntPtr.Zero) || (pDomainName == IntPtr.Zero))
                    {
                        throw new Win32Exception(Marshal.GetLastWin32Error());
                    }

                    // lookup for account
                    int accountType;
                    if (SecurityNative.LookupAccountSid(
                            systemName,
                            accountSid.Handle,
                            pAccountName,
                            ref cbAccountName,
                            pDomainName,
                            ref cbDomainName,
                            out accountType))
                    {
                        return(Marshal.PtrToStringUni(pDomainName) + "\\" + Marshal.PtrToStringUni(pAccountName));
                    }
                    else
                    {
                        int error = Marshal.GetLastWin32Error();
                        if (error != Win32.ERROR_OUTOFMEMORY)
                        {
                            throw new Win32Exception(error);
                        }
                    }
                }
            }
            finally
            {
                if (pAccountName != IntPtr.Zero)
                {
                    Win32.LocalFree(pAccountName);
                }
                if (pDomainName != IntPtr.Zero)
                {
                    Win32.LocalFree(pDomainName);
                }
            }
        }
Example #55
0
			static int AVISaveOptions(IntPtr stream, ref Win32.AVICOMPRESSOPTIONS opts, IntPtr owner)
			{
				IntPtr mem = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(Win32.AVICOMPRESSOPTIONS)));

				Marshal.StructureToPtr(opts, mem, false);

				IntPtr[] streams = new[] { stream };
				IntPtr[] infPtrs = new[] { mem };

				int ret = Win32.AVISaveOptions(owner, 0, 1, streams, infPtrs);

				opts = (Win32.AVICOMPRESSOPTIONS)Marshal.PtrToStructure(mem, typeof(Win32.AVICOMPRESSOPTIONS));

				Marshal.FreeHGlobal(mem);

				return ret;
			}
        /// <summary>
        /// We need to do some P/Invoke magic to get the windows on screen
        /// </summary>
        /// <param name="unsorted"></param>
        /// <returns></returns>
        private IEnumerable <Window> SortWindowsTopToBottom(IEnumerable <Window> unsorted)
        {
            var byHandle = unsorted.ToDictionary(win =>
                                                 ((HwndSource)PresentationSource.FromVisual(win)).Handle);

            for (IntPtr hWnd = Win32.GetTopWindow(IntPtr.Zero); hWnd != IntPtr.Zero; hWnd = Win32.GetWindow(hWnd, Win32.GW_HWNDNEXT))
            {
                if (byHandle.ContainsKey(hWnd))
                {
                    yield return(byHandle[hWnd]);
                }
            }
        }
Example #57
0
		// ------------------------------------------------------------------
		#endregion

		#region Private member.
		// ------------------------------------------------------------------

		/// <summary>
		/// Called when [custom draw].
		/// </summary>
		/// <param name="idCtrl">The id CTRL.</param>
		/// <param name="nmcd">The NMCD.</param>
		/// <returns></returns>
		private int OnCustomDraw(
			int idCtrl,
			ref Win32.NMCUSTOMDRAW nmcd )
		{
			int nResult = 0;
			switch ( nmcd.dwDrawStage )
			{
				case (int)Win32.CDDS.CDDS_PREPAINT:
					nResult = interfaceCustDraw.OnPrePaint( idCtrl, ref nmcd );
					break;
				case (int)Win32.CDDS.CDDS_POSTPAINT:
					nResult = interfaceCustDraw.OnPostPaint( idCtrl, ref nmcd );
					break;
				case (int)Win32.CDDS.CDDS_PREERASE:
					nResult = interfaceCustDraw.OnPreErase( idCtrl, ref nmcd );
					break;
				case (int)Win32.CDDS.CDDS_POSTERASE:
					nResult = interfaceCustDraw.OnPostErase( idCtrl, ref nmcd );
					break;
				case (int)Win32.CDDS.CDDS_ITEMPREPAINT:
					nResult = interfaceCustDraw.OnItemPrePaint( idCtrl, ref nmcd );
					break;
				case (int)Win32.CDDS.CDDS_ITEMPOSTPAINT:
					nResult = interfaceCustDraw.OnItemPostPaint( idCtrl, ref nmcd );
					break;
				case (int)Win32.CDDS.CDDS_ITEMPREERASE:
					nResult = interfaceCustDraw.OnItemPreErase( idCtrl, ref nmcd );
					break;
				case (int)Win32.CDDS.CDDS_ITEMPOSTERASE:
					nResult = interfaceCustDraw.OnItemPostErase( idCtrl, ref nmcd );
					break;
				default:
					break;
			}
			return nResult;
		}
Example #58
0
 private void restoreConfigurationToolStripMenuItem_Click(object sender, EventArgs e)
 {
     Show();
     WindowState = m_ePrevWindowState;
     Win32.ShowTopmost(Handle);
 }
Example #59
0
 private static bool ConsoleCtrlHandler(Win32.CtrlType ctrlType)
 {
     const bool ignore = true;
     return ignore;
 }
Example #60
0
 private int Call(SciMsg msg, int wParam, int lParam)
 {
     return((int)Win32.SendMessage(_activeScintilla, msg, wParam, lParam));
 }