Program: What Time Do I Leave Friday

Posted on 14 Aug 2006 by Brian A. Thomas 3

Last Update 9 September 2006.
What Time Do I Leave Friday is a program I created in C# using Visual C# 2005 Express Edition. It is the first "semi-practical" program I have made. (I say "semi-practical" as I don't have a way of using it at work, since I don't have a laptop.)

Simply stated, the program is designed for people who are mostly on Flex Time and want to find out when they should leave on their last day of the work week. The user enters the hours they worked so far, the time they came in that day, a lunch if they take one, and it will give them the time to leave.
You can get it from here.
I will post the code to it's own page to keep this page from getting too far out of hand.
Here are some screenshots:
The main screen:
Mian screen of my program, What Time Do I Leave Friday
Here the user enters the total hours they worked so far this week (using the action menu they can change the standard work week hours from 40:00), they also enter the time they got in Friday (or whatever their last day of work is) and a lunch if applicable. It will then display what time they are to leave Friday.

Here is the lunch screen:
Lunch screen of my program, What Time Do I Leave Friday
Here the user can choose to enter their lunch time (for example 0:30 for 30 minutes) or put in their time out to and in from lunch.

Here is the main screen after being used (I typically don't take a lunch, but for this example I entered one):
Main screen in use, after entering lunch and other information for my program, What Time Do I Leave Friday

Here is some of the code (I don't present the code for the designer since I figure it isn't necessary, it should be easy enough to figure it out from the screenshots, the program itself and the code below). The code is presented in alphabetical order.

Changes Log:
9 September 2006 - Minor changes to the Validator class. Semi-major change to the main window itself. The program now checks if the user entered a decimal time in one of the two main text boxes, if so, a message box comes up to be sure that is what they wanted to enter. I probably didn't handle that one the best way.

This is the Convert Time class that easily enough converts the time from one format to another for use in the program.

PLAIN TEXT
C#:
  1. // **********************************************
  2. // Program Name: What Time Do I Leave Friday
  3. // Program Author: Brian A. Thomas
  4. // Program Homepage: http://www.brianathomas.com/
  5. // Author Homepage: http://www.brianathomas.com/
  6. // **********************************************
  7. // This Namespace: WhatTimeFriday
  8. // NOTE: This will likely change in future versions
  9. // to be in my own library set.
  10. // **********************************************
  11. // Class: ConvertTime
  12. // Class Author: Brian A. Thomas
  13. // Class webpage: http://www.brianathomas.com/
  14. // This Class Version: 0.4
  15. // This Class Copyright: 2006 by Brian A. Thomas
  16. // **********************************************
  17. /*
  18.      This file is part of What Time Do I Leave Friday.
  20.     What Time Do I Leave Friday is free software; you can redistribute it
  21.     and/or modify it under the terms of the GNU General Public License as
  22.     published by the Free Software Foundation; version 2 of the
  23.     License, or any later version.
  25.     What Time Do I Leave Friday is distributed in the hope that it will be
  26.     useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
  27.     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  28.     GNU General Public License for more details.
  30.     You should have received a copy of the GNU General Public License
  31.     along with What Time Do I Leave Friday; if not, write to the Free Software
  32.     Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  33. */
  34.  
  35. using System;
  36. using System.Collections.Generic;
  37. using System.Text;
  38. using System.Windows.Forms;
  39.  
  40. namespace WhatTimeFriday
  41. {
  42.     /// <summary>
  43.     /// ConvertTime Class has a few methods for converting time
  44.     /// currently it converts a standard format time such as 8:30 into
  45.     /// decimal time, and from military time to standard time
  46.     /// </summary>
  47.     class ConvertTime
  48.     {
  49.         /// <summary>
  50.         /// Changes time from standard format such as 8:30 into decimal time
  51.         /// (not the French version) but breaking minutes into hundreds. For
  52.         /// example 8:30 becomes 8.5.
  53.         /// </summary>
  54.         /// <param name="s">time in string format without the AM/PM</param>
  55.         /// <returns>time in double format</returns>
  56.         public static double ToDecimal(string s)
  57.         {
  58.             // had to add as canceling a lunch addition caused an error.
  59.             if (s == null)
  60.             {
  61.                 s = "0.00";
  62.             }
  63.             if (s.IndexOf(':') <0)
  64.             {
  65.                 // for some reason using a conditional or in the above didn't
  66.                 // work. It was set as (s.IndexOf(':') <0 || s.IndexOf('.')
  67.                 // <0) but if a string did have a : in it, it still went
  68.                 // to CantConvert
  69.                 if (s.IndexOf('.')>= 0)
  70.                 {
  71.                     // don't worry about it.
  72.                 }
  73.                 else
  74.                 {
  75.                     s = CantConvert(s);
  76.                 }
  77.             }
  78.             if (s.IndexOf(':')> -1) // check to see if it has a : in the time
  79.             //if so we need to turn it into a decimal time for
  80.             {
  81.                 // first split hours and minutes apart
  82.                 string[] allTime = s.Split(':');
  83.                 string hoursString = allTime[0];
  84.                 string minutesString = allTime[1];
  85.                 if (minutesString == "")
  86.                 {
  87.                     minutesString = "00";
  88.                 }
  89.                 //string secondsString = allTime[2];
  90.                 // above not used currently
  91.                 double minutes = Convert.ToInt32(minutesString);
  92.                 minutes /= 60;
  93.                 if (minutes <1 && minutes> 0)
  94.                 {
  95.                     string timeString = minutes.ToString();
  96.                     string[] fullTime = timeString.Split('.');
  97.                     string wholeString = fullTime[0];
  98.                     string portionString = fullTime[1];
  99.                     minutesString = portionString;
  100.                 }
  101.                 else
  102.                 {
  103.                     minutesString = "00";
  104.                 }
  105.                 string returnTime = hoursString + "." + minutesString;
  106.                 double time = Convert.ToDouble(returnTime);
  107.                 return time;
  108.             } // end if :
  109.             else
  110.             {
  111.                 string returnTime = s;
  112.                 // in theory, shouldn't need, but testing showed otherwise...
  113.                 // actually, should be gone for sure now after adding the
  114.                 // if(s==null) above, but will leave to be safe.
  115.                 if (returnTime == "")
  116.                 {
  117.                     returnTime = "0.00";
  118.                 }
  119.                 double time = Convert.ToDouble(returnTime);
  120.                 return time;
  121.             } // end else already in decimal time
  122.         }// end ToDecimal method of ConvertTime class
  123.  
  124.         /// <summary>
  125.         /// Converts from military time to standard time in the event the user
  126.         /// entered military time (24 hour time compared to 12 hour time)
  127.         /// </summary>
  128.         /// <param name="s">time in string format without the AM/PM</param>
  129.         /// <returns>time in string format with :</returns>
  130.         public static string NonMillTime(string s)
  131.         {
  132.             if (s == null)
  133.             {
  134.                 s = "0:00";
  135.             }
  136.             if (s.IndexOf(':') <0)
  137.             {
  138.                 // for some reason using a conditional or in the above didn't
  139.                 // work. It was set as (s.IndexOf(':') <0 || s.IndexOf('.')
  140.                 // <0) but if a string did have a : in it, it still went
  141.                 // to CantConvert
  142.                 if (s.IndexOf('.')>= 0)
  143.                 {
  144.                     // don't worry about it.
  145.                 }
  146.                 else
  147.                 {
  148.                     s = CantConvert(s);
  149.                 }
  150.             }
  151.             string[] allTime = s.Split(':');
  152.             string hoursString = allTime[0];
  153.             string minutesString = allTime[1];
  154.             if (minutesString == "")
  155.             {
  156.                 minutesString = "00";
  157.             }
  158.             // string secondsString = allTime[2];
  159.             // above not used currently
  160.             double hours = Convert.ToDouble(hoursString);
  161.             if (hours> 12)
  162.             {
  163.                 hours -= 12;
  164.                 WhatTimeFriday.MainWindow.PM = true;
  165.             } // end hours> 12
  166.             string returnTime = hours.ToString() + ":" + minutesString;
  167.             return returnTime;
  168.         } // end StandardTime Method of ConvertTime Class
  169.  
  170.         /// <summary>
  171.         /// Truns decimal time (not French version) to stnadard time with
  172.         /// a : as the time seperator. So 8.5 becomes 8:30.
  173.         /// </summary>
  174.         /// <param name="s">time in string format without the AM/PM</param>
  175.         /// <returns>time in string format with :</returns>
  176.         public static string StandardTime(string s)
  177.         {
  178.             // had to add as canceling adding a lunch caused an error
  179.             if (s == null)
  180.             {
  181.                 s = "0:00";
  182.             }
  183.             if (s.IndexOf(':') <0)
  184.             {
  185.                 // for some reason using a conditional or in the above didn't
  186.                 // work. It was set as (s.IndexOf(':') <0 || s.IndexOf('.')
  187.                 // <0) but if a string did have a : in it, it still went
  188.                 // to CantConvert
  189.                 if (s.IndexOf('.')>= 0)
  190.                 {
  191.                     // don't worry about it.
  192.                 }
  193.                 else
  194.                 {
  195.                     s = CantConvert(s);
  196.                 }
  197.             }
  198.             if (s.IndexOf(':')> -1)
  199.             {
  200.                 //already has a : so it is okay
  201.                 // had to add the split just in case user entered
  202.                 // :30 for lunch or something like that where the hour
  203.                 // string is empty
  204.                 string[] allTime = s.Split(':');
  205.                 string hoursString = allTime[0];
  206.                 string minutesString = allTime[1];
  207.                 if (minutesString == "")
  208.                 {
  209.                     minutesString = "00";
  210.                 }
  211.                 if (hoursString == "")
  212.                 {
  213.                     hoursString = "0";
  214.                 }
  215.                 s = hoursString + ":" + minutesString;
  216.                 return s;
  217.             } // end if s has a :
  218.             else
  219.             {
  220.                 if (s == "" || s == "0")
  221.                 {
  222.                     s = "0.00";
  223.                 }
  224.                 string[] allTime = s.Split('.');
  225.                 string hoursString = allTime[0];
  226.                 // just in case the hoursString is empty
  227.                 if (hoursString == "")
  228.                 {
  229.                     hoursString = "0";
  230.                 }
  231.                 string minutesString = allTime[1];
  232.                 if (minutesString == "")
  233.                 {
  234.                     minutesString = "00";
  235.                 }
  236.                 // string secondsString = allTime[2];
  237.                 // above not used currently
  238.                 minutesString = "." + minutesString;
  239.                 double minutes = Convert.ToDouble(minutesString);
  240.                 minutes *= 60;
  241.                 minutesString = minutes.ToString("f0"); //needs to remove the
  242.                 // decimal place if there is one, otherwise there are problems
  243.                 // probably will add to the seconds if that seconds are ever
  244.                 // calculated
  245.                 if (minutesString == "0")
  246.                 {
  247.                     minutesString = "00";
  248.                 }
  249.                 string returnTime = hoursString + ":" + minutesString;
  250.                 return returnTime;
  251.             }
  252.         } // end StandardTime method of ConvertTimeClass
  253.  
  254.         /// <summary>
  255.         /// Shouldn't actually be used as the method calling the ConvertTime
  256.         /// class should validate before sending.
  257.         /// If string coming into ConvertTiem doesn't have a : or a . in it
  258.         /// adds a :
  259.         /// </summary>
  260.         /// <param name="s">and integer in striang format</param>
  261.         /// <returns>a string with a : in it</returns>
  262.         private static string CantConvert(string s)
  263.         {
  264.             // Method calling the Convert Class should validate this before it
  265.             // sends it here, but just in case.
  266.             // presently I know of no way of knowing for sure which text box
  267.             // caused this from this class, which is why it should be validated
  268.             // by the method, class or something calling this class.
  269.             // Also, the string sent to the ConvertTime class may not be from a
  270.             // text box anyhow, so even knowing the text box may not help.
  271.             string sugestedTime;
  272.             if (s == "")
  273.             {
  274.                 s = "0";
  275.             }
  276.             int number = Convert.ToInt32(s);
  277.             if (number <0)
  278.             {
  279.                 // if the number is negative, reverse it
  280.                 number = -number;
  281.             }
  282.             if (number> 24 && number <60)
  283.             {
  284.                 // we'll guess that the user may want it in the minutes
  285.                 // spot if it is over 24 and under 60 since it can't be
  286.                 // more then 60 if it is minutes, and possibly minutes if
  287.                 // over 24 which would be the limit of the hours spot if it
  288.                 // is military time
  289.                 sugestedTime = "0:" + s;
  290.             }
  291.             else
  292.             {
  293.                 // this takes a huge range of 0 to 24 and from 60 on
  294.                 // as noted above, the calling method to the ConvertTime
  295.                 // class really needs to validate the string before sending
  296.                 // it here
  297.                 sugestedTime = s = ":00";
  298.             }
  299.             string message = "Can't convert " + s + " to a time.\n"
  300.             + "It needs a ":" either before it (hours) or after it"
  301.             + "(minutes).\n"
  302.             + "Pressing OK will return " + sugestedTime + ". If this is not "
  303.             + "correct you will need to edit the entry when you return.";
  304.             MessageBox.Show(message, "Entry Error");
  305.             return sugestedTime;
  306.         } // end CantConvert method of ConvertTime class
  307.     } // end ConvertTime class
  308. }

Here is the code for the Hours Worked Calculator:

PLAIN TEXT
C#:
  1. // **********************************************
  2. // Program Name: What Time Do I Leave Friday
  3. // Program Author: Brian A. Thomas
  4. // Program Homepage: http://www.brianathomas.com/
  5. // Author Homepage: http://www.brianathomas.com/
  6. // **********************************************
  7. // This Namespace: WhatTimeFriday
  8. // **********************************************
  9. // This Class: HoursWorkedCalculator
  10. // This Class Author: Brian A. Thomas
  11. // This Class Version: 0.4
  12. // This Class Copyright: 2006 by Brian A. Thomas
  13. // **********************************************
  14. /*
  15.      This file is part of What Time Do I Leave Friday.
  17.     What Time Do I Leave Friday is free software; you can redistribute it
  18.     and/or modify it under the terms of the GNU General Public License as
  19.     published by the Free Software Foundation; version 2 of the
  20.     License, or any later version.
  22.     What Time Do I Leave Friday is distributed in the hope that it will be
  23.     useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
  24.     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  25.     GNU General Public License for more details.
  27.     You should have received a copy of the GNU General Public License
  28.     along with What Time Do I Leave Friday; if not, write to the Free Software
  29.     Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  30. */
  31.  
  32. using System;
  33. using System.Collections.Generic;
  34. using System.ComponentModel;
  35. using System.Data;
  36. using System.Drawing;
  37. using System.Text;
  38. using System.Windows.Forms;
  39.  
  40. namespace WhatTimeFriday
  41. {
  42.     /// <summary>
  43.     /// form for the Hours Worked Calculator
  44.     /// </summary>
  45.     public partial class HoursWorkedCalculator : Form
  46.     {
  47.         /// <summary>
  48.         /// Main class for the Hours Worked Calculator
  49.         /// </summary>
  50.         public HoursWorkedCalculator()
  51.         {
  52.             InitializeComponent();
  53.         }
  54.  
  55.         // global variable to track days added, user can only add up to 6 days
  56.         // since even if they were working 7 days, the main form keeps care
  57.         // of the 7th day
  58.         int dayAdded = 0;
  59.         string amPmOutBreak1 = "AM";
  60.         string amPmInBreak1 = "AM";
  61.         string amPmOutLunch = "AM";
  62.         string amPmInLunch = "AM";
  63.         string amPmOutBreak2 = "AM";
  64.         string amPmInBreak2 = "AM";
  65.         string lunchTime = "0:00";
  66.         private bool ok = true;
  67.         string amPmInForDay = "AM";
  68.         string amPMOutForDay = "PM";
  69.         string hoursWorkedWeek = "0:00";
  70.  
  71.         // user has the use clock radio button picked
  72.         private void rbnUseClock_CheckedChanged(object sender, EventArgs e)
  73.         {
  74.             grpHoursBox.Text = "Step 4";
  75.             grpSendBox.Text = "Step 5";
  76.             grpLunchClock.Enabled = true;
  77.             grpAddBox.Enabled = true;
  78.             txtDay1Hours.ReadOnly = true;
  79.             txtDay2Hours.ReadOnly = true;
  80.             txtDay3Hours.ReadOnly = true;
  81.             txtDay4Hours.ReadOnly = true;
  82.             txtDay5Hours.ReadOnly = true;
  83.             txtDay6Hours.ReadOnly = true;
  84.             txtInForDay.TabStop = true;
  85.             cboInForDayAmPm.TabStop = true;
  86.             txtOutBreak1.TabStop = true;
  87.             cboOutBreak1AmPm.TabStop = true;
  88.             txtInBreak1.TabStop = true;
  89.             cboInBreak1AmPm.TabStop = true;
  90.             txtOutToLunch.TabStop = true;
  91.             cboOutLunchAmPm.TabStop = true;
  92.             txtInFromLunch.TabStop = true;
  93.             cboInLunchAmPm.TabStop = true;
  94.             txtOutBreak2.TabStop = true;
  95.             cboOutBreak2AmPm.TabStop = true;
  96.             txtInBreak2.TabStop = true;
  97.             cboInBreak2AmPm.TabStop = true;
  98.             txtOutForDay.TabStop = true;
  99.             cboOutForDayAmPm.TabStop = true;
  100.             txtDay1Hours.TabStop = false;
  101.             txtDay2Hours.TabStop = false;
  102.             txtDay3Hours.TabStop = false;
  103.             txtDay4Hours.TabStop = false;
  104.             txtDay5Hours.TabStop = false;
  105.             txtDay6Hours.TabStop = false;
  106.             btnAdd.Enabled = false;
  107.             btnAddTogether.Enabled = false;
  108.             btnSend.Enabled = false;
  109.         }
  110.  
  111.         // user has the total hours radio button checked
  112.         private void rbtnUseHours_CheckedChanged(object sender, EventArgs e)
  113.         {
  114.             grpHoursBox.Text = "Step 2";
  115.             grpSendBox.Text = "Step 3";
  116.             grpLunchClock.Enabled = false;
  117.             grpAddBox.Enabled = false;
  118.             txtDay1Hours.ReadOnly = false;
  119.             txtDay2Hours.ReadOnly = false;
  120.             txtDay3Hours.ReadOnly = false;
  121.             txtDay4Hours.ReadOnly = false;
  122.             txtDay5Hours.ReadOnly = false;
  123.             txtDay6Hours.ReadOnly = false;
  124.             txtDay1Hours.TabStop = true;
  125.             txtDay2Hours.TabStop = true;
  126.             txtDay3Hours.TabStop = true;
  127.             txtDay4Hours.TabStop = true;
  128.             txtDay5Hours.TabStop = true;
  129.             txtDay6Hours.TabStop = true;
  130.             btnAddTogether.Enabled = true;
  131.             btnSend.Enabled = false;
  132.         }
  133.  
  134.         // user clicked the cancel button
  135.         private void btnCancel_Click(object sender, EventArgs e)
  136.         {
  137.             this.Close();
  138.         }
  139.  
  140.         // load event for the Hours Worked Calcuator form
  141.         private void HoursWorkedCalculator_Load(object sender, EventArgs e)
  142.         {
  143.             cboInForDayAmPm.Items.Add("AM");
  144.             cboInForDayAmPm.Items.Add("PM");
  145.             cboInForDayAmPm.SelectedIndex = 0;
  146.             cboOutLunchAmPm.Items.Add("AM");
  147.             cboOutLunchAmPm.Items.Add("PM");
  148.             cboOutLunchAmPm.SelectedIndex = 0;
  149.             cboInLunchAmPm.Items.Add("AM");
  150.             cboInLunchAmPm.Items.Add("PM");
  151.             cboInLunchAmPm.SelectedIndex = 0;
  152.             cboInBreak1AmPm.Items.Add("AM");
  153.             cboInBreak1AmPm.Items.Add("PM");
  154.             cboInBreak1AmPm.SelectedIndex = 0;
  155.             cboOutBreak1AmPm.Items.Add("AM");
  156.             cboOutBreak1AmPm.Items.Add("PM");
  157.             cboOutBreak1AmPm.SelectedIndex = 0;
  158.             cboInBreak2AmPm.Items.Add("AM");
  159.             cboInBreak2AmPm.Items.Add("PM");
  160.             cboInBreak2AmPm.SelectedIndex = 1;
  161.             cboOutBreak2AmPm.Items.Add("AM");
  162.             cboOutBreak2AmPm.Items.Add("PM");
  163.             cboOutBreak2AmPm.SelectedIndex = 1;
  164.             cboOutForDayAmPm.Items.Add("AM");
  165.             cboOutForDayAmPm.Items.Add("PM");
  166.             cboOutForDayAmPm.SelectedIndex = 1;
  167.             rbnUseClock_CheckedChanged(sender, e);
  168.         }
  169.  
  170.         // user clicked the Calculate button
  171.         private void btnCalculate_Click(object sender, EventArgs e)
  172.         {
  173.             // must add the if(!(Validator. stuff here
  174.             if (!(Validator.IsPresent(txtInForDay) &&
  175.                 Validator.IsPresent(txtOutBreak1) &&
  176.                 Validator.IsPresent(txtInBreak1) &&
  177.                 Validator.IsPresent(txtOutToLunch) &&
  178.                 Validator.IsPresent(txtInFromLunch) &&
  179.                 Validator.IsPresent(txtOutBreak2) &&
  180.                 Validator.IsPresent(txtInBreak2) &&
  181.                 Validator.IsPresent(txtOutForDay) &&
  182.                 Validator.IsTime(txtInForDay) &&
  183.                 Validator.IsTime(txtOutBreak1) &&
  184.                 Validator.IsTime(txtInBreak1) &&
  185.                 Validator.IsTime(txtOutToLunch) &&
  186.                 Validator.IsTime(txtInFromLunch) &&
  187.                 Validator.IsTime(txtOutBreak2) &&
  188.                 Validator.IsTime(txtInBreak2) &&
  189.                 Validator.IsTime(txtOutForDay)
  190.                 ))
  191.             {
  192.                 ok = false;
  193.             }
  194.             else
  195.             {
  196.                 // calcualte time in and out for day
  197.                 string inForDay = ConvertTime.StandardTime(txtInForDay.Text);
  198.                 inForDay = ConvertTime.NonMillTime(inForDay);
  199.                 inForDay += amPmInForDay;
  200.                 string outForDay = ConvertTime.StandardTime(txtOutForDay.Text);
  201.                 outForDay = ConvertTime.NonMillTime(outForDay);
  202.                 outForDay += amPMOutForDay;
  203.                 DateTime inDay = DateTime.Parse(inForDay);
  204.                 DateTime outDay = DateTime.Parse(outForDay);
  205.                 TimeSpan workedToday = outDay - inDay;
  206.                 hoursWorkedWeek = workedToday.ToString();
  207.  
  208.                 // calculate lunch and breaks
  209.                 // Break 1
  210.                 string outToBreak1 =
  211.                     ConvertTime.StandardTime(txtOutBreak1.Text);
  212.                 outToBreak1 = ConvertTime.NonMillTime(outToBreak1);
  213.                 outToBreak1 += amPmOutBreak1;
  214.                 string inFromBreak1 =
  215.                     ConvertTime.StandardTime(txtInBreak1.Text);
  216.                 inFromBreak1 = ConvertTime.NonMillTime(inFromBreak1);
  217.                 inFromBreak1 += amPmInBreak1;
  218.                 DateTime outBreak1 = DateTime.Parse(outToBreak1);
  219.                 DateTime inBreak1 = DateTime.Parse(inFromBreak1);
  220.                 TimeSpan break1 = inBreak1 - outBreak1;
  221.  
  222.                 // Lunch
  223.                 string outToLunch =
  224.                     ConvertTime.StandardTime(txtOutToLunch.Text);
  225.                 outToLunch = ConvertTime.NonMillTime(outToLunch);
  226.                 outToLunch += amPmOutLunch;
  227.                 string inFromLunch =
  228.                     ConvertTime.StandardTime(txtInFromLunch.Text);
  229.                 inFromLunch = ConvertTime.NonMillTime(inFromLunch);
  230.                 inFromLunch += amPmInLunch;
  231.                 DateTime outLunch = DateTime.Parse(outToLunch);
  232.                 DateTime inLunch = DateTime.Parse(inFromLunch);
  233.                 TimeSpan lunch = inLunch - outLunch;
  234.  
  235.                 //Break 2
  236.                 string outToBreak2 =
  237.                     ConvertTime.StandardTime(txtOutBreak2.Text);
  238.                 outToBreak2 = ConvertTime.NonMillTime(outToBreak2);
  239.                 outToBreak2 += amPmOutBreak2;
  240.                 string inFromBreak2 =
  241.                     ConvertTime.StandardTime(txtInBreak2.Text);
  242.                 inFromBreak2 = ConvertTime.NonMillTime(inFromBreak2);
  243.                 inFromBreak2 += amPmInBreak2;
  244.                 DateTime outBreak2 = DateTime.Parse(outToBreak2);
  245.                 DateTime inBreak2 = DateTime.Parse(inFromBreak2);
  246.                 TimeSpan break2 = inBreak2 - outBreak2;
  247.  
  248.                 TimeSpan lunchTotal = break1.Add(break2);
  249.                 lunchTotal = lunchTotal.Add(lunch);
  250.  
  251.                 string lunchTimeUsed = lunchTotal.ToString();
  252.                 //lunchTimeUsed = ConvertTime.NoAmPm(lunchTimeUsed);
  253.                 lunchTime = lunchTimeUsed;
  254.  
  255.                 // now calculate hours worked - lunch
  256.                 double worked = ConvertTime.ToDecimal(hoursWorkedWeek);
  257.                 double lunchBreaks = ConvertTime.ToDecimal(lunchTime);
  258.                 worked = worked - lunchBreaks;
  259.                 string forwardTime = worked.ToString();
  260.                 // just in case we get back a whole number, which is likely
  261.                 // othewise ConvertTime.StandardTime will have a problem.
  262.                 if (forwardTime.IndexOf('.') <0)
  263.                 {
  264.                     forwardTime += ":00";
  265.                 }
  266.                 forwardTime = ConvertTime.StandardTime(forwardTime);
  267.                 txtTotalHoursDay.Text = forwardTime;
  268.                 btnAdd.Enabled = true;
  269.                 ok = true;
  270.             }
  271.         }
  272.  
  273.         // user clicked the add button
  274.         private void btnAdd_Click(object sender, EventArgs e)
  275.         {
  276.             dayAdded++;
  277.             if (dayAdded == 6)
  278.             {
  279.                 grpLunchClock.Enabled = false;
  280.                 // MessageBox.Show("You may only enter up to 6 work days. If you"
  281.                 //+ " are working 7 days, that will be kept care of on the main"
  282.                 //+ " window.", "Entry Error");
  283.             }
  284.             switch (dayAdded)
  285.             {
  286.                 case 1:
  287.                     txtDay1Hours.Text = txtTotalHoursDay.Text;
  288.                     lblDay.Text = "second";
  289.                     lblDayCon.Text = "Day 2:";
  290.                     btnAddTogether.Enabled = true;
  291.                     break;
  292.                 case 2:
  293.                     txtDay2Hours.Text = txtTotalHoursDay.Text;
  294.                     lblDay.Text = "third";
  295.                     lblDayCon.Text = "Day 3:";
  296.                     break;
  297.                 case 3:
  298.                     txtDay3Hours.Text = txtTotalHoursDay.Text;
  299.                     lblDay.Text = "fourth";
  300.                     lblDayCon.Text = "Day 4:";
  301.                     break;
  302.                 case 4:
  303.                     txtDay4Hours.Text = txtTotalHoursDay.Text;
  304.                     lblDay.Text = "fifth";
  305.                     lblDayCon.Text = "Day 5:";
  306.                     break;
  307.                 case 5:
  308.                     txtDay5Hours.Text = txtTotalHoursDay.Text;
  309.                     lblDay.Text = "sixth";
  310.                     lblDayCon.Text = "Day 6:";
  311.                     break;
  312.                 case 6:
  313.                     txtDay6Hours.Text = txtTotalHoursDay.Text;
  314.                     break;
  315.             }
  316.         }
  317.  
  318.         // ucer is changing am/pm
  319.         private void cboInForDayAmPm_SelectedIndexChanged(object sender, EventArgs e)
  320.         {
  321.             if (cboInForDayAmPm.SelectedIndex == 1)
  322.             {
  323.                 amPmInForDay = "PM";
  324.  
  325.             }
  326.             else
  327.             {
  328.                 amPmInForDay = "AM";
  329.             }
  330.         }
  331.  
  332.         // user clicked the send button
  333.         private void btnSend_Click(object sender, EventArgs e)
  334.         {
  335.             if (ok)
  336.             {
  337.                 // allow form to close
  338.                 this.Tag = txtTotalHoursWeek.Text;
  339.                 this.DialogResult = DialogResult.OK;
  340.             }
  341.         }
  342.  
  343.         // user clicked the Add together button
  344.         private void btnAddTogether_Click(object sender, EventArgs e)
  345.         {
  346.             if(!(Validator.IsPresent(txtDay1Hours) &&
  347.                 Validator.IsPresent(txtDay2Hours) &&
  348.                 Validator.IsPresent(txtDay3Hours) &&
  349.                 Validator.IsPresent(txtDay4Hours) &&
  350.                 Validator.IsPresent(txtDay5Hours) &&
  351.                 Validator.IsPresent(txtDay6Hours) &&
  352.                 Validator.IsTime(txtDay1Hours) &&
  353.                 Validator.IsTime(txtDay2Hours) &&
  354.                 Validator.IsTime(txtDay3Hours) &&
  355.                 Validator.IsTime(txtDay4Hours) &&
  356.                 Validator.IsTime(txtDay5Hours) &&
  357.                 Validator.IsTime(txtDay6Hours)))
  358.             {
  359.                 ok = false;
  360.             }
  361.             else
  362.             {
  363.                 double day1 = ConvertTime.ToDecimal(txtDay1Hours.Text);
  364.                 double day2 = ConvertTime.ToDecimal(txtDay2Hours.Text);
  365.                 double day3 = ConvertTime.ToDecimal(txtDay3Hours.Text);
  366.                 double day4 = ConvertTime.ToDecimal(txtDay4Hours.Text);
  367.                 double day5 = ConvertTime.ToDecimal(txtDay5Hours.Text);
  368.                 double day6 = ConvertTime.ToDecimal(txtDay6Hours.Text);
  369.                 double totalHours = day1 + day2 + day3 + day4 + day5 + day6;
  370.                 string workedHours = totalHours.ToString("f2");
  371.                 if (workedHours.IndexOf('.') <0)
  372.                 {
  373.                     workedHours += ".00";
  374.                 }
  375.                 hoursWorkedWeek = ConvertTime.StandardTime(workedHours);
  376.                 if (hoursWorkedWeek == "0:00")
  377.                 {
  378.                     MessageBox.Show("All times have a zero value, so there is "
  379.                     + "nothing to add together", "Entry Error");
  380.                     txtDay1Hours.Focus();
  381.                 }
  382.                 else
  383.                 {
  384.                     ok = true;
  385.                     txtTotalHoursWeek.Text = hoursWorkedWeek;
  386.                     btnSend.Enabled = true;
  387.                 }
  388.             }
  389.            
  390.         }
  391.  
  392.         // user clicked Exit in the menu
  393.         private void exitToolStripMenuItem_Click(object sender, EventArgs e)
  394.         {
  395.             this.Close();
  396.         }
  397.  
  398.         // user clicked About in the menu
  399.         private void aboutToolStripMenuItem_Click(object sender, EventArgs e)
  400.         {
  401.             Form aboutForm = new AboutBox1();
  402.             aboutForm.ShowDialog();
  403.         }
  404.  
  405.         // user clicked the Contents for help the menu
  406.         private void contentsToolStripMenuItem_Click(object sender, EventArgs e)
  407.         {
  408.             Help.ShowHelp(this, this.helpProvider1.HelpNamespace);
  409.         }
  410.     }
  411. }

Here is the code for the Lunch window, it adds unpaid lunch/breaks to the day:

PLAIN TEXT
C#:
  1. // **********************************************
  2. // Program Name: What Time Do I Leave Friday
  3. // Program Author: Brian A. Thomas
  4. // Program Homepage: http://www.brianathomas.com/
  5. // Author Homepage: http://www.brianathomas.com/
  6. // **********************************************
  7. // This Namespace: WhatTimeFriday
  8. // **********************************************
  9. // This Class: frmLunch
  10. // This Class Author: Brian A. Thomas
  11. // This Class Version: 0.4.2
  12. // This Class Copyright: 2006 by Brian A. Thomas
  13. // **********************************************
  14. /*
  15.      This file is part of What Time Do I Leave Friday.
  17.     What Time Do I Leave Friday is free software; you can redistribute it
  18.     and/or modify it under the terms of the GNU General Public License as
  19.     published by the Free Software Foundation; version 2 of the
  20.     License, or any later version.
  22.     What Time Do I Leave Friday is distributed in the hope that it will be
  23.     useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
  24.     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  25.     GNU General Public License for more details.
  27.     You should have received a copy of the GNU General Public License
  28.     along with What Time Do I Leave Friday; if not, write to the Free Software
  29.     Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  30. */
  31.  
  32. using System;
  33. using System.Collections.Generic;
  34. using System.ComponentModel;
  35. using System.Data;
  36. using System.Drawing;
  37. using System.Text;
  38. using System.Windows.Forms;
  39.  
  40. namespace WhatTimeFriday
  41. {
  42.     /// <summary>
  43.     /// Code for the Lunch form. Allows the user to add unpaid lunchs and
  44.     /// breaks to the calculation on the main window
  45.     /// </summary>
  46.     public partial class frmLunch : Form
  47.     {
  48.         /// <summary>
  49.         /// Created by Visual C# 2005
  50.         /// </summary>
  51.         public frmLunch()
  52.         {
  53.             InitializeComponent();
  54.         }
  55.  
  56.         // set global variables
  57.         string amPmOutBreak1 = "AM";
  58.         string amPmInBreak1 = "AM";
  59.         string amPmOutLunch = "AM";
  60.         string amPmInLunch = "AM";
  61.         string amPmOutBreak2 = "AM";
  62.         string amPmInBreak2 = "AM";
  63.         // lunchTime is the string returned to the main window
  64.         string lunchTime = "0:00";
  65.         // will allow the lunch window to close so long as all is valid
  66.         private bool ok = true;
  67.  
  68.         // load event, sets AM/PM in combo boxes.
  69.         private void frmLunch_Load(object sender, EventArgs e)
  70.         {
  71.             cboOutLunchAmPm.Items.Add("AM");
  72.             cboOutLunchAmPm.Items.Add("PM");
  73.             cboOutLunchAmPm.SelectedIndex = 0;
  74.             cboInLunchAmPm.Items.Add("AM");
  75.             cboInLunchAmPm.Items.Add("PM");
  76.             cboInLunchAmPm.SelectedIndex = 0;
  77.             cboInBreak1AmPm.Items.Add("AM");
  78.             cboInBreak1AmPm.Items.Add("PM");
  79.             cboInBreak1AmPm.SelectedIndex = 0;
  80.             cboOutBreak1AmPm.Items.Add("AM");
  81.             cboOutBreak1AmPm.Items.Add("PM");
  82.             cboOutBreak1AmPm.SelectedIndex = 0;
  83.             cboInBreak2AmPm.Items.Add("AM");
  84.             cboInBreak2AmPm.Items.Add("PM");
  85.             cboInBreak2AmPm.SelectedIndex = 0;
  86.             cboOutBreak2AmPm.Items.Add("AM");
  87.             cboOutBreak2AmPm.Items.Add("PM");
  88.             cboOutBreak2AmPm.SelectedIndex = 0;
  89.             // focus on ClockTime text box as that is the default entry.
  90.             txtClockTime.Focus();
  91.         }
  92.  
  93.         // user chose to enter their lunch and unpaid breaks in a clock in/out
  94.         // format
  95.         private void rbtnClock_CheckedChanged(object sender, EventArgs e)
  96.         {
  97.             grpTotalLunchTime.Enabled = false;
  98.             grpLunchClock.Enabled = true;
  99.             txtOutToLunch.Focus();
  100.         }
  101.  
  102.         // user will enter total time of lunchs and unpaid breaks
  103.         private void rbtnTime_CheckedChanged(object sender, EventArgs e)
  104.         {
  105.             grpLunchClock.Enabled = false;
  106.             grpTotalLunchTime.Enabled = true;
  107.             txtClockTime.Focus();
  108.         }
  109.  
  110.         // close this form
  111.         private void btnCancel_Click(object sender, EventArgs e)
  112.         {
  113.             this.Close();
  114.         }
  115.  
  116.         /// <summary>
  117.         /// If all information if valid, calculate total lunch and unpaid
  118.         /// break time (if the user entered time into the clock) and then send
  119.         /// the information back to the main window
  120.         /// </summary>
  121.         /// <param name="sender">standard object sender</param>
  122.         /// <param name="e">standard event handler</param>
  123.         private void btnSave_Click(object sender, EventArgs e)
  124.         {
  125.             if (rbtnTime.Checked)
  126.             {
  127.                 // user entered a total time for lunch and unpaid breaks
  128.  
  129.                 //Validator.IsPresent(txtClockTime);
  130.                 //Validator.IsTime(txtClockTime);
  131.                 // was originally like above, but, every time something wasn't
  132.                 // valid, the error box would come up, I would hit OK then
  133.                 // the lunch window would go away with the box.
  134.                 // so added this Not logical operator to allow me to set
  135.                 // an okay or not bool value to false, allowing me to stop
  136.                 // the dialog result being OK.
  137.                 if (!(Validator.IsPresent(txtClockTime) &&
  138.                     Validator.IsTime(txtClockTime)))
  139.                 {
  140.                     // isn't valid so don't allow this form to close
  141.                     ok = false;
  142.                 }
  143.                 else
  144.                 {
  145.                     // make sure it isn't in decimal format then set to allow
  146.                     // ok to true so form can close
  147.                     // lunchTime will be returned to main window
  148.                     lunchTime = ConvertTime.StandardTime(txtClockTime.Text);
  149.                     if (lunchTime == "0:00")
  150.                     {
  151.                         MessageBox.Show("Time was a zero. If you want to "
  152.                             + "Cancel entry select the cancell button",
  153.                             "Entry Error");
  154.                         txtClockTime.Focus();
  155.                         ok = false;
  156.                     }
  157.                     else
  158.                     {
  159.                         ok = true;
  160.                     }
  161.                 }
  162.             }
  163.             else
  164.             {
  165.                 // user is using the clock function to calculate total
  166.                 // lunch and unpaid break time
  167.                 if(!(Validator.IsPresent(txtOutBreak1) &&
  168.                     Validator.IsTime(txtOutBreak1) &&
  169.                     Validator.IsPresent(txtInBreak1) &&
  170.                     Validator.IsTime(txtInBreak1) &&
  171.                     Validator.IsPresent(txtOutToLunch) &&
  172.                     Validator.IsPresent(txtInFromLunch) &&
  173.                     Validator.IsTime(txtOutToLunch) &&
  174.                     Validator.IsTime(txtInFromLunch) &&
  175.                     Validator.IsPresent(txtOutBreak2) &&
  176.                     Validator.IsTime (txtOutBreak2) &&
  177.                     Validator.IsPresent(txtInBreak2) &&
  178.                     Validator.IsTime(txtInBreak2)))
  179.                 {
  180.                     // isn't valid, so don't allow this form to close
  181.                     ok = false;
  182.                 }
  183.                 else
  184.                 {
  185.                     // entries are valid, so start calculating
  186.  
  187.                     // Break 1
  188.                     string outToBreak1 =
  189.                         ConvertTime.StandardTime(txtOutBreak1.Text);
  190.                     outToBreak1 = ConvertTime.NonMillTime(outToBreak1);
  191.                     outToBreak1 += amPmOutBreak1;
  192.                     string inFromBreak1 =
  193.                         ConvertTime.StandardTime(txtInBreak1.Text);
  194.                     inFromBreak1 = ConvertTime.NonMillTime(inFromBreak1);
  195.                     inFromBreak1 += amPmInBreak1;
  196.                     DateTime outBreak1 = DateTime.Parse(outToBreak1);
  197.                     DateTime inBreak1 = DateTime.Parse(inFromBreak1);
  198.                     TimeSpan break1 = inBreak1 - outBreak1;
  199.  
  200.                     // Lunch
  201.                     string outToLunch =
  202.                         ConvertTime.StandardTime(txtOutToLunch.Text);
  203.                     outToLunch = ConvertTime.NonMillTime(outToLunch);
  204.                     outToLunch += amPmOutLunch;
  205.                     string inFromLunch =
  206.                         ConvertTime.StandardTime(txtInFromLunch.Text);
  207.                     inFromLunch = ConvertTime.NonMillTime(inFromLunch);
  208.                     inFromLunch += amPmInLunch;
  209.                     DateTime outLunch = DateTime.Parse(outToLunch);
  210.                     DateTime inLunch = DateTime.Parse(inFromLunch);
  211.                     TimeSpan lunch = inLunch - outLunch;
  212.  
  213.                     //Break 2
  214.                     string outToBreak2 =
  215.                         ConvertTime.StandardTime(txtOutBreak2.Text);
  216.                     outToBreak2 = ConvertTime.NonMillTime(outToBreak2);
  217.                     outToBreak2 += amPmOutBreak2;
  218.                     string inFromBreak2 =
  219.                         ConvertTime.StandardTime(txtInBreak2.Text);
  220.                     inFromBreak2 = ConvertTime.NonMillTime(inFromBreak2);
  221.                     inFromBreak2 += amPmInBreak2;
  222.                     DateTime outBreak2 = DateTime.Parse(outToBreak2);
  223.                     DateTime inBreak2 = DateTime.Parse(inFromBreak2);
  224.                     TimeSpan break2 = inBreak2 - outBreak2;
  225.  
  226.                     // start calcualting total lunch and unpaid breaks
  227.                     TimeSpan lunchTotal = break1.Add(break2);
  228.                     lunchTotal = lunchTotal.Add(lunch);
  229.                     string lunchTimeUsed = lunchTotal.ToString();
  230.                     // lunchTime will be returned to main window
  231.                     lunchTime = lunchTimeUsed;
  232.                     if (lunchTime == "0:00")
  233.                     {
  234.                         MessageBox.Show("Time was a zero. If you want to "
  235.                             + "Cancel entry select the cancell button",
  236.                             "Entry Error");
  237.                         ok = false;
  238.                         txtOutToLunch.Focus();
  239.                     }
  240.                     else
  241.                     {
  242.                         ok = true;
  243.                     }
  244.                 }
  245.             }
  246.  
  247.             // sets lunchTime to be value to be returned to main window
  248.             this.Tag = lunchTime;
  249.             if (ok)
  250.             {
  251.                 // allow form to close
  252.                 this.DialogResult = DialogResult.OK;
  253.             }
  254.         }
  255.  
  256.         // set the AM/PM combo boxes
  257.         private void cboOutLunchAmPm_SelectedIndexChanged(object sender, EventArgs e)
  258.         {
  259.             if (cboOutLunchAmPm.SelectedIndex == 1)
  260.             {
  261.                 amPmOutLunch = "PM";
  262.  
  263.             }
  264.             else
  265.             {
  266.                 amPmOutLunch = "AM";
  267.             }
  268.         }
  269.  
  270.         private void cboInLunchAmPm_SelectedIndexChanged(object sender, EventArgs e)
  271.         {
  272.             if (cboInLunchAmPm.SelectedIndex == 1)
  273.             {
  274.                 amPmInLunch = "PM";
  275.  
  276.             }
  277.             else
  278.             {
  279.                 amPmInLunch = "AM";
  280.             }
  281.         }
  282.  
  283.         private void cboOutBreak1AmPm_SelectedIndexChanged(object sender, EventArgs e)
  284.         {
  285.             if (cboOutBreak1AmPm.SelectedIndex == 1)
  286.             {
  287.                 amPmOutBreak1 = "PM";
  288.  
  289.             }
  290.             else
  291.             {
  292.                 amPmOutBreak1 = "AM";
  293.             }
  294.         }
  295.  
  296.         private void cboInBreak1AmPm_SelectedIndexChanged(object sender, EventArgs e)
  297.         {
  298.             if (cboInBreak1AmPm.SelectedIndex == 1)
  299.             {
  300.                 amPmInBreak1 = "PM";
  301.  
  302.             }
  303.             else
  304.             {
  305.                 amPmInBreak1 = "AM";
  306.             }
  307.         }
  308.  
  309.         private void cboOutBreak2AmPm_SelectedIndexChanged(object sender, EventArgs e)
  310.         {
  311.             if (cboOutBreak2AmPm.SelectedIndex == 1)
  312.             {
  313.                 amPmOutBreak2 = "PM";
  314.  
  315.             }
  316.             else
  317.             {
  318.                 amPmOutBreak2 = "AM";
  319.             }
  320.         }
  321.  
  322.         private void cboInBreak2AmPm_SelectedIndexChanged(object sender, EventArgs e)
  323.         {
  324.             if (cboInBreak2AmPm.SelectedIndex == 1)
  325.             {
  326.                 amPmInBreak2 = "PM";
  327.  
  328.             }
  329.             else
  330.             {
  331.                 amPmInBreak2 = "AM";
  332.             }
  333.         }
  334.  
  335.         // Menu items
  336.         private void aboutToolStripMenuItem_Click(object sender, EventArgs e)
  337.         {
  338.             Form aboutForm = new AboutBox1();
  339.             aboutForm.ShowDialog();
  340.         }
  341.  
  342.         private void exitToolStripMenuItem_Click(object sender, EventArgs e)
  343.         {
  344.             this.Close();
  345.         }
  346.  
  347.         private void contentsToolStripMenuItem_Click(object sender, EventArgs e)
  348.         {
  349.             Help.ShowHelp(this, this.helpProvider1.HelpNamespace);
  350.         }
  351.     } // end class ConvertTime
  352. }

Here is the code for Vacation time:

PLAIN TEXT
C#:
  1. // **********************************************
  2. // Program Name: What Time Do I Leave Friday
  3. // Program Author: Brian A. Thomas
  4. // Program Homepage: http://www.brianathomas.com/
  5. // Author Homepage: http://www.brianathomas.com/
  6. // **********************************************
  7. // This Namespace: WhatTimeFriday
  8. // **********************************************
  9. // This Class: vacation
  10. // This Class Author: Brian A. Thomas
  11. // This Class Version: 0.4
  12. // This Class Copyright: 2006 by Brian A. Thomas
  13. // **********************************************
  14. /*
  15.      This file is part of What Time Do I Leave Friday.
  17.     What Time Do I Leave Friday is free software; you can redistribute it
  18.     and/or modify it under the terms of the GNU General Public License as
  19.     published by the Free Software Foundation; version 2 of the
  20.     License, or any later version.
  22.     What Time Do I Leave Friday is distributed in the hope that it will be
  23.     useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
  24.     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  25.     GNU General Public License for more details.
  27.     You should have received a copy of the GNU General Public License
  28.     along with What Time Do I Leave Friday; if not, write to the Free Software
  29.     Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  30. */
  31. using System;
  32. using System.Collections.Generic;
  33. using System.ComponentModel;
  34. using System.Data;
  35. using System.Drawing;
  36. using System.Text;
  37. using System.Windows.Forms;
  38.  
  39. namespace WhatTimeFriday
  40. {
  41.     /// <summary>
  42.     /// This window adds unpaid vacation/sick/personal time to the
  43.     /// calculations used by the main window
  44.     /// </summary>
  45.     public partial class vacation : Form
  46.     {
  47.         /// <summary>
  48.         /// This window adds unpaid vacation/sick/personal time to the
  49.         /// calculations used by the main window this is the actual start
  50.         /// of this window
  51.         /// </summary>
  52.         public vacation()
  53.         {
  54.             InitializeComponent();
  55.         }
  56.        
  57.         // set global variables
  58.         private bool ok = true;
  59.         string hoursWorkedWeek = "0:00";
  60.        
  61.         // user clicked add together to get total hours
  62.         private void btnAddTogether_Click(object sender, EventArgs e)
  63.         {
  64.             if (!(Validator.IsPresent(txtDay1Hours) &&
  65.                 Validator.IsPresent(txtDay2Hours) &&
  66.                 Validator.IsPresent(txtDay3Hours) &&
  67.                 Validator.IsPresent(txtDay4Hours) &&
  68.                 Validator.IsPresent(txtDay5Hours) &&
  69.                 Validator.IsPresent(txtDay6Hours) &&
  70.                 Validator.IsTime(txtDay1Hours) &&
  71.                 Validator.IsTime(txtDay2Hours) &&
  72.                 Validator.IsTime(txtDay3Hours) &&
  73.                 Validator.IsTime(txtDay4Hours) &&
  74.                 Validator.IsTime(txtDay5Hours) &&
  75.                 Validator.IsTime(txtDay6Hours)))
  76.             {
  77.                 // not valid, don't let window close
  78.                 ok = false;
  79.             }
  80.             else
  81.             {
  82.                 double day1 = ConvertTime.ToDecimal(txtDay1Hours.Text);
  83.                 double day2 = ConvertTime.ToDecimal(txtDay2Hours.Text);
  84.                 double day3 = ConvertTime.ToDecimal(txtDay3Hours.Text);
  85.                 double day4 = ConvertTime.ToDecimal(txtDay4Hours.Text);
  86.                 double day5 = ConvertTime.ToDecimal(txtDay5Hours.Text);
  87.                 double day6 = ConvertTime.ToDecimal(txtDay6Hours.Text);
  88.                 double totalHours = day1 + day2 + day3 + day4 + day5 + day6;
  89.                 string workedHours = totalHours.ToString("f2");
  90.                 if (workedHours.IndexOf('.') <0)
  91.                 {
  92.                     workedHours += ".00";
  93.                 }
  94.                 hoursWorkedWeek = ConvertTime.StandardTime(workedHours);
  95.                 if (hoursWorkedWeek == "0:00")
  96.                 {
  97.                     MessageBox.Show("All times have a zero value, so there is "
  98.                     + "nothing to add together", "Entry Error");
  99.                     txtDay1Hours.Focus();
  100.                 }
  101.                 else
  102.                 {
  103.                     ok = true;
  104.                     txtTotalHoursWeek.Text = hoursWorkedWeek;
  105.                     btnSend.Enabled = true;
  106.                 }
  107.             }
  108.         }
  109.  
  110.         // user chose to send results back
  111.         private void btnSend_Click(object sender, EventArgs e)
  112.         {
  113.             if (ok)
  114.             {
  115.                 // allow form to close
  116.                 this.Tag = txtTotalHoursWeek.Text;
  117.                 this.DialogResult = DialogResult.OK;
  118.             }
  119.         }
  120.  
  121.         // user chose to cancel entry
  122.         private void btnCancel_Click(object sender, EventArgs e)
  123.         {
  124.             this.Close();
  125.         }
  126.  
  127.         // user chose Exit from the menu
  128.         private void exitToolStripMenuItem_Click(object sender, EventArgs e)
  129.         {
  130.             Form aboutForm = new AboutBox1();
  131.             aboutForm.ShowDialog();
  132.         }
  133.  
  134.         // user chose About from the menu
  135.         private void aboutToolStripMenuItem_Click(object sender, EventArgs e)
  136.         {
  137.             Form aboutForm = new AboutBox1();
  138.             aboutForm.ShowDialog();
  139.         }
  140.  
  141.         // user chose Help from the menu
  142.         private void contentsToolStripMenuItem_Click(object sender, EventArgs e)
  143.         {
  144.             Help.ShowHelp(this, this.helpProvider1.HelpNamespace);
  145.         }
  146.     }
  147. }

Here is the code for the Vailidator class:

PLAIN TEXT
C#:
  1. // **********************************************
  2. // Program Name: What Time Do I Leave Friday
  3. // Program Author: Brian A. Thomas
  4. // Program Homepage: http://www.brianathomas.com/
  5. // Author Homepage: http://www.brianathomas.com/
  6. // **********************************************
  7. // This Namespace: WhatTimeFriday
  8. // NOTE: This will likely change in future versions
  9. // to be in my own library set.
  10. // **********************************************
  11. // Class: MainWindow
  12. // Class Author: Brian A. Thomas
  13. // Class Version: 0.6
  14. // Based off of the Validator Class presented in Murach's C# 2005 book
  15. // by Joel Murach
  16. // Published by: Mike Murach and Associates, Inc.
  17. // ISBN-10: 1-890774-37-5, ISBN-13: 978-1-890774-37-0
  18. // Available at www.murach.com, Amazon.com and other quality book stores
  19. // **********************************************
  20. /*
  21.      This file is part of What Time Do I Leave Friday.
  23.     What Time Do I Leave Friday is free software; you can redistribute it
  24.     and/or modify it under the terms of the GNU General Public License as
  25.     published by the Free Software Foundation; version 2 of the
  26.     License, or any later version.
  28.     What Time Do I Leave Friday is distributed in the hope that it will be
  29.     useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
  30.     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  31.     GNU General Public License for more details.
  33.     You should have received a copy of the GNU General Public License
  34.     along with What Time Do I Leave Friday; if not, write to the Free Software
  35.     Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  36. */
  37. // Portions from Murach's book might fall outside the bounds from the GNU GPL.
  38.  
  39. using System;
  40. using System.Collections.Generic;
  41. using System.Text;
  42. using System.Windows.Forms;
  43.  
  44. namespace WhatTimeFriday
  45. {
  46.     /// <summary>
  47.     /// Validator claass is used to validate that data entered into text boxes
  48.     /// are valid.  Presently covers that the text boxes that are required are
  49.     /// not empty, that it containes a decimal and that it is in a proper
  50.     /// time format.
  51.     /// See comments at top for original source information.
  52.     /// </summary>
  53.     class Validator
  54.     {
  55.         /// <summary>
  56.         /// Determains if a text box has an entry
  57.         /// </summary>
  58.         /// <param name="textBox">The name of the text box's Tag property</param>
  59.         /// <returns>true or false value</returns>
  60.         //  NOTE: This is the part that came from Murach's book and as such
  61.         //  may fall outside the bounds of the GNU GPL.
  62.         public static bool IsPresent(TextBox textBox)
  63.         {
  64.             if (textBox.Text == "")
  65.             {
  66.                 MessageBox.Show(textBox.Tag + " is a requried field.", "Entry Error");
  67.                 textBox.Focus();
  68.                 return false;
  69.             } // end box is empty Message Box
  70.             return true;
  71.         } // end IsPresent
  72.  
  73.         /// <summary>
  74.         /// Makes sure that the entry into the text box is in a valid time
  75.         /// format such as 8:30 or 8.5.
  76.         /// It does NOT insure it is in standard time over military time as
  77.         /// some times entered into boxes will be more then 12, so that part
  78.         /// is handled by the StandardTime method of the ConvertTime class.
  79.         /// This one was not in the book.
  80.         /// </summary>
  81.         /// <param name="textBox">The name of the text box's Tag property</param>
  82.         /// <returns>true or false value</returns>
  83.         public static bool IsTime(TextBox textBox)
  84.         {
  85.             string s = textBox.Text;
  86.             int seperatorCount = 0;
  87.             bool validTime = true;
  88.             foreach (char c in s)
  89.             {
  90.                 if (!(c == '0' || c == '1' || c == '2' || c == '3' || c == '4'
  91.                     || c == '5' || c == '6' || c == '7' || c == '8' || c == '9'
  92.                     || c == ':' || c == '.'))
  93.                 {
  94.                     validTime = false;
  95.                     break;
  96.                 } // end Time isn't valid
  97.                 if (c == ':' || c == '.')
  98.                 {
  99.                     seperatorCount++;
  100.                 } // end if seperator
  101.             } // end foreach
  102.             if (validTime && seperatorCount == 1) // presently doesn't allow
  103.             // for seconds. May be modified at a later date to allow for
  104.             // them by changing it to>0 && <=2 so it forces it to be over
  105.             // over 0 but still under 2.
  106.             {
  107.                 return true;
  108.             } // end if time is valid and seperator count isn't too high
  109.             else
  110.             {
  111.                 MessageBox.Show(textBox.Tag + " must be in a time format. "
  112.                 + "Such as 8:30.\nDo NOT enter seconds or AM/PM.\nAM/PM is"
  113.                 + " selected by using the AM/PM buttons.\nAlso be sure to "
  114.                 + "include the ":" seperator.\n"
  115.                 + "If the time is 0 enter 0:00.", "Entry Error");
  116.                 textBox.Focus();
  117.                 return false;
  118.             } // end time isn't valid message box display
  119.         } // end IsTime
  120.     }// end Validator class
  121. }

Finally, here is the code for the main window itself:

PLAIN TEXT
C#:
  1. // **********************************************
  2. // Program Name: What Time Do I Leave Friday
  3. // Program Author: Brian A. Thomas
  4. // Program Homepage: http://www.brianathomas.com/
  5. // Author Homepage: http://www.brianathomas.com/
  6. // **********************************************
  7. // This Namespace: WhatTimeFriday
  8. // **********************************************
  9. // This Class: MainWindow
  10. // This Class Author: Brian A. Thomas
  11. // This Class Version: 0.8
  12. // This Class Copyright: 2006 by Brian A. Thomas
  13. // **********************************************
  14. /*
  15.      This file is part of What Time Do I Leave Friday.
  17.     What Time Do I Leave Friday is free software; you can redistribute it
  18.     and/or modify it under the terms of the GNU General Public License as
  19.     published by the Free Software Foundation; version 2 of the
  20.     License, or any later version.
  22.     What Time Do I Leave Friday is distributed in the hope that it will be
  23.     useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
  24.     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  25.     GNU General Public License for more details.
  27.     You should have received a copy of the GNU General Public License
  28.     along with What Time Do I Leave Friday; if not, write to the Free Software
  29.     Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  30. */
  31.  
  32. using System;
  33. using System.Collections.Generic;
  34. using System.ComponentModel;
  35. using System.Data;
  36. using System.Drawing;
  37. using System.Text;
  38. using System.Windows.Forms;
  39. //using ystem.Windows.Forms.ToolTip;
  40.  
  41. namespace WhatTimeFriday
  42. {
  43.     /// <summary>
  44.     /// This program will take the hours worked so far in a week, the time
  45.     /// in Friday and lets you know what time to leave Friday
  46.     /// Future versions will allow for less then 40 hours for a standard work
  47.     /// week and allow for lunches on Friday
  48.     /// </summary>
  49.     public partial class MainWindow : Form
  50.     {
  51.         /// <summary>
  52.         /// Created by Visual C# 2005
  53.         /// </summary>
  54.         public MainWindow()
  55.         {
  56.             InitializeComponent();
  57.            
  58.         }
  59.  
  60.         // set global variable
  61.         double standardWorkWeek = 40;
  62.         string lunchTime = "0:00";
  63.         bool standWeekOpen = false;
  64.         double vacationTime = 0;
  65.         // Global variable moved from below so it can be used by a
  66.         // few methods, most noteably so I could display the lunch time
  67.         double lunch;
  68.         bool valid = true;
  69.        
  70.         /// <summary>
  71.         /// This Field controls if the time in is AM or PM
  72.         /// </summary>
  73.         private static bool pm = false;
  74.  
  75.         /// <summary>
  76.         /// PM Property for other classes to access the pm field and set
  77.         /// AM/PM as needed. Most notably at this time the ConvertTime class
  78.         /// uses it if the user uses military time in the Friday in box.
  79.         /// </summary>
  80.         public static bool PM
  81.         {
  82.             get
  83.             {
  84.                 return pm;
  85.             }
  86.             set
  87.             {
  88.                 pm = value;
  89.             }
  90.         }
  91.        
  92.         /// <summary>
  93.         /// User clicked the Calculate button.
  94.         /// If everything is valid, then calculate the time out and hours
  95.         /// for the day.
  96.         /// </summary>
  97.         /// <param name="sender">Standard object sender for event</param>
  98.         /// <param name="e">Standard event handler</param>
  99.         private void btnCalculate_Click(object sender, EventArgs e)
  100.         {
  101.             if (standWeekOpen)
  102.             {
  103.                 // if the user was editing the standard work week
  104.  
  105.                 // first check the text box
  106.                 if (Validator.IsPresent(txtWorkWeek))
  107.                 {
  108.                     if (txtWorkWeek.Text.IndexOf(':') <0
  109.                         && txtWorkWeek.Text.IndexOf('.') <0)
  110.                     {
  111.                         txtWorkWeek.Text += ":00";
  112.                     }
  113.                     else if (txtWorkWeek.Text.IndexOf('.')> -1)
  114.                     {
  115.                         string tempTime =
  116.                             ConvertTime.StandardTime(txtWorkWeek.Text);
  117.                         txtWorkWeek.Text = tempTime;
  118.                     }
  119.                     // check to be sure there are minutes even if they are 0
  120.                     string checkMinutes =
  121.                         ConvertTime.StandardTime(txtWorkWeek.Text);
  122.                     txtWorkWeek.Text = checkMinutes;
  123.                 }
  124.                 // next change standarWorkWeek into a time value
  125.                 string changeStandardWorkWeek = standardWorkWeek.ToString();
  126.                 if (changeStandardWorkWeek.IndexOf('.') <0)
  127.                 {
  128.                     changeStandardWorkWeek += ":00";
  129.                 }
  130.                 else
  131.                 {
  132.                     changeStandardWorkWeek =
  133.                     ConvertTime.StandardTime(changeStandardWorkWeek);
  134.                 }
  135.                
  136.                 // okay one more thing to check before we go on
  137.                 // check to see if the time in the text box is differant
  138.                 // from the standerWorkWeek (changeStandarWorkWeek)
  139.                 if (!(changeStandardWorkWeek == txtWorkWeek.Text))
  140.                 {
  141.                     // the standardWorkWeek and the time in the box are differant
  142.                     DialogResult button = MessageBox.Show("You are still editing "
  143.                     + "the Standard Work Week.\n"
  144.                     + "Press OK to save work week as " + txtWorkWeek.Text + "\n"
  145.                     + "Or press CANCEL to save work week as "
  146.                     + changeStandardWorkWeek, "Work Week Open",
  147.                     MessageBoxButtons.OKCancel);
  148.                     if (button == DialogResult.OK)
  149.                     {
  150.                         btnSaveWorkWeek_Click(sender, e);
  151.                     }
  152.                     else
  153.                     {
  154.                         txtWorkWeek.Text = changeStandardWorkWeek;
  155.                         btnSaveWorkWeek_Click(sender, e);
  156.                     }
  157.                 }
  158.                 else
  159.                 {
  160.                     // they were equal hit the save button so we are sure
  161.                     // to hit the time in. This also makes sure the save
  162.                     // button goes away and the text box becomes read only
  163.                     btnSaveWorkWeek_Click(sender, e);
  164.                 }
  165.  
  166.                
  167.             }
  168.  
  169.             // Check to see if they entered decimal time in a box
  170.             string totalTime = txtTotalHours.Text;
  171.             string inTime = txtTimeInFriday.Text;
  172.             if (totalTime.IndexOf('.')>= 0)
  173.             {
  174.                 DialogResult button = MessageBox.Show("You entered a decimal "
  175.                     + "value into the Total Hours text box.\nIt normally "
  176.                     + "expects a standard time with a colon seperating\nhours "
  177.                     + "from minutes.\nIf you are sure you want to use the "
  178.                     + "decimal entry click OK\notherwise click Cancel to return"
  179.                     + "and edit your entry.","Notice",
  180.                 MessageBoxButtons.OKCancel, MessageBoxIcon.Warning);
  181.                 if (button == DialogResult.OK)
  182.                 {
  183.                     valid = true;
  184.                 }
  185.                 else
  186.                 {
  187.                     valid = false;
  188.                     txtTotalHours.Focus();
  189.                     txtTimeToLeave.Text = "";
  190.                     txtHourForFriday.Text = "";
  191.                 }
  192.             }
  193.             if (inTime.IndexOf('.')>= 0)
  194.             {
  195.                 DialogResult button = MessageBox.Show("You entered a decimal "
  196.                     + "value into the Time in Friday text box.\nIt normally "
  197.                     + "expects a standard time with a colon seperating\nhours "
  198.                     + "from minutes.\nIf you are sure you want to use the "
  199.                     + "decimal entry click OK\notherwise click Cancel to return"
  200.                     + "and edit your entry.", "Notice",
  201.                 MessageBoxButtons.OKCancel, MessageBoxIcon.Warning);
  202.                 if (button == DialogResult.OK)
  203.                 {
  204.                     valid = true;
  205.                 }
  206.                 else
  207.                 {
  208.                     valid = false;
  209.                     txtTimeInFriday.Focus();
  210.                     txtTimeToLeave.Text = "";
  211.                     txtHourForFriday.Text = "";
  212.                 }