Posts Tagged Windows

Capture an Image of the Desktop, Specific Screen or Portion of a Screen with C#

So today is my birthday. It has been a wild ride this last 46 years. Lets hope that things continue to get better.

So this is my entire class for capturing screens and desktop appearance to an image file or to print them. I use this class quite often in my error management, saving or emailing the output should errors occur so I can get a good idea of what was going on at the time an error occurs. Why? Because often end users or business analysts, though they are trying their best, sometimes can’t describe in detail how to reproduce what occurred. I suggest using this in conjunction with a logging class as well so that you can replicate the steps needed. The image file is also very handy in reconstructing what a user was or was not doing which, as a coder, can literally save your ass on occasion. So here it is. It is well commented and pretty straight forward.

using System.Windows.Forms;
using System;
using System.Runtime.InteropServices;
using System.Drawing;
using System.Drawing.Imaging;

public class clsScreenCapture
{
    private System.Drawing.Printing.PrintDocument Pd = new System.Drawing.Printing.PrintDocument();
    private PictureBox PicForm = new PictureBox();

    /// Creates an Image object containing a screen shot of the entire desktop
    public Image CaptureScreen()
    {
        return CaptureWindow(User32.GetDesktopWindow());
    } //CaptureScreen
    /// Creates an Image object containing a screen shot of a specific window
    public Image CaptureWindow(IntPtr handle)
    {
        int SRCCOPY = 0xCC0020;
        // get te hDC of the target window
        IntPtr hdcSrc = User32.GetWindowDC(handle);
        // get the size
        User32.RECT windowRect = new User32.RECT();
        User32.GetWindowRect(handle, ref windowRect);
        int width = windowRect.right – windowRect.left;
        int height = windowRect.bottom – windowRect.top;
        // create a device context we can copy to
        IntPtr hdcDest = GDI32.CreateCompatibleDC(hdcSrc);
        // create a bitmap we can copy it to,
        // using GetDeviceCaps to get the width/height
        IntPtr hBitmap = GDI32.CreateCompatibleBitmap(hdcSrc, width, height);
        // select the bitmap object
        IntPtr hOld = GDI32.SelectObject(hdcDest, hBitmap);
        // bitblt over
        GDI32.BitBlt(hdcDest, 0, 0, width, height, hdcSrc, 0, 0, SRCCOPY);
        // restore selection
        GDI32.SelectObject(hdcDest, hOld);
        // clean up
        GDI32.DeleteDC(hdcDest);
        User32.ReleaseDC(handle, hdcSrc);

        // get a .NET image object for it
        Image img = Image.FromHbitmap(hBitmap);
        // free up the Bitmap object
        GDI32.DeleteObject(hBitmap);

        return img;
    } //CaptureWindow
    /// Captures a screen shot of a specific window, and saves it to a file
    public void CaptureWindowToFile(IntPtr handle, string filename, ImageFormat format)
    {
        Image img = CaptureWindow(handle);
        img.Save(filename, format);
    } //CaptureWindowToFile
    /// Captures a screen shot of a specific window, and saves it to a file
    public void CaptureWindowToPrinter(Form mfForm, ImageFormat format)
    {
        // Dim img As Image = CaptureScreen()

        Image img = CaptureWindow(mfForm.Handle);
        try
        {
            PicForm.Image = img;
            if (MessageBox.Show(“Press Yes to Print or No to Copy to your Clipboard (‘No’ will allow pasting into an email or Word document etc).”, “Print or Copy to Clipboard?”, MessageBoxButtons.YesNo) == DialogResult.Yes)
            {
                Pd.Print();
            }
            else
            {
                Clipboard.SetDataObject(img, true);
            }
        }
        catch (Exception ex)
        {
            string a = “vfdgsfg”;
        }
    } //CaptureWindowToPrinter
    private void pd_PrintPage(object sender, System.Drawing.Printing.PrintPageEventArgs e)
    {
        //—————————————————————
        // this procedure handles events raised by the printer object pd
        //—————————————————————
        e.Graphics.DrawImageUnscaled(PicForm.Image, 0, 0); //send image to printer – upper left position

        e.HasMorePages = false; //this is the last page to print

    }

