We Keep Coding

Windows form going behind after splash screen

I am working with Windows forms. I have set up a splash screen to appear when opening the program like this.
protected override void OnLoad(EventArgs e)
{
base.OnLoad(e);
this.FormBorderStyle = FormBorderStyle.None;
}
private void timer1_Tick(object sender, EventArgs e)
{
progressBar1.Increment(15);
if (progressBar1.Value == 30) timer1.Stop();
}
It has a progress bar and a timer. I got the idea from another post here. This is working OK, the splash screen is appearing as it should. On the windows form to appear after this I have:
Thread t = new Thread(new ThreadStart(splash));
t.Start();
Thread.Sleep(2000);
InitializeComponent();
t.Abort();
The problem is as follows. When I open the exe, the splash screens appear for about 2 secs as it should, and then when it goes away, the next form appears a second and then goes behind every other window I have opened.
Do you know how can I fix it?
Update 1:
public void splash()
{
System.Windows.Forms.Application.Run(new Form2());
}
This is my splash screen
Final Update:
I got it to work this way.
Splash splash = new Splash();
Instalador instalador = new Instalador();
splash.Show();
Thread.Sleep(2 * 1000);
splash.Close();
Application.Run(instalador);
This on the main. I do not know how OK is this, but it works.

To answer your specific question, you might get away with just adding this.Activate() after InitializeComponent
Thread t = new Thread(new ThreadStart(splash));
t.Start();
Thread.Sleep(2000);
InitializeComponent();
this.Activate();
t.Abort();
However, at the very least, implement handshaking that shuts down the splash screen nicely rather than just aborting the thread.
Also, depending on exactly what you're doing in your splash screen thread, there may be a multitude of subtle issues - e.g. the Z-ordering issue you're currently having.
Typically, I launch my splash screens from Main() before Application.Run({main form}) and also call Application.Run({splashScreen}) from it's thread handler. Application.Run has thread affinity so the splash screen will get its own ApplicationContext which will properly hook Closing/Closed events to shutdown the thread and raise ThreadExit just by invoking or beginInvoking SplashScreen.Close() (typically from MainForm_Shown event handler). It also has other minor benefits such as Application.OpenForms containing the splash screen.
Taking this route has pretty much eliminated my bugs and frustrations with splash screens.
-Begin Edit-
A more thorough example:
Start up the second thread and ApplicationContext in Main()
static class Program
{
/// <summary>
/// The main entry point for the application.
/// </summary>
[STAThread]
static void Main()
{
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Thread t = new Thread(new ThreadStart(splash));
t.IsBackground = true;
t.SetApartmentState(ApartmentState.STA);
t.Start();
Application.Run(new Form1());
}
private static void splash()
{
Application.Run(new Form2());
}
}
Splash screen with a SetProgress method added so you can update it externally if you wish.
public partial class Form2 : Form
{
public Form2()
{
InitializeComponent();
timer1.Start();
}
public void SetProgress()
{
if (this.InvokeRequired) //Should have been handled by SplashScreenHandler but check just in case.
this.BeginInvoke(new Action(SetProgress));
progressBar1.Increment(15);
}
private void timer1_Tick(object sender, EventArgs e)
{
progressBar1.Increment(15);
if (progressBar1.Value == 30) timer1.Stop();
}
}
Main form: Notice nothing in constructor and the Shown event handler shuts down the splash screen(s) without having to carry in a reference (if you're going to instead rely on the timer for status updates.)
public partial class Form1 : Form
{
public Form1()
{
//Simulate a long init
Thread.Sleep(2000);
InitializeComponent();
}
private void Form1_Shown(object sender, EventArgs e)
{
foreach (var splashScreen in Application.OpenForms.OfType<Form2>())
{
splashScreen.BeginInvoke( (Action) delegate () { splashScreen.Close(); });
}
}
}
-End Edit-

After long time struggle i got the solution.
Use the code into Login Form (Form_Load) this.Activate();
Example:
private void login_Load(object sender, EventArgs e)
{
this.Activate();
}

I had the same issue and after stuggling for a very long time I ended up doing the following in the Load event of the main form after closing the splash screen:
//Manually activate frmMain as it gets back in the Z-order by Windows when splash screen closes.
NativeMethods.SetForegroundWindow(this.Handle);
this.Activate();
Where "SetForegroundWindow" is defined as follows:
/// <summary>
/// Sets foreground window
/// </summary>
/// <param name="hWnd"></param>
/// <returns></returns>
[DllImport("user32.dll")]
internal static extern bool SetForegroundWindow(IntPtr hWnd);
That being said we probably need to see more of your code.

How can I pass application control to another WPF window?

I'm setting up a simple WPF application, which looks at its command-line arguments to determine what kind of window should be shown next. When that's determined, I show the next window by calling new ApplicationWindow(), set the content, and call Show(). The problem is that the MainWindow instance seems to have "application control" - i.e. when it closes, so does everything else.
It goes like this:
public partial class MainWindow : Window
{
public MainWindow()
{
InitializeComponent();
TopBar.Background = new SolidColorBrush((Color)ColorConverter.ConvertFromString("#FF1975DD"));
this.ContentRendered += MainWindow_ContentRendered;
this.OperationModeSet += MainWindow_OperationModeSet;
}
[STAThread]
private void MainWindow_ContentRendered(object sender, EventArgs e)
{
Thread worker = new Thread(new ThreadStart(this.ParseCommandLineArgs));
worker.SetApartmentState(ApartmentState.STA);
worker.Start();
}
[STAThread]
public void ParseCommandLineArgs()
{
Thread.Sleep(3000);
string[] args = Environment.GetCommandLineArgs();
if (args.Any(item => item == "--server" || item == "-s"))
{
SetOperationMode(OperationMode.Server);
Dispatcher.BeginInvoke(new Action(delegate()
{
this.CloseWindow();
}));
}
else
{
SetOperationMode(OperationMode.Client);
Dispatcher.BeginInvoke(new Action(delegate()
{
this.CloseWindow();
}));
}
}
[STAThread]
private void SetOperationMode(OperationMode mode)
{
OperatingMode = mode;
if (OperationModeSet != null)
{
OperationModeSet(this, new OperationModeSetEventArgs(mode));
}
}
[STAThread]
private void MainWindow_OperationModeSet(object sender, OperationModeSetEventArgs e)
{
AppWindow window = new AppWindow();
if (e.Mode == OperationMode.Client)
{
this.CloseWindow();
window.Content = new ClientPage();
}
else if (e.Mode == OperationMode.Server)
{
this.CloseWindow();
window.Content = new ServerPage();
}
window.Show();
}
}
These methods get called in the order I've put them here, through various events. I've omitted a few fields and properties.
The problem is that when this MainWindow closes, so does window - the instantiated ApplicationWindow. I assume this is because the MainWindow created it.
However, I do want to be able to close the MainWindow and continue with another window as the "main" window - so how can I decouple the instantiated ApplicationWindow from its parent MainWindow so it continues on?
I've seen setting Application.MainWindow in App.xaml changes the main window - but I have no reference to the instantiated window that I can put into a static XAML file.

Why are you parsing the command line args in your MainWindow?
You could just remove the StartupUri in the App.xaml and override the OnStartup method. Then you can use StartUpArgs to decide which operating mode you want.
In App.xaml.cs
protected override void OnStartup(StartupEventArgs e)
{
// Decide which window to show here
// Add bounds checks etc.
if (e.Args[0] == "-s")
{
var window = new ServerPage();
window.Show();
}
else
{
var window = new ClientPage();
window.Show();
}
Current.ShutdownMode = ShutdownMode.OnExplicitShutdown;
base.OnStartup(e);
}

What I think you could do (now there are better options I'm sure...) is instead of creating a new window in your main program, move your other code into a new project and in your main project, launch it as a new process with Process.Start(...).
I've only ever seen code that used this though, never written it from scratch myself. But I would take a look at this page from the MDSN and pages related to it.
Excuse the lack of example code to help you, this is just at the edge of my knowledge and I'd hate to give you incorrect code.

How can I animate a progress indicator in a splash screen of a windows application

I have created a splash screen in my windows application. I want a cycling "ring" progress indicator (like the one shown on the Windows 8 boot screen) to be added on splash screen until the main form is connected. The code in program.cs is:
static void Main()
{
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
logo f = new logo();
f.Shown += new EventHandler((o, e) =>
{
System.Threading.Thread t = new System.Threading.Thread(() =>
{
System.Threading.Thread.Sleep(4000);
f.Invoke(new Action(() => { f.Close(); }));
});
t.IsBackground = true;
t.Start();
});
}
logo is the start up form or splash screen I want to add progress bar or ring progress indicator to as in windows 8 startup.

There isn't a specific "cycle" progress ring control within the default control set, so I'd say you have two options:
Add a standard horizontal ProgressBar, and set its style to Marquee - this will give you the indeterminate "progress is happening but we're not sure when it's going to finish" look:
myProgressBar.Style = ProgressBarStyle.Marquee;
If you want a ring/circular progress indicator, then you're better off using an animated .gif or similar and the ImageAnimator control.
There is a good example of loading a gif and stepping through the frames on MSDN on the documentation for the ImageAnimator.Animate method:
Create a control, such as "AnimatedProgress":
public partial class AnimatedProgress : UserControl
{
//Create a Bitmpap Object.
Bitmap animatedImage = new Bitmap("circle_progress_animation.gif");
bool currentlyAnimating = false;
//This method begins the animation.
public void AnimateImage()
{
if (!currentlyAnimating)
{
//Begin the animation only once.
ImageAnimator.Animate(animatedImage, new EventHandler(this.OnFrameChanged));
currentlyAnimating = true;
}
}
private void OnFrameChanged(object o, EventArgs e)
{
//Force a call to the Paint event handler.
this.Invalidate();
}
protected override void OnPaint(PaintEventArgs e)
{
//Begin the animation.
AnimateImage();
//Get the next frame ready for rendering.
ImageAnimator.UpdateFrames();
//Draw the next frame in the animation.
e.Graphics.DrawImage(this.animatedImage, new Point(0, 0));
}
}
Add this control to your logo form:
public Logo()
{
InitializeComponent();
var progressSwirl = new AnimatedProgress();
progressSwirl.Location = new Point(50, 50);
Controls.Add(progressSwirl);
}
(I found adding it via code worked better than using the designer as I'd just referenced the image fairly crudely in my AnimatedProgress control and the VS designer couldn't find the image.)
Your cycling ring will then appear on your splash screen.
In terms of the "simplest" way to show the splash screen props must go to Veldmius for pointing out the SpalshScreen property:
Start by adding a reference to Microsoft.VisualBasic.dll to your project, then update your program.cs to something like:
using System;
using System.Windows.Forms;
using Microsoft.VisualBasic.ApplicationServices;
namespace WindowsFormsApplication1
{
public class Startup : WindowsFormsApplicationBase
{
protected override void OnCreateSplashScreen()
{
SplashScreen = new logo();
}
protected override void OnCreateMainForm()
{
MainForm = new Form1();
}
}
static class Program
{
[STAThread]
static void Main()
{
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
new Startup().Run(new string[]{});
}
}
}
To test this, I added a Thread.Sleep(5000) to the loading event of my main form, and there you have it - my logo page displayed with an animated progress for 5 seconds then my main form loaded in.

How to properly dispose multiple forms

Question: How to properly dispose the ScreenSaverForm(s) that is created in the method ShowScreensaver?
When I run CODE ANALYSIS from Visual Studio it reports the following: In method 'Program.ShowScreenSaver()', call System.IDisposable.Dispose on object 'ssf' before all references to it are out of scope.
I don't understand how to do that because the Application enters an anonymous message loop afters exiting method ShowScreenSaver(). Only the screensavers themselves can stop the application by calling Application.Exit() on mousemove-event. Should the screensaverForms dispose themselves perhaps?
static class Program
{
[STAThread]
static void Main(string[] args)
{
ShowScreenSaver();
Application.Run();
}
/// <summary>
/// Display the form on each of the computer's monitors.
/// </summary>
static void ShowScreenSaver()
{
ScreenSaverForm ssf;
foreach (Screen screen in Screen.AllScreens)
{
ssf = new ScreenSaverForm(screen.Bounds);
ssf.Show();
}
}
}
Simplified code of the Screensaver class
public partial class ScreenSaverForm : Form
{
public ScreenSaverForm()
{
InitializeComponent();
//Display pretty image
ShowprettyImage();
}
private void ScreenSaverForm_MouseMove(object sender, MouseEventArgs e)
{
if (!mouseLocation.IsEmpty)
{
// Terminate if mouse is moved a significant distance
if (Math.Abs(mouseLocation.X - e.X) > 25 ||
Math.Abs(mouseLocation.Y - e.Y) > 25)
Application.Exit();
}
// Update current mouse location
mouseLocation = e.Location;
}
}

To comply with code analysis, you can just do:
static void ShowScreenSaver() {
foreach (Screen screen in Screen.AllScreens) {
ScreenSaverForm form = new ScreenSaverForm(screen.Bounds);
form.FormClosed += (sender, e) => {
form.Dispose();
};
form.Show();
}
}
If you know when you will be done with it and you no longer need it, get rid of it.

Let them dispose themselves. They'll be freed up when the screensaver stops and the executable is shut down.
If you really want to, you can make the ssf object a class level field and dispose of it when the application shuts down, and that would be the best practice.
You could also have ShowScreenSaver return the form, and use the Application.Run that takes a form as a parameter, and add an event to the application exit that will dispose of it for you.
ScreenSaverForm form = ShowScreenSaver();
Application.ApplicationExit += (sender, e) => form.Dispose();
Application.Run(form);

First I would say bring ssf variable into the loop
static void ShowScreenSaver()
{
foreach (Screen screen in Screen.AllScreens)
{
ScreenSaverForm ssf = new ScreenSaverForm(screen.Bounds);
ssf.Show();
}
}
This may already resolve a problem.
It's enough to manage, if you need that, the disposal inside the form itself.

progressBar while MainFrom initialize

I have a windows form application that needs to load a bunch of things before loading the Main window. I thought this would justify a ProgressBar, so I thought I display another form that contains the ProgressBar Control using the constructor of my main form.
It all works fine but if I try to put the text in a Label on the intro form its content won't show until the main form is loaded. Is here a way to avoid this other than loading the intro window first?

Warning: this post contains elements of self promotion ;o)
I would probably use a splash form in this case. I wrote a blog post a while ago (triggered by this SO Q&A) about a thread-safe splash form that could be used together will long-running main form initializations.
In short the approach is to using ShowDialog, but to create and display the form on a separate thread so it doesn't block the main thread. The form contains a status message label (could of course be extended with a progressbar as well). Then there is a static class that provides thread-safe methods for displaying, updating and closing the splash form.
Condensed code samples (for commented code samples, check the blog post):
using System;
using System.Windows.Forms;
public interface ISplashForm
{
IAsyncResult BeginInvoke(Delegate method);
DialogResult ShowDialog();
void Close();
void SetStatusText(string text);
}
using System.Windows.Forms;
public partial class SplashForm : Form, ISplashForm
{
public SplashForm()
{
InitializeComponent();
}
public void SetStatusText(string text)
{
_statusText.Text = text;
}
}
using System;
using System.Windows.Forms;
using System.Threading;
public static class SplashUtility<T> where T : ISplashForm
{
private static T _splash = default(T);
public static void Show()
{
ThreadPool.QueueUserWorkItem((WaitCallback)delegate
{
_splash = Activator.CreateInstance<T>();
_splash.ShowDialog();
});
}
public static void Close()
{
if (_splash != null)
{
_splash.BeginInvoke((MethodInvoker)delegate { _splash.Close(); });
}
}
public static void SetStatusText(string text)
{
if (_splash != null)
{
_splash.BeginInvoke((MethodInvoker)delegate { _splash.SetStatusText(text); });
}
}
}
Example of usage:
SplashUtility<SplashForm>.Show();
SplashUtility<SplashForm>.SetStatusText("Working really hard...");
SplashUtility<SplashForm>.Close();

There sure is. It's called a BackgroundWorker.
Here is a code snippet from Figo Fei with slight modification for explanation purposes:
private void button1_Click(object sender, EventArgs e)
{
progressBar1.Maximum = 100;
backgroundWorker1.WorkerReportsProgress = true;
backgroundWorker1.ProgressChanged += new ProgressChangedEventHandler(backgroundWorker1_ProgressChanged);
backgroundWorker1.DoWork += new DoWorkEventHandler(backgroundWorker1_DoWork);
backgroundWorker1.RunWorkerCompleted += new RunWorkerCompletedEventHandler(backgroundWorker1_RunWorkerCompleted);
backgroundWorker1.RunWorkerAsync();
}
private void backgroundWorker1_DoWork(object sender, DoWorkEventArgs e)
{
// This would be the load process, where you put your Load methods into.
// You would report progress as something loads.
for (int i = 0; i < 100; i++)
{
Thread.Sleep(100);
backgroundWorker1.ReportProgress(i); //run in back thread
}
}
private void backgroundWorker1_ProgressChanged(object sender, ProgressChangedEventArgs e) //call back method
{
progressBar1.Value = e.ProgressPercentage;
}
private void backgroundWorker1_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e) //call back method
{
progressBar1.Value = progressBar1.Maximum;
}
Hope this helps you.

You can show your SplashForm from either the main program or the MainForm constructor, that doesn't really matter. What you are seeing is that as long as your Loading process isn't completed, no messages are processed and hence no Screen updates are happening. The ProgressBar is an exception, it runs it's own thread for precisely this reason.
The short solution is to do a SplashForm.Update() after changing the Label. A little more involved would be to start a separate Thread with a MessagePump (Application.Run). Here is a SO question with some more leads.

The problem is most likely because there is not a running message loop at the time you are attempting to display the progress bar form. There should be a line of code that looks something like the following in the entry point of your application.
Application.Run(new Form1());
The call to Application.Run will start the message loop, but do you see how the Form1 constructor is executed before the message loop is running? And since your progress bar logic is in that constructor then there is no mechanism running that can dispatch the form's painting messages.
I think the best approach is to load a splash screen first and kick off a worker thread (you could use BackgroundWorker for that) that does the time consuming work. The progress bar will live on the splash screen form and you will update that periodically. Once the work is complete then you can close the splash screen and load the main form.