using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Drawing;
using System.IO;
using System.Linq;
using System.Management;
using System.Reflection;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Text;
using System.Windows.Forms;
using Microsoft.Office.Core;
using Microsoft.Win32;
using Excel = Microsoft.Office.Interop.Excel;
using PowerPoint = Microsoft.Office.Interop.PowerPoint;
using Word = Microsoft.Office.Interop.Word;
using Microsoft.Web.WebView2.Core;
using System.Runtime.InteropServices.ComTypes;


namespace RobvanderWoude
{
	public partial class FormMonitorClipboard : Form
	{
		static readonly string progver = "4.00";


		#region Global Variables

		static string clipboardtext = string.Empty;
		static string gsexec = string.Empty;
		static readonly string title = string.Format( "MonitorClipboard, Version {0}", progver );
		static string errormessage = string.Empty;
		static bool debugmode = false;
		static bool modalwindow = true;
		static bool compactmode = false;
		static float fontsizefactor = 1F;
		static int interval = 1;
		static int[] highestversion = new int[] { 0, 0, 0, 0 };
		static readonly bool isExcelInstalled = ( Type.GetTypeFromProgID( "Excel.Application" ) != null );
		static readonly bool isGhostScriptInstalled = CheckIfGhostScriptIsInstalled( );
		static readonly bool isPowerPointInstalled = ( Type.GetTypeFromProgID( "PowerPoint.Application" ) != null );
		static readonly bool isWordInstalled = ( Type.GetTypeFromProgID( "Word.Application" ) != null );
		static bool isRedirected = false;
		static List<string> tempfiles = new List<string>( );
		static List<string> tempdirs = new List<string>( );

		#endregion Global Variables


		public FormMonitorClipboard( )
		{
			InitializeComponent( );
			// Code to hide menu bar in WebViw2 by jpine
			// https://stackoverflow.com/a/74018241
			webView2ClipboardContent.CoreWebView2InitializationCompleted += ( sender, e ) =>
			{
				if ( e.IsSuccess )
				{
					webView2ClipboardContent.CoreWebView2.Settings.HiddenPdfToolbarItems =
						CoreWebView2PdfToolbarItems.Bookmarks
						| CoreWebView2PdfToolbarItems.FitPage
						| CoreWebView2PdfToolbarItems.PageLayout
						| CoreWebView2PdfToolbarItems.PageSelector
						| CoreWebView2PdfToolbarItems.Print
						| CoreWebView2PdfToolbarItems.Rotate
						| CoreWebView2PdfToolbarItems.Save
						| CoreWebView2PdfToolbarItems.SaveAs
						| CoreWebView2PdfToolbarItems.Search
						| CoreWebView2PdfToolbarItems.ZoomIn
						| CoreWebView2PdfToolbarItems.ZoomOut;
				}
			};
		}


		private void FormMonitorClipboard_Load( object sender, EventArgs e )
		{
			// https://www.csharp411.com/console-output-from-winforms-application/
			// redirect console output to parent process;
			// must be before any calls to Console.WriteLine( )
			AttachConsole( ATTACH_PARENT_PROCESS );
			Text = title;
			ParseCommandLine( );
			if ( debugmode )
			{
				DebugInfo( );
				modalwindow = false;
			}
			if ( compactmode )
			{
				CompactWindow( );
			}
			CheckClipboard( );
			TopMost = modalwindow;
			ClipboardNotification.ClipboardUpdate += ClipboardNotification_ClipboardUpdate;
		}