    /// Captures a screen shot of the entire desktop, and saves it to a file
    public void CaptureScreenToFile(string filename, ImageFormat format)
    {
        Image img = CaptureScreen();
        img.Save(filename, format);
    } //CaptureScreenToFile
    public Bitmap CaptureDeskTopRectangle(Rectangle CapRect, int CapRectWidth, int CapRectHeight)
    {
        /// Returns BitMap of the region of the desktop, similar to CaptureWindow, but can be used to
        /// create a snapshot of the desktop when no handle is present, by passing in a rectangle
        /// Grabs snapshot of entire desktop, then crops it using the passed in rectangle’s coordinates
        clsScreenCapture SC = new clsScreenCapture();
        Bitmap bmpImage = new Bitmap(SC.CaptureScreen());
        Bitmap bmpCrop = new Bitmap(CapRectWidth, CapRectHeight, bmpImage.PixelFormat);
        Rectangle recCrop = new Rectangle(CapRect.X, CapRect.Y, CapRectWidth, CapRectHeight);
        Graphics gphCrop = Graphics.FromImage(bmpCrop);
        Rectangle recDest = new Rectangle(0, 0, CapRectWidth, CapRectHeight);
        gphCrop.DrawImage(bmpImage, recDest, recCrop.X, recCrop.Y, recCrop.Width, recCrop.Height, GraphicsUnit.Pixel);
        return bmpCrop;
    }
    /// Helper class containing Gdi32 API functions
    private class GDI32
    {
        public int SRCCOPY = 0xCC0020;
        // BitBlt dwRop parameter
        [System.Runtime.InteropServices.DllImport(“gdi32.dll”, EntryPoint=”BitBlt”, ExactSpelling=true, CharSet=System.Runtime.InteropServices.CharSet.Ansi, SetLastError=true)]
        public static extern Int32 BitBlt(IntPtr hDestDC, Int32 x, Int32 y, Int32 nWidth, Int32 nHeight, IntPtr hSrcDC, Int32 xSrc, Int32 ySrc, Int32 dwRop);

        [System.Runtime.InteropServices.DllImport(“gdi32.dll”, EntryPoint=”CreateCompatibleBitmap”, ExactSpelling=true, CharSet=System.Runtime.InteropServices.CharSet.Ansi, SetLastError=true)]
        public static extern IntPtr CreateCompatibleBitmap(IntPtr hdc, Int32 nWidth, Int32 nHeight);

        [System.Runtime.InteropServices.DllImport(“gdi32.dll”, EntryPoint=”CreateCompatibleDC”, ExactSpelling=true, CharSet=System.Runtime.InteropServices.CharSet.Ansi, SetLastError=true)]
        public static extern IntPtr CreateCompatibleDC(IntPtr hdc);

        [System.Runtime.InteropServices.DllImport(“gdi32.dll”, EntryPoint=”DeleteDC”, ExactSpelling=true, CharSet=System.Runtime.InteropServices.CharSet.Ansi, SetLastError=true)]
        public static extern Int32 DeleteDC(IntPtr hdc);

        [System.Runtime.InteropServices.DllImport(“gdi32.dll”, EntryPoint=”DeleteObject”, ExactSpelling=true, CharSet=System.Runtime.InteropServices.CharSet.Ansi, SetLastError=true)]
        public static extern Int32 DeleteObject(IntPtr hObject);

        [System.Runtime.InteropServices.DllImport(“gdi32.dll”, EntryPoint=”SelectObject”, ExactSpelling=true, CharSet=System.Runtime.InteropServices.CharSet.Ansi, SetLastError=true)]
        public static extern IntPtr SelectObject(IntPtr hdc, IntPtr hObject);
    } //GDI32
    /// Helper class containing User32 API functions
    public class User32
    {
        [StructLayout(LayoutKind.Sequential)]
        public struct RECT
        {
            public int left;
            public int top;
            public int right;
            public int bottom;
        } //RECT

        [System.Runtime.InteropServices.DllImport(“user32.dll”, EntryPoint=”GetDesktopWindow”, ExactSpelling=true, CharSet=System.Runtime.InteropServices.CharSet.Ansi, SetLastError=true)]
        public static extern IntPtr GetDesktopWindow();

        [System.Runtime.InteropServices.DllImport(“user32.dll”, EntryPoint=”GetWindowDC”, ExactSpelling=true, CharSet=System.Runtime.InteropServices.CharSet.Ansi, SetLastError=true)]
        public static extern IntPtr GetWindowDC(IntPtr hwnd);

        [System.Runtime.InteropServices.DllImport(“user32.dll”, EntryPoint=”ReleaseDC”, ExactSpelling=true, CharSet=System.Runtime.InteropServices.CharSet.Ansi, SetLastError=true)]
        public static extern Int32 ReleaseDC(IntPtr hwnd, IntPtr hdc);

