<Type Name="Application" FullName="Gtk.Application">
  <TypeSignature Language="C#" Value="public class Application : GLib.Application" Maintainer="John Luke" />
  <TypeSignature Language="ILAsm" Value=".class public auto ansi Application extends GLib.Application" />
  <AssemblyInfo>
    <AssemblyName>gtk-sharp</AssemblyName>
    <AssemblyPublicKey>
    </AssemblyPublicKey>
  </AssemblyInfo>
  <ThreadSafetyStatement>Gtk# is thread aware, but not thread safe; See the <link location="node:gtk-sharp/programming/threads">Gtk# Thread Programming</link> for details.</ThreadSafetyStatement>
  <Base>
    <BaseTypeName>GLib.Application</BaseTypeName>
  </Base>
  <Interfaces />
  <Docs>
    <summary>Application class</summary>
    <remarks>
      <para>
	Provides the initialization and event loop iteration related
	methods for the Gtk# widget library.  Since Gtk# is an event 
	driven toolkit, Applications register callbacks against various
	events to handle user input. These callbacks are invoked from
	the main event loop when events are detected.
      </para>
      <example>
        <code lang="C#">
using Gtk;
using System;
using GLib;

public class HelloWorld  {

	public static int Main (string[] args)
	{
		Application.Init ();
		Gtk.Window win = new Gtk.Window ("Gtk# Hello World");
		win.DeleteEvent += new DeleteEventHandler (Window_Delete);
		win.ShowAll ();
		Application.Run ();
		return 0;
	}

	static void Window_Delete (object obj, DeleteEventArgs args)
	{
		SignalArgs sa = (SignalArgs) args;
		Application.Quit ();
		sa.RetVal = true;
	}
}
        </code>
      </example>
    </remarks>
  </Docs>
  <Members>
    <Member MemberName=".ctor">
      <MemberSignature Language="C#" Value="public Application (IntPtr raw);" />
      <MemberSignature Language="ILAsm" Value=".method public hidebysig specialname rtspecialname instance void .ctor(native int raw) cil managed" />
      <MemberType>Constructor</MemberType>
      <Parameters>
        <Parameter Name="raw" Type="System.IntPtr" />
      </Parameters>
      <Docs>
        <param name="raw">Native object pointer.</param>
        <summary>Internal constructor</summary>
        <remarks>This is not typically used by C# code.  Exposed primarily for use by language bindings to wrap native object instances.</remarks>
        <since version="Gtk# 3.0" />
      </Docs>
    </Member>
    <Member MemberName=".ctor">
      <MemberSignature Language="C#" Value="public Application (string application_id, GLib.ApplicationFlags flags);" />
      <MemberSignature Language="ILAsm" Value=".method public hidebysig specialname rtspecialname instance void .ctor(string application_id, valuetype GLib.ApplicationFlags flags) cil managed" />
      <MemberType>Constructor</MemberType>
      <Parameters>
        <Parameter Name="application_id" Type="System.String" />
        <Parameter Name="flags" Type="GLib.ApplicationFlags" />
      </Parameters>
      <Docs>
        <param name="application_id">To be added.</param>
        <param name="flags">To be added.</param>
        <summary>To be added.</summary>
        <remarks>To be added.</remarks>
        <since version="Gtk# 3.0" />
      </Docs>
    </Member>
    <Member MemberName="AddWindow">
      <MemberSignature Language="C#" Value="public void AddWindow (Gtk.Window window);" />
      <MemberSignature Language="ILAsm" Value=".method public hidebysig instance void AddWindow(class Gtk.Window window) cil managed" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Void</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="window" Type="Gtk.Window" />
      </Parameters>
      <Docs>
        <param name="window">To be added.</param>
        <summary>To be added.</summary>
        <remarks>To be added.</remarks>
        <since version="Gtk# 3.0" />
      </Docs>
    </Member>
    <Member MemberName="CurrentEvent">
      <MemberSignature Language="C#" Value="public static Gdk.Event CurrentEvent { get; }" />
      <MemberSignature Language="ILAsm" Value=".property class Gdk.Event CurrentEvent" />
      <MemberType>Property</MemberType>
      <ReturnValue>
        <ReturnType>Gdk.Event</ReturnType>
      </ReturnValue>
      <Parameters />
      <Docs>
        <summary>Returns the event currently taking place.</summary>
        <value>a <see cref="T:Gdk.Event" /></value>
        <remarks />
      </Docs>
    </Member>
    <Member MemberName="EventsPending">
      <MemberSignature Language="C#" Value="public static bool EventsPending ();" />
      <MemberSignature Language="ILAsm" Value=".method public static hidebysig bool EventsPending() cil managed" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Parameters />
      <Docs>
        <summary>Whether there are events on the queue</summary>
        <returns>
          <see langword="true" /> if events are available to be processed, <see langword="false" /> otherwise</returns>
        <remarks>
          <para>
	    Checks if any events are pending. This can be used to
	    update the GUI and invoke timeouts etc. while doing some
	    time intensive computation.
	  </para>
          <example>
            <code lang="C#">
void LongComputation ()
{
	while (!done){
	    ComputationChunk ();

    	// Flush pending events to keep the GUI reponsive
    	while (Application.EventsPending ())
		    Application.RunIteration ();
	}
}
	    </code>
          </example>
        </remarks>
      </Docs>
    </Member>
    <Member MemberName="GType">
      <MemberSignature Language="C#" Value="public static GLib.GType GType { get; }" />
      <MemberSignature Language="ILAsm" Value=".property valuetype GLib.GType GType" />
      <MemberType>Property</MemberType>
      <ReturnValue>
        <ReturnType>GLib.GType</ReturnType>
      </ReturnValue>
      <Docs>
        <summary>GType Property.</summary>
        <value>The native <see cref="T:GLib.GType" /> value.</value>
        <remarks>Returns the native <see cref="T:GLib.GType" /> value for <see cref="T:Gtk.Application" />.</remarks>
        <since version="Gtk# 3.0" />
      </Docs>
    </Member>
    <Member MemberName="Init">
      <MemberSignature Language="C#" Value="public static void Init ();" />
      <MemberSignature Language="ILAsm" Value=".method public static hidebysig void Init() cil managed" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Void</ReturnType>
      </ReturnValue>
      <Parameters />
      <Docs>
        <summary>Initializes GTK+ for operation.</summary>
        <remarks>
          <para>
	    Call this function before using any other Gtk# functions
	    in your GUI applications. It will initialize everything
	    needed to operate the toolkit.
	  </para>
          <para>
	    This function will terminate your program if it was unable
	    to initialize the GUI for some reason. If you want your
	    program to fall back to a textual interface you want to
	    call <see cref="M:Gtk.Application.InitCheck(System.String, System.String []&amp;)" /> instead.
	  </para>
          <para>
	    If you want to pass arguments from the command line use
	    the <see cref="T:Gtk.Application.Init(System.String, System.String []&amp;)" />
	    method instead. 
	  </para>
        </remarks>
      </Docs>
    </Member>
    <Member MemberName="Init">
      <MemberSignature Language="C#" Value="public static void Init (string progname, ref string[] args);" />
      <MemberSignature Language="ILAsm" Value=".method public static hidebysig void Init(string progname, string[] args) cil managed" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Void</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="progname" Type="System.String" />
        <Parameter Name="args" Type="System.String[]&amp;" RefType="ref" />
      </Parameters>
      <Docs>
        <param name="progname">The name of the program.</param>
        <param name="args">An string array with the parameters given to the program.</param>
        <summary>Call this method before using any other GTK# method in your GUI applications.</summary>
        <remarks>
          <para>
	    It will initialize everything needed to operate the toolkit and parses some standard command line options, <paramref name="args" /> is adjusted accordingly so your code will never see those standard arugments.
	  </para>
          <para>
	    Note that there are some alternative ways to initialize GTK#, if you are calling <see cref="M:Gtk.Global.ParseArgs" /> or <see cref="M:Gtk.Application.InitCheck" /> you don't have to call <see cref="M:Gtk.Application.Init" />.
	  </para>
        </remarks>
      </Docs>
    </Member>
    <Member MemberName="InitCheck">
      <MemberSignature Language="C#" Value="public static bool InitCheck (string progname, ref string[] args);" />
      <MemberSignature Language="ILAsm" Value=".method public static hidebysig bool InitCheck(string progname, string[] args) cil managed" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="progname" Type="System.String" />
        <Parameter Name="args" Type="System.String[]&amp;" RefType="ref" />
      </Parameters>
      <Docs>
        <param name="progname">The name of the program.</param>
        <param name="args">An string array with the parameters given to the program.</param>
        <summary>This method does the same work as <see cref="M:Gtk.Application.Init" /> with only a single change, it does not terminate the program if the GUI can't be initialized. Instead it returns <see langword="false" /> on failure.</summary>
        <returns>
          <see langword="" /> if the GUI has been succesfully initialized, otherwise <see langword="false" />.</returns>
        <remarks>This way the application can fall back to some toher means of communication with the user, for example a curses or command line interface.</remarks>
      </Docs>
    </Member>
    <Member MemberName="Invoke">
      <MemberSignature Language="C#" Value="public static void Invoke (EventHandler d);" />
      <MemberSignature Language="ILAsm" Value=".method public static hidebysig void Invoke(class System.EventHandler d) cil managed" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Void</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="d" Type="System.EventHandler" />
      </Parameters>
      <Docs>
        <param name="d">An event handler to invoke on the main thread.</param>
        <summary>Invoke the given EventHandler in the GUI thread.</summary>
        <remarks>
	   Use this method to invoke the given delegate code in the
    	   main thread.  This is necessary since Gtk# does not allow
	   multiple threads to perform operations on Gtk objects as it
	   the toolkit is not thread-safe.
	   <para>
	     This mechanism is simpler to use than <see cref="T:Gtk.ThreadNotify" /> since it does not require the
    	     creation of a notifier per event.
	   </para><para>
	     This is particularly useful with C# 2.0 as it is possible
	     to use anonymous methods with it, for example:
	   </para><example><code lang="C#">
	using Gtk;
	using Gdk;
	using System;
	using System.Threading;

	public class HelloThreads  {
		static Label msg;
		static Button but;
		static int count;
		static Thread thr;
		
		public static int Main (string[] args)
		{
			Application.Init ();
			Gtk.Window win = new Gtk.Window ("Gtk# Threaded Counter");
			win.DeleteEvent += new DeleteEventHandler (Window_Delete);
			msg = new Label ("Click to quit");
			but = new Button (msg);
			but.Clicked += delegate { thr.Abort (); Application.Quit (); };
			win.Add (but);
			win.ShowAll ();

			thr = new Thread (ThreadMethod);
			thr.Start ();
			
			Application.Run ();
			
			return 0;
		}

		static void ThreadMethod ()
		{
			Console.WriteLine ("Starting thread");
			while (true){
				count++;
				Thread.Sleep (500);
				Application.Invoke (delegate {
					msg.Text = String.Format ("Click to Quit ({0})", count);
				});
			}
		}
		
		static void Window_Delete (object obj, DeleteEventArgs args)
		{
			Application.Quit ();
			args.RetVal = true;
		}
        </code></example></remarks>
      </Docs>
    </Member>
    <Member MemberName="Invoke">
      <MemberSignature Language="C#" Value="public static void Invoke (object sender, EventArgs args, EventHandler d);" />
      <MemberSignature Language="ILAsm" Value=".method public static hidebysig void Invoke(object sender, class System.EventArgs args, class System.EventHandler d) cil managed" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Void</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="sender" Type="System.Object" />
        <Parameter Name="args" Type="System.EventArgs" />
        <Parameter Name="d" Type="System.EventHandler" />
      </Parameters>
      <Docs>
        <param name="sender">The sender to pass to the event handler..</param>
        <param name="args">The argument to pass to the event handler.</param>
        <param name="d">An event handler to invoke on the main thread.</param>
        <summary>Invoke the given EventHandler in the GUI thread.</summary>
        <remarks>
    	   Use this method to invoke the given delegate code in the
        	   main thread.  This is necessary since Gtk# does not allow
    	   multiple threads to perform operations on Gtk objects as it
    	   the toolkit is not thread-safe.
    	   <para>
    	     This mechanism is simpler to use than <see cref="T:Gtk.ThreadNotify" /> since it does not require the
        	     creation of a notifier per event.
    	   </para><para>
    	     This is particularly useful with C# 2.0 as it is possible
    	     to use anonymous methods with it, for example:
    	   </para><example><code lang="C#">
    	using Gtk;
    	using Gdk;
    	using System;
    	using System.Threading;
    
    	public class HelloThreads  {
    		static Label msg;
    		static Button but;
    		static int count;
    		static Thread thr;
    		
    		public static int Main (string[] args)
    		{
    			Application.Init ();
    			Gtk.Window win = new Gtk.Window ("Gtk# Threaded Counter");
    			win.DeleteEvent += new DeleteEventHandler (Window_Delete);
    			msg = new Label ("Click to quit");
    			but = new Button (msg);
    			but.Clicked += delegate { thr.Abort (); Application.Quit (); };
    			win.Add (but);
    			win.ShowAll ();
    
    			thr = new Thread (ThreadMethod);
    			thr.Start ();
    			
    			Application.Run ();
    			
    			return 0;
    		}
    
    		static void ThreadMethod ()
    		{
    			Console.WriteLine ("Starting thread");
    			while (true){
    				count++;
    				Thread.Sleep (500);
    				Application.Invoke (delegate {
    					msg.Text = String.Format ("Click to Quit ({0})", count);
    				});
    			}
    		}
    		
    		static void Window_Delete (object obj, DeleteEventArgs args)
    		{
    			Application.Quit ();
    			args.RetVal = true;
    		}
            </code></example></remarks>
      </Docs>
    </Member>
    <Member MemberName="Quit">
      <MemberSignature Language="C#" Value="public static void Quit ();" />
      <MemberSignature Language="ILAsm" Value=".method public static hidebysig void Quit() cil managed" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Void</ReturnType>
      </ReturnValue>
      <Parameters />
      <Docs>
        <summary>Quits the current main loop</summary>
        <remarks>
          <para>
	    Makes the innermost invocation of the main loop return when it regains control.
	  </para>
        </remarks>
      </Docs>
    </Member>
    <Member MemberName="RemoveWindow">
      <MemberSignature Language="C#" Value="public void RemoveWindow (Gtk.Window window);" />
      <MemberSignature Language="ILAsm" Value=".method public hidebysig instance void RemoveWindow(class Gtk.Window window) cil managed" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Void</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="window" Type="Gtk.Window" />
      </Parameters>
      <Docs>
        <param name="window">To be added.</param>
        <summary>To be added.</summary>
        <remarks>To be added.</remarks>
        <since version="Gtk# 3.0" />
      </Docs>
    </Member>
    <Member MemberName="Run">
      <MemberSignature Language="C#" Value="public static void Run ();" />
      <MemberSignature Language="ILAsm" Value=".method public static hidebysig void Run() cil managed" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Void</ReturnType>
      </ReturnValue>
      <Parameters />
      <Docs>
        <summary>Runs the main loop</summary>
        <remarks>
          <para>
	    Runs the main loop until <see cref="M:Gtk.Application.Quit()" /> is called. You can nest
	    calls to <see cref="M:Gtk.Application.Run()" />.  In that
	    case <see cref="M:Gtk.Application.Quit()" /> will make the
	    innermost invocation of the main loop return.
	  </para>
        </remarks>
      </Docs>
    </Member>
    <Member MemberName="RunIteration">
      <MemberSignature Language="C#" Value="public static void RunIteration ();" />
      <MemberSignature Language="ILAsm" Value=".method public static hidebysig void RunIteration() cil managed" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Void</ReturnType>
      </ReturnValue>
      <Parameters />
      <Docs>
        <summary>Runs a single iteration of the main loop.</summary>
        <remarks>
          <para>
	    Runs a single iteration of the main loop. If no events are
	    waiting to be processed Gtk# will block until the next
	    event is noticed.  If you do not want to block look at <see cref="M:Gtk.Application.RunIteration(System.Boolean)" /> or check if
	    any events are pending with <see cref="M:Gtk.Application.EventsPending()" /> first.
	  </para>
        </remarks>
      </Docs>
    </Member>
    <Member MemberName="RunIteration">
      <MemberSignature Language="C#" Value="public static bool RunIteration (bool blocking);" />
      <MemberSignature Language="ILAsm" Value=".method public static hidebysig bool RunIteration(bool blocking) cil managed" />
      <MemberType>Method</MemberType>
      <ReturnValue>
        <ReturnType>System.Boolean</ReturnType>
      </ReturnValue>
      <Parameters>
        <Parameter Name="blocking" Type="System.Boolean" />
      </Parameters>
      <Docs>
        <param name="blocking">A boolean value, whether the iteration should block or not</param>
        <summary>Runs a single iteration of the main loop.</summary>
        <returns>
          <see langword="true" /> if <see cref="M:Gtk.Application.Quit()" /> has been called in the innermost main loop.</returns>
        <remarks>
          <para>
            Runs a single iteration of the main loop. If <paramref name="blocking" /> is <see langword="true" />, then if no events are
            waiting to be processed Gtk# will block until the next event is noticed; If <paramref name="blocking" /> is <see langword="false" />,
            then it if no events are waiting to be processed Gtk#, routine will return immediately.
          </para>
        </remarks>
      </Docs>
    </Member>
    <Member MemberName="Windows">
      <MemberSignature Language="C#" Value="public Gtk.Window[] Windows { get; }" />
      <MemberSignature Language="ILAsm" Value=".property instance class Gtk.Window[] Windows" />
      <MemberType>Property</MemberType>
      <ReturnValue>
        <ReturnType>Gtk.Window[]</ReturnType>
      </ReturnValue>
      <Docs>
        <summary>To be added.</summary>
        <value>To be added.</value>
        <remarks>To be added.</remarks>
        <since version="Gtk# 3.0" />
      </Docs>
    </Member>
  </Members>
</Type>