		private void ChangeViewerType( ViewerType viewerwindow )
		{
			pictureBoxClipboardContent.Visible = ( viewerwindow == ViewerType.Picture );
			richTextBoxClipboardContent.Visible = ( viewerwindow == ViewerType.RichText );
			textBoxClipboardContent.Visible = ( viewerwindow == ViewerType.Text );
			webView2ClipboardContent.Visible = ( viewerwindow == ViewerType.Web );
			labelFilename.Visible = ( viewerwindow != ViewerType.Text );
			switch ( viewerwindow )
			{
				case ViewerType.Picture:
					richTextBoxClipboardContent.Text = null;
					textBoxClipboardContent.Text = null;
					webView2ClipboardContent.SendToBack( );
					pictureBoxClipboardContent.BringToFront( );
					break;
				case ViewerType.RichText:
					pictureBoxClipboardContent.Image = null;
					textBoxClipboardContent.Text = null;
					webView2ClipboardContent.SendToBack( );
					richTextBoxClipboardContent.BringToFront( );
					break;
				case ViewerType.Text:
					pictureBoxClipboardContent.Image = null;
					richTextBoxClipboardContent.Text = null;
					webView2ClipboardContent.SendToBack( );
					textBoxClipboardContent.BringToFront( );
					break;
				case ViewerType.Web:
					pictureBoxClipboardContent.Image = null;
					richTextBoxClipboardContent.Text = null;
					textBoxClipboardContent.Text = null;
					webView2ClipboardContent.BringToFront( );
					break;
			}
		}


		private void CheckClipboard( )
		{
			labelFilename.Text = null;
			if ( Clipboard.ContainsText( ) )
			{
				ChangeViewerType( ViewerType.Text );
				clipboardtext = Clipboard.GetText( TextDataFormat.UnicodeText );
				textBoxClipboardContent.BackColor = Color.White;
				textBoxClipboardContent.ForeColor = Color.Black;
				textBoxClipboardContent.Text = clipboardtext;
			}
			else if ( Clipboard.ContainsImage( ) )
			{
				ChangeViewerType( ViewerType.Picture );
				pictureBoxClipboardContent.Image = Clipboard.GetImage( );
			}
			else if ( Clipboard.GetFileDropList( ) != null )
			{
				bool success = false;
				if ( Clipboard.GetFileDropList( ).Count == 1 )
				{
					success = Preview( Clipboard.GetFileDropList( )[0] );
				}
				if ( !success )
				{
					ChangeViewerType( ViewerType.Text );
					textBoxClipboardContent.Text = null;
					textBoxClipboardContent.BringToFront( );
					labelFilename.Text = null;
					labelFilename.Visible = false;
					List<string> files = new List<string>( );
					List<string> folders = new List<string>( );
					foreach ( var file in Clipboard.GetFileDropList( ) )
					{
						if ( Directory.Exists( file ) )
						{
							folders.Add( file );
						}
						else
						{
							files.Add( file );
						}
					}
					if ( folders.Count > 0 )
					{
						folders.Sort( );
						textBoxClipboardContent.Text = "Folders:" + Environment.NewLine + string.Join( Environment.NewLine, folders ) + Environment.NewLine + Environment.NewLine;
					}
					if ( files.Count > 0 )
					{
						files.Sort( );
						textBoxClipboardContent.Text += "Files:" + Environment.NewLine + string.Join( Environment.NewLine, files );
					}
				}
			}
			else
			{
				ChangeViewerType( ViewerType.Picture );
				textBoxClipboardContent.BackColor = Form.DefaultBackColor;
				textBoxClipboardContent.ForeColor = Color.Gray;
				textBoxClipboardContent.Text = string.Join( Environment.NewLine, Clipboard.GetDataObject( ).GetFormats( ).ToArray<string>( ) ); // requires Linq
			}
			textBoxClipboardContent.SelectionStart = 0;
			textBoxClipboardContent.SelectionLength = 0;
		}


		static bool CheckIfGhostScriptIsInstalled( )
		{
			string gspath;
			if ( Win3264( ) == 64 )
			{
				gspath = SearchPath( "gswin64c.exe" );
				if ( !string.IsNullOrWhiteSpace( gspath ) )
				{
					gsexec = gspath;
					return true;
				}
			}
			gspath = SearchPath( "gswin32c.exe" );
			if ( !string.IsNullOrWhiteSpace( gspath ) )
			{
				gsexec = gspath;
				return true;
			}
			RegistryKey uninstallKey = Registry.LocalMachine.OpenSubKey( @"SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall" );
			var programs = uninstallKey.GetSubKeyNames( );
			foreach ( var program in programs )
			{
				if ( program.ToLower( ).Contains( "ghostscript" ) )
				{
					RegistryKey subkey = uninstallKey.OpenSubKey( program );
					string uninstallstring = subkey.GetValue( "UninstallString" ).ToString( );
					subkey.Close( );
					if ( !string.IsNullOrWhiteSpace( uninstallstring ) )
					{
						if ( File.Exists( Path.GetDirectoryName( uninstallstring ) + @"\bin\gswin64.exe" ) )
						{
							gsexec = Path.GetDirectoryName( uninstallstring ) + @"\bin\gswin64.exe";
						}
						else if ( File.Exists( Path.GetDirectoryName( uninstallstring ) + @"\bin\gswin32.exe" ) )
						{
							gsexec = Path.GetDirectoryName( uninstallstring ) + @"\bin\gswin32.exe";
						}
						break;
					}
				}
			}
			uninstallKey.Close( );
			if ( !string.IsNullOrWhiteSpace( gsexec ) )
			{
				return true;
			}
			if ( Win3264( ) == 64 )
			{
				uninstallKey = Registry.LocalMachine.OpenSubKey( @"SOFTWARE\WOW6432Node\Microsoft\Windows\CurrentVersion\Uninstall" );
				programs = uninstallKey.GetSubKeyNames( );
				foreach ( var program in programs )
				{
					if ( program.ToLower( ).Contains( "ghostscript" ) )
					{
						RegistryKey subkey = uninstallKey.OpenSubKey( program );
						string uninstallstring = subkey.GetValue( "UninstallString" ).ToString( );
						subkey.Close( );
						if ( !string.IsNullOrWhiteSpace( uninstallstring ) )
						{
							if ( File.Exists( Path.GetDirectoryName( uninstallstring ) + @"\bin\gswin32.exe" ) )
							{
								gsexec = Path.GetDirectoryName( uninstallstring ) + @"\bin\gswin32.exe";
							}
							break;
						}
					}
				}
				uninstallKey.Close( );
			}
			return string.IsNullOrWhiteSpace( gsexec );
		}


		private void CompactWindow( )
		{
			this.ClientSize = new Size( (int)( Screen.PrimaryScreen.Bounds.Width / 2 ), 40 );
			this.Location = new System.Drawing.Point( (int)( Screen.PrimaryScreen.Bounds.Width / 4 ), Screen.PrimaryScreen.Bounds.Height - 40 );
			this.TopLevel = true;
			this.ControlBox = false;
			this.Text = string.Empty;
			this.FormBorderStyle = FormBorderStyle.None;
			textBoxClipboardContent.Size = new Size( this.ClientSize.Width - 40, this.ClientSize.Height );
			textBoxClipboardContent.Location = new System.Drawing.Point( 0, 0 );
			textBoxClipboardContent.Font = new System.Drawing.Font( textBoxClipboardContent.Font.FontFamily, (float)( textBoxClipboardContent.Font.Size * fontsizefactor ), FontStyle.Regular );
			Button exitbutton = new Button
			{
				Text = "Exit",
				Size = new Size( 32, 32 ),
				Location = new System.Drawing.Point( this.ClientSize.Width - 36, 4 )
			};
			exitbutton.Click += Exitbutton_Click;
			this.Controls.Add( exitbutton );
		}