        [System.Runtime.InteropServices.DllImport(“user32.dll”, EntryPoint=”GetWindowRect”, ExactSpelling=true, CharSet=System.Runtime.InteropServices.CharSet.Ansi, SetLastError=true)]
        public static extern Int32 GetWindowRect(IntPtr hwnd, ref RECT lpRect);

    } //User32

    public clsScreenCapture()
    {
        SubscribeToEvents();
    }

// event handler wireups:
    private bool EventsSubscribed = false;
    private void SubscribeToEvents()
    {
        if (EventsSubscribed)
            return;
        else
            EventsSubscribed = true;

        Pd.PrintPage += pd_PrintPage;
    }

}


Join me on Facebook

, , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , ,

Leave a comment

C# Application linked to SharePoint List Web Service

This weekend found myself knee deep in a crisis that my friend who had migrated from SharePoint 2003 to 2007 (there were reasons he couldn’t go to 2010). Simply put the migration from SharePoint 2003 to 2007 had broken his application (tracking program that submitted data to a 2003 SharePoint List) because in SharePoint 2007  you can’t do this while not on the actual server if you have “Web Page Security Validation” enabled. So for the code below you have to have SPWeb.AllowUnsafeUpdates = true; . Obviously not the ideal solution for my friend but we didn’t have time to screw around. Here is what I did….

 

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.Collections;
using System.Xml;
using System.ServiceModel;
using System.Net;
 
namespace Trigger_Tracker
{
    public partial class Form1 : Form
    {//form move on click and drag
        bool FormMoving;
        Point initialPoint;
        TriggerTrackerPictureBox frmPicture;
 
        public Form1()
        {//form move on click and drag
            InitializeComponent();
            comboBox1.SelectedIndex = 0;
            FormMoving = false;
 
            frmPicture = new TriggerTrackerPictureBox();
            frmPicture.localForm = this;
            frmPicture.Owner = this;
            frmPicture.Show();
            frmPicture.Width = 68;
            frmPicture.Height = 65;
            SetPositionOfPictureForm();
        }
 
        private void SetPositionOfPictureForm()
        {
            frmPicture.Top = this.Top + 26;
            frmPicture.Left = this.Left + 87;
        }
 
       
 
        private void TrackerButton(object sender, EventArgs e)
        {
            string listGUID = “A93E1A7E-67D0-4D7D-A4ED-803D7DFE684B”;
            string viewGUID = “6B2F3EF2-4B0C-41E1-B87E-0C3185B587DD”;
            //string viewGUID2 = “6B2F3EF2-4B0C-41E1-B87E-0C3185B587DD”;
 
            int ItemCounter = 1;
            ServiceList.Lists listService = new ServiceList.Lists();
           // RetentionLists.ListsSoapClient listService = new RetentionLists.ListsSoapClient();
 
            //////
           listService.Credentials = System.Net.CredentialCache.DefaultNetworkCredentials;
           //listService.ChannelFactory.Credentials.Windows.ClientCredential   = System.Net.CredentialCache.DefaultNetworkCredentials;
 
            XmlNode activeItemData = listService.GetListItems(listGUID, viewGUID, null, null, “100”, null);
            XmlDocument xDoc = new XmlDocument();
            string tmpString = activeItemData.InnerXml.Replace(“\r\r”, “”);
            xDoc.LoadXml(tmpString);
            XmlNamespaceManager nsManager = new XmlNamespaceManager(xDoc.NameTable);
            nsManager.AddNamespace(“z”, “#RowsetSchema”);
            nsManager.AddNamespace(“rs”, “urn:schemas-microsoft-com:rowset”);
 
            XmlNodeList xNode = xDoc.SelectNodes(“/rs:data/z:row”, nsManager);
 
            foreach (XmlNode tmpNode in xNode)
                ItemCounter++;
 
            StringBuilder strBuilder = new StringBuilder();
            strBuilder.Append(“<Method ID='” + ItemCounter + “‘ Cmd=’New’>”);
            strBuilder.Append(“<Field Name=’Attachments’>” + “0” + “</Field>”);
            strBuilder.Append(“<Field Name=’Title’>” + PolicyNumber.Text + “</Field>”);
            strBuilder.Append(“<Field Name=’Reason’>” + comboBox1.Text + “</Field>”);
            strBuilder.Append(“</Method>”);
 
            string strBatch = strBuilder.ToString();
 
            XmlDocument newDoc = new XmlDocument();
            XmlElement newElement = newDoc.CreateElement(“Batch”);
            newElement.SetAttribute(“OnError”, “Continue”);
            newElement.SetAttribute(“ViewName”, viewGUID);
            newElement.InnerXml = strBatch;
           
            XmlNode returnNode = listService.UpdateListItems(listGUID, newElement);
 
            this.comboBox1.Text = “Please Select….”;
            this.PolicyNumber.Text = “”;
            this.PolicyNumber.Mask = “0000000000”;
 
            comboBox1.Focus();
        }
 
       
 
 
        public void Form1_MouseUp(object sender, MouseEventArgs e)
        {//form move on click and drag
            FormMoving = false;
        }
 
        public void Form1_MouseMove(object sender, MouseEventArgs e)
        {//form move on click and drag
            if (FormMoving)
            {
                if ((Left + e.X – initialPoint.X) <= 0)
                    Left = 0;
                else if ((Right + e.X – initialPoint.X) >= Screen.PrimaryScreen.Bounds.Right)
                    Left = Screen.PrimaryScreen.Bounds.Right – Width;
                else
                    Left = Left + e.X – initialPoint.X;
                if ((Top + e.Y – initialPoint.Y) <= 0)
                    Top = 0;
                else if ((Bottom + e.Y – initialPoint.Y) >= Screen.PrimaryScreen.Bounds.Bottom)
                    Top = Screen.PrimaryScreen.Bounds.Bottom – Height;
                else
                    Top = Top + e.Y – initialPoint.Y;
            }
            SetPositionOfPictureForm();
        }
 
        public void Form1_MouseDown(object sender, MouseEventArgs e)
        {//form move on click and drag
            FormMoving = true;
            initialPoint = new Point(e.X, e.Y);
        }
 
        public void pictureBox1_MouseDown(object sender, MouseEventArgs e)
        {//form move on click and drag
            FormMoving = true;
            initialPoint = new Point(e.X, e.Y);
        }
 
        private void pictureBox1_MouseMove(object sender, MouseEventArgs e)
        {
        }
 
        private void pictureBox1_MouseHover(object sender, EventArgs e)
        {
        }
 
        public void label1_MouseHover(object sender, EventArgs e)
        {
            FormMoving = false;
        }
 
        public void label1_MouseUp(object sender, MouseEventArgs e)
        {
            FormMoving = false;
        }
 
       
 
        public void Form1_MouseHover(object sender, EventArgs e)
        {
            this.Opacity = 1;
        }
 
        public void Form1_MouseLeave(object sender, EventArgs e)
        {
            if(!PolicyNumber.Focused)
                this.Opacity = .25;
        }
 
        public void pictureBox1_MouseLeave(object sender, EventArgs e)
        {
            this.Opacity = 1;
        }
 
        public void pictureBox1_MouseHover_1(object sender, EventArgs e)
        {
            this.Opacity = 1;
        }
 
        public void Form1_Click(object sender, EventArgs e)
        {
            comboBox1.Focus();
        }
    }
}

, , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , ,

Leave a comment

Fluent C# Review : Chapter Three

I am reviewing an advanced copy of the book Fluent C# by noted .NET author Rebecca Riordan.

My focus today will be on chapter three. Chapter three picks up where chapter two left off  in describing the Visual Studio environment. It does an excellent job of reviewing the more intricate details of Visual Studio. Again, it ignores winforms and focuses on the Windows Presentation Foundation (WPF) forms and design editor. Encouraging the reader to customize the interface for themselves, it shows how to do that. I certainly have not seen that done before so early on in the process and in such an easygoing manner. It ends the first section explaining what Intellisense is. Later on in this chapter it goes into how members are listed. An excellent tutorial on refactoring and such is also discussed. It’s possible this discussion could have waited a bit until later on but it still works here.

We then move on to cover what a Visual Studio solution and project is and what it contains including a very helpful diagram, as they seem to always do in this book, explaining what the relationship between the various items in a Visual Studio solution and project are.

image

The next section introduces designer and source files, resources and your design documents. Covering how to add items to a solution or project comes next along with a graphical and step by step process of how to modify project properties. Changing the icon and window property is one such example they cover. Then we build the application to see the results of the changes.

Further customization of the Visual Studio environment is then discussed in the usual graphical and step by step nature this book is so good at.

image

Overall I wish I had had a book like this when I first started using Visual Studio so many eons ago!

The next chapter gets into debugging and deploying an application. Moving right along the user shouldn’t be overwhelmed with this patient, easy going manner of teaching.

, , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , ,

Leave a comment

Fluent C# Review : Chapter Two

I am reviewing an advanced copy of the book Fluent C# by noted .NET author Rebecca Riordan.

My focus today will be on Chapter Two. Chapter Two gets into some of the nuts and bolts of the .NET Framework and writes the initial “Hello World” application that these beginner books almost always do. They begin by putting up a very nice illustration of how .NET works. Truly I have not seen it explained in such a way before!

image

They give you a little quiz on what you picked up.

Then there is an explanation of why the .NET Framework is a better way to go than say a Visual Basic 6 way of thinking. I am not sure that to a beginner programmer they understand or need to know any of this. But they certainly make good points. Being an old VB6 and VBA programmer myself I certainly could appreciate what was said.

Then they proceed into building the first application. But there is a little twist. Riordan chooses to not even bother with winforms and instead chooses to plow right into a Windows Presentation Foundation (WPF) application. At first the choice seemed odd to me. But as I considered it this makes sense. WPF is the future. Winforms is dying. It’s a sad truth but it is what it is.

Riordan walks you through the process of creating a WPF application in Visual Studio 2010 while beautifully illustrating how to do that task.

image

Then the first example of modifying a property in the WPF gui is introduced. Really it is quite well done. The appropriate message box appears saying “hello world!” is displayed. She tells the user to take a break and congratulates them on their first application. She then displays and explains the code editor in the same easy going manner. Another note that often goes on through out this book she often gives the novice programmer fun little facts to digest, so as to have fun while learning. Imagine that! C# learning being made fun!

We will be covering Chapter Three in the next entry where the Visual Studio interface will be reviewed in more detail.

, , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , ,

1 Comment

Show All Forms In A Project with C#

This will list all forms or other types you specify that are in your particular Visual Studio project. It is a continuation of redoing code I have previously done in vb.net for C#. It can come in handy when documenting your code during your project. If it’s a form, do a certain set of actions, a class then do another set of actions and so on.

You can find the vb.net version here. There were some changes made from that version.

Have a great day!

static void GETALLFORMSINPROJECT()
       {
           System.Reflection.Assembly myAssembly = System.Reflection.Assembly.GetEntryAssembly();
           Type[] Types = myAssembly.GetTypes();
           foreach (Type myType in Types)
              
          {
               if (myType.BaseType == null) continue;

               if (myType.BaseType.FullName == “System.Windows.Forms.Form”) MessageBox.Show(myType.Name);

               //else { MessageBox.Show(myType.Name); }      
               
           }              
        } 

Facebook

, , , , , , , , , , , , , , , , , , , ,

Leave a comment

Tag Generator for Live Writer: Problems and Workarounds

One topic of emails and questions I receive are in relation to the Tag Generator, a plugin available for download, for Live Writer, a blog writing tool.

First some history. The Tag Generator was originally written over two years ago to provide myself a way to automatically generate tags for my blog posts. I got tired of doing it manually. It worked well for me so I decided to create a plugin that others could use. It uses the Microsoft Word thesaurus to verify words in the blog and their meanings. It isn’t perfect but its better than nothing. Obviously some of you agreed as over 14,000 downloads took place. However over the last couple of years, for various reasons, no work was done on this plugin and a new version of Live Writer was released. While the Tag Generator plugin still works, it does not support the options feature for plugins that came out with this version of Live Writer. In addition, as you all know, Windows Live Spaces no longer supports blogging, instead choosing to support the Word Press blogging resources. Generating these tags are obviously pointless.

You might wonder to yourself why I just don’t sit down and rewrite the plugin and be done with it. Basically it is because I am too busy at the moment to do so. I will at some point I promise. I apologize to those of you who have been frustrated. But this blog post today is to tell you how I still make use of this plugin and how  you can too.

First after you are done writing your post, right click on your document and click select all.

image

Then click “Insert” in the Live Writer toolbar and click “Generate Tags”.

image

Click the option or options you wish to generate the tags for and click the button “Generate”

image

Add, modify or delete the tags you wish…..but do not click the Insert button at the bottom! Instead select all of the words in the “Tags” text box and copy them. Then in the Set tags text box at the top of Live Writer, paste these words in their textbox.

image

Now your post will be tag ready for publication whenever you choose!

I am sorry for the hassle. I still find this plugin extremely useful for me and I promise I will get around to redoing it for you at some point. But this works fine for me for now and hopefully will for you as well.

Facebook

, , , , , , , , , , , , , , , , , , , , , , , , , , , ,

5 Comments