		private void DebugInfo( )
		{
			string programpath = System.Windows.Forms.Application.ExecutablePath;
			string[] arguments = Environment.GetCommandLineArgs( ).Skip( 1 ).ToArray( ); // requires Linq
			string installednetframework = GetInstalledNETFrameworkVersion( );
			string requirednetframework = GetRequiredNETFrameworkVersion( );
			string debuginfo = string.Format( "DEBUGGING INFO:{0}==============={0}Program path           : {1}{0}Required .NET version  : {2}{0}Installed .NET version : {3}{0}Command line arguments : {4}{0}Timer interval         : {5}{0}Modal window           : {6}", System.Environment.NewLine, programpath, requirednetframework, installednetframework, string.Join( " ", arguments ), interval, modalwindow );
			Clipboard.SetText( debuginfo );
		}


		private string Excel2PDF( string excelfile )
		{
			if ( !isExcelInstalled )
			{
				return null;
			}
			string pdffile = Path.GetTempFileName( ) + ".pdf";
			if ( pdffile != null )
			{
				tempfiles.Add( pdffile );
				Excel.Application excelapp = null;
				Excel.Workbook workbook = null;
				try
				{
					excelapp = new Excel.Application
					{
						Visible = false
					};
					object updatelinks = true;
					object openreadonly = true;
					workbook = excelapp.Workbooks.Open( excelfile, updatelinks, openreadonly );
					Excel.Worksheet sheet = (Excel.Worksheet)workbook.Worksheets[1];
					sheet.ExportAsFixedFormat( Excel.XlFixedFormatType.xlTypePDF, pdffile );
				}
				catch ( Exception ex )
				{
					MessageBox.Show( ex.Message + "\n\n" + ex.StackTrace );
				}
				finally
				{
					workbook?.Close( );
					excelapp?.Quit( );
				}
			}
			return pdffile;
		}


		private string GetInstalledNETFrameworkVersion( )
		{
			string rc = string.Empty;
			System.Collections.Generic.List<string> installedversions = new System.Collections.Generic.List<string>( );
			// Get the list of installed .NET Framework versions from the registry, by Microsoft:
			// https://docs.microsoft.com/en-us/dotnet/framework/migration-guide/how-to-determine-which-versions-are-installed
			using ( RegistryKey ndpKey = RegistryKey.OpenRemoteBaseKey( RegistryHive.LocalMachine, "" ).OpenSubKey( @"SOFTWARE\Microsoft\NET Framework Setup\NDP\" ) )
			{
				foreach ( string versionKeyName in ndpKey.GetSubKeyNames( ) )
				{
					if ( versionKeyName.StartsWith( "v" ) )
					{
						RegistryKey versionKey = ndpKey.OpenSubKey( versionKeyName );
						string name = (string) versionKey.GetValue( "Version", "" );
						if ( name == "" )
						{
							foreach ( string subKeyName in versionKey.GetSubKeyNames( ) )
							{
								RegistryKey subKey = versionKey.OpenSubKey( subKeyName );
								name = (string) subKey.GetValue( "Version", "" );
								if ( name != "" )
								{
									installedversions.Add( name );
								}
							}
						}
						else
						{
							installedversions.Add( name );
						}
					}
				}
			}
			// Determine the highest version
			foreach ( string version in installedversions )
			{
				highestversion = HighestVersion( highestversion, version );
			}
			return string.Join( ".", highestversion.Select( x => x.ToString( ) ).ToArray( ) ); // requires System.Linq
		}


		static string GetRequiredNETFrameworkVersion( )
		{
			// Get the required .NET Framework version
			// By Fernando Gonzalez Sanchez on StackOverflow.com
			// https://stackoverflow.com/a/18623516
			object[] list = Assembly.GetExecutingAssembly( ).GetCustomAttributes( true );
			var attribute = list.OfType<TargetFrameworkAttribute>( ).First( ); // requires Linq
			//string frameworkname = attribute.FrameworkName;
			string frameworkdisplayname = attribute.FrameworkDisplayName;
			return frameworkdisplayname;
		}


		static int[] HighestVersion( int[] version1, string version2 )
		{
			int[] converted2 = version2.Split( ".".ToCharArray( ) ).Select( x => System.Convert.ToInt32( x ) ).ToArray( );
			int minlength = Math.Min( version1.Length, converted2.Length );
			for ( int i = 0; i < minlength; i++ )
			{
				if ( version1[i] > converted2[i] )
				{
					return version1;
				}
				else if ( version1[i] < converted2[i] )
				{
					return converted2;
				}
			}
			return version1;
		}


		private void ParseCommandLine( )
		{
			isRedirected = ( Console.IsOutputRedirected || Console.IsErrorRedirected );
			string[] arguments = Environment.GetCommandLineArgs( ).Skip( 1 ).ToArray( ); // requires Linq
			foreach ( string argument in arguments )
			{
				string clswitch = argument.Split( ":=".ToCharArray( ) )[0].ToUpper( );
				string clval = ( argument.IndexOfAny( ":=".ToCharArray( ) ) > 0 ? argument.Split( ":=".ToCharArray( ) )[1] : string.Empty );
				switch ( clswitch )
				{
					case "/CM":
						compactmode = true;
						break;
					case "/D":
					case "/DEBUG":
						debugmode = true;
						break;
					case "/F":
						int fontsizepercentage = 100;
						if ( !int.TryParse( clval, out fontsizepercentage ) )
						{
							errormessage = string.Format( "Invalid font size percentage: {0}", argument );
							ShowHelp( );
						}
						else if ( fontsizepercentage < 50 || fontsizepercentage > 150 )
						{
							errormessage = string.Format( "Font size percentage out of range (50..150): {0}", argument );
							ShowHelp( );
						}
						else
						{
							fontsizefactor = fontsizepercentage / 100F;
						}
						break;
					case "/NM":
						modalwindow = false;
						break;
					case "/?":
						ShowHelp( );
						break;
					default:
						errormessage = string.Format( "Invalid argument: {0}", argument );
						ShowHelp( );
						break;
				}
			}
		}


		private string PPT2JPG( string pptfile )
		{
			if ( !isPowerPointInstalled )
			{
				return null;
			}
			string jpgfile = Path.GetTempFileName( ) + ".jpg";
			tempfiles.Add( jpgfile );
			PowerPoint.Application pptapp = new PowerPoint.Application( );
			try
			{
				PowerPoint.Slide slide = pptapp.Presentations.Open( pptfile, MsoTriState.msoTrue, MsoTriState.msoFalse, MsoTriState.msoFalse ).Slides[1];
				slide.Export( jpgfile, "JPG" );
			}
			catch
			{
				jpgfile = null;
			}
			finally
			{
				pptapp.Quit( );
			}
			return jpgfile;
		}


		private bool Preview( string filename )
		{
			labelFilename.Location = new System.Drawing.Point( 12, 325 );
			labelFilename.Width = textBoxClipboardContent.Width;
			labelFilename.Height = 30;
			labelFilename.TextAlign = ContentAlignment.MiddleCenter;
			labelFilename.BackColor = Color.Transparent;
			labelFilename.Visible = false;
			string tempfile;
			bool result = true;
			switch ( Path.GetExtension( filename ).ToLower( ) )
			{
				case ".ini":
				case ".log":
				case ".txt":
					ChangeViewerType( ViewerType.Text );
					textBoxClipboardContent.Text = File.ReadAllText( filename );
					ShowLabel( filename );
					break;
				case ".htm":
				case ".html":
				case ".pdf":
				case ".php":
				case ".xhtml":
					ChangeViewerType( ViewerType.Web );
					webView2ClipboardContent.Source = new Uri( filename );
					ShowLabel( filename );
					break;
				case ".bmp":
				case ".gif":
				case ".jpg":
				case ".jpeg":
				case ".png":
				case ".tif":
				case ".tiff":
					ChangeViewerType( ViewerType.Picture );
					pictureBoxClipboardContent.Image = Image.FromFile( filename );
					ShowLabel( filename );
					break;
				case ".mp3":
				case ".mp4":
				case ".webp":
					ChangeViewerType( ViewerType.Web );
					webView2ClipboardContent.Source = new Uri( filename );
					ShowLabel( filename );
					break;
				case ".epub":
					string tempdir = Path.Combine( Environment.GetEnvironmentVariable( "Temp" ), Path.GetFileNameWithoutExtension( filename ) );
					if ( Directory.Exists( tempdir ) )
					{
						Directory.Delete( tempdir, true );
					}
					else
					{
						Directory.CreateDirectory( tempdir );
					}
					tempdirs.Add( tempdir );
					System.IO.Compression.ZipFile.ExtractToDirectory( filename, tempdir );
					string cover = Directory.GetFiles( tempdir, "cover.jpg", SearchOption.AllDirectories ).FirstOrDefault( );
					if ( !File.Exists( cover ) )
					{
						cover = Directory.GetFiles( tempdir, "cover.jpeg", SearchOption.AllDirectories ).FirstOrDefault( );
					}
					if ( File.Exists( cover ) )
					{
						tempfiles.Add( cover );
						ChangeViewerType( ViewerType.Picture );
						pictureBoxClipboardContent.Image = Image.FromFile( cover );
						ShowLabel( filename );
					}
					else
					{
						ChangeViewerType( ViewerType.Text );
						textBoxClipboardContent.Text = "File:" + Environment.NewLine + filename;
					}
					break;
				case ".xls":
				case ".xlsx":
				case ".ods":
					tempfile = Excel2PDF( filename );
					if ( tempfile == null )
					{
						ChangeViewerType( ViewerType.Text );
						textBoxClipboardContent.Text = "File:" + Environment.NewLine + filename;
					}
					else
					{
						tempfiles.Add( tempfile );
						ChangeViewerType( ViewerType.Web );
						webView2ClipboardContent.Source = new Uri( tempfile );
						ShowLabel( filename );
					}
					break;
				case ".doc":
				case ".docx":
				case ".odt":
					tempfile = Word2RTF( filename );
					if ( tempfile == null )
					{
						ChangeViewerType( ViewerType.Text );
						textBoxClipboardContent.Text = "File:" + Environment.NewLine + filename;
					}
					else
					{
						tempfiles.Add( tempfile );
						ChangeViewerType( ViewerType.RichText );
						richTextBoxClipboardContent.Rtf = File.ReadAllText( tempfile, Encoding.UTF8 );
						ShowLabel( filename );
					}
					break;
				case ".pps":
				case ".ppsx":
				case ".ppt":
				case ".pptx":
				case ".odp":
					tempfile=PPT2JPG( filename );
					if ( tempfile == null )
					{
						ChangeViewerType( ViewerType.Text );
						textBoxClipboardContent.Text = "File:" + Environment.NewLine + filename;
					}
					else
                    {
						ChangeViewerType( ViewerType.Picture );
						pictureBoxClipboardContent.Image = Image.FromFile( tempfile );
						ShowLabel( filename );
					}
					break;
				case ".rtf":
					ChangeViewerType( ViewerType.RichText );
					richTextBoxClipboardContent.Rtf = File.ReadAllText( filename, Encoding.UTF8 );
					ShowLabel( filename );
					break;
				default:
					ChangeViewerType( ViewerType.Text );
					result = false;
					break;
			}
			return result;
		}


		static string SearchPath( string execname )
		{
			foreach(string folder in Environment.GetEnvironmentVariable("PATH").Split( ';' ) )
			{
				if ( File.Exists( Path.Combine( folder, execname ) ) )
				{
					return Path.Combine( folder, execname );
				}
			}
			return null;
		}


		private void ShowHelp( )
		{
			string message = string.Empty;
			if ( !string.IsNullOrWhiteSpace( errormessage ) )
			{
				message += errormessage + "\n\n";
			}
			message += title;
			message += "\nMonitor clipboard content in realtime\n\n";
			message += "Usage:    MONITORCLIPBOARD.EXE  [ options ]\n\n";
			message += "Options:  /CM      Compact Mode: small window over taskbar\n";
			message += "                   (default: normal window at center of screen)\n";
			message += "          /F:perc  Font size percentage (50..150; default: 100)\n";
			message += "          /NM      sets the program's window to Non-Modal\n";
			message += "                   (default: always on top)\n";
			message += "          /D       Debug mode: send some debugging information\n";
			message += "                   to the clipboard (warning: this will overwrite\n";
			message += "                   the current clipboard content)\n\n";
			message += "Notes:    If the clipboard content is text or image, a preview will\n";
			message += "          be shown in the program window.\n";
			message += "          If the clipboard contains multiple files and/or folders,\n";
			message += "          the files and folders will be listed separately, sorted.\n";
			message += "          If the clipboard contains a single file, the program will\n";
			message += "          attempt to show a preview of the file's content, plus its path.\n";
			message += "          Supported file types are images, Microsoft Office and OpenOffice\n";
			message += "          text, spreadsheets and presentations, PDF and RTF.\n";
			message += "          These previews depend on software installed on the computer,\n";
			message += "          i.e. Microsoft Office and GhostScript.\n";
			message += "          if the required software is not found, the program will show\n";
			message += "          the file as a \"list of one file\".\n";
			message += "          Though invalid or duplicate arguments DO raise error\n";
			message += "          messages, they are ignored.\n\n";
			message += "Credits:  Clipboard changes notifications by Gert Lombard\n";
			message += "          https://gist.github.com/glombard/7986317\n";
			message += "          Console output from a WinForms program by Timm\n";
			message += "          https://www.csharp411.com/console-output-from-winforms-application/\n";
			message += "          Show text as RTF based on code by Wendy Zang\n";
			message += "          https://learn.microsoft.com/en-us/archive/msdn-technet-forums\n";
			message += "          /6e56af9b-d7d3-49f3-9ec4-80edde3fe54b#a64345e9-cfcb-43be-ab18-c08fae02cb2a\n";
			message += "          Hide menus in WebView2 viewer by jpine\n";
			message += "          https://stackoverflow.com/a/74018241\n\n";
			message += "Written by Rob van der Woude\n";
			message += "https://www.robvanderwoude.com";
			Console.WriteLine( message );
			Clipboard.SetText( message.Replace( "\n", Environment.NewLine ) );
		}


		private void ShowLabel( string text )
		{
			labelFilename.Text = text;
			labelFilename.Visible = true;
			labelFilename.BringToFront( );
		}
		
		
		static int Win3264( )
		{
			ManagementObjectSearcher searcher = new ManagementObjectSearcher( @"root\CIMV2", "SELECT * FROM Win32_Processor" );
			foreach ( ManagementObject queryObj in searcher.Get( ).Cast<ManagementObject>( ) )
			{
				return (int)(UInt16)( queryObj["AddressWidth"] );
			}
			return 0;
		}


		private string Word2RTF( string filename )
		{
			if(!isWordInstalled)
			{
				return null;
			}
			string rtffile = Path.GetTempFileName( ) + ".rtf";
			tempfiles.Add( rtffile );
			Word.Application wordapp = new Word.Application( );
			object savechanges = Word.WdSaveOptions.wdDoNotSaveChanges;
			try
			{
				wordapp.Visible = false;
				Word.Document worddoc = wordapp.Documents.Open( filename );
				worddoc.SaveAs2( rtffile, Word.WdSaveFormat.wdFormatRTF );
				worddoc.Close( savechanges );
			}
			finally
			{
				wordapp.Quit( savechanges );
			}
			return rtffile;
		}


		private void ClipboardNotification_ClipboardUpdate( object sender, EventArgs e )
		{
			CheckClipboard( );
		}


		private void Exitbutton_Click( object sender, EventArgs e )
		{
			System.Windows.Forms.Application.Exit( );
		}


		private void FormMonitorClipboard_FormClosing( object sender, FormClosingEventArgs e )
		{
			pictureBoxClipboardContent.Image = null;
			pictureBoxClipboardContent.Dispose( );
			richTextBoxClipboardContent.Text = null;
			richTextBoxClipboardContent.Dispose( );
			textBoxClipboardContent.Text = null;
			textBoxClipboardContent.Dispose( );
			webView2ClipboardContent.Dispose( );
			foreach ( string tempfile in tempfiles )
			{
				try
				{
					File.Delete( tempfile );
				}
				catch
				{
					// ignore
				}
			}
			foreach ( string tempdir in tempdirs )
			{
				try
				{
					Directory.Delete( tempdir, true );
				}
				catch
				{
					// ignore
				}
			}
		}


		private void FormMonitorClipboard_HelpRequested( object sender, HelpEventArgs hlpevent )
		{
			ShowHelp( );
		}


		[DllImport( "kernel32.dll" )]
		static extern bool AttachConsole( int dwProcessId );
		private const int ATTACH_PARENT_PROCESS = -1;


		#region Clipboard Changes Notification

		// Code by Gert Lombard on https://gist.github.com/glombard/7986317

		/// <summary>
		/// Provides notifications when the contents of the clipboard is updated.
		/// </summary>
		public sealed class ClipboardNotification
		{
			/// <summary>
			/// Occurs when the contents of the clipboard is updated.
			/// </summary>
			public static event EventHandler ClipboardUpdate;

			private static NotificationForm _form = new NotificationForm( );

			/// <summary>
			/// Raises the <see cref="ClipboardUpdate"/> event.
			/// </summary>
			/// <param name="e">Event arguments for the event.</param>
			private static void OnClipboardUpdate( EventArgs e )
			{
				var handler = ClipboardUpdate;
				if ( handler != null )
				{
					handler( null, e );
				}
			}


			/// <summary>
			/// Hidden form to recieve the WM_CLIPBOARDUPDATE message.
			/// </summary>
			private class NotificationForm : Form
			{
				public NotificationForm( )
				{
					NativeMethods.SetParent( Handle, NativeMethods.HWND_MESSAGE );
					NativeMethods.AddClipboardFormatListener( Handle );
				}

				protected override void WndProc( ref Message m )
				{
					if ( m.Msg == NativeMethods.WM_CLIPBOARDUPDATE )
					{
						OnClipboardUpdate( null );
					}
					base.WndProc( ref m );
				}
			}
		}

		internal static class NativeMethods
		{
			// See http://msdn.microsoft.com/en-us/library/ms649021%28v=vs.85%29.aspx
			public const int WM_CLIPBOARDUPDATE = 0x031D;
			public static IntPtr HWND_MESSAGE = new IntPtr( -3 );
			// See http://msdn.microsoft.com/en-us/library/ms632599%28VS.85%29.aspx#message_only
			[DllImport( "user32.dll", SetLastError = true )]
			[return: MarshalAs( UnmanagedType.Bool )]
			public static extern bool AddClipboardFormatListener( IntPtr hwnd );
			// See http://msdn.microsoft.com/en-us/library/ms633541%28v=vs.85%29.aspx
			// See http://msdn.microsoft.com/en-us/library/ms649033%28VS.85%29.aspx
			[DllImport( "user32.dll", SetLastError = true )]
			public static extern IntPtr SetParent( IntPtr hWndChild, IntPtr hWndNewParent );
		}

		#endregion Clipboard Changes Notification
	}


	public enum ViewerType
	{
		Picture,
		RichText,
		Text,
		Web
	}
}