Neither. DBNull is a singleton class, the sole instance of which is returned by DBNull.Value. The code generated by the is and == operators is exactly the same. RageInTheMachine9532 "...a pungent, ghastly, stinky piece of cheese!" -- The Roaming Gnome

One option would be to save the checkbox states into a Session variable. It is probably not the best way, but it would result in a solution to the problem. for example: Session("CheckBox1") = CheckBox1.Checked Then, when you reload your page, in Page_Load: if Page.IsPostBack then CheckBox1.Checked = Session("CheckBox1") end if Jon G www.Gizmocoder.com

You can always use a regular expression or custom validator to do that validation. I suspect there is some kind of regional setting to make that validation work, but it is probably safer to do it yourself. I can imagine the sinking feeling one would have after ordering my book, only to find a laughably ridiculous theory with demented logic once the book arrives - Mark McCutcheon

Hey, thank a lot Andy. Works flawlessly now. Perfect, thanks again.

iframes are inline elements so u cant "redraw" them after the page has drawn ... they are drawn inline period afaik thats why iframes can be tricky to work with "there is no spoon" biz stuff about me

The XML document that contains the comments must be in the same directory as the assembly you're referencing. Microsoft MVP, Visual C# My Articles

Doing a SELECT TOP N ... without a WHERE and ORDER BY clause is kind of trivial, and you shouldn't rely on an id or auto-increment field in an ORDER BY, as it is no guarantee of the chonological order in which records are added to a table. You should work with other fields, such as datetime fields, foreign key fields, etc. Another question: Are you referring to paging through a DataSet using ASP.NET? If so, there are plenty of examples and articles out there on data paging and controls like the DataGrid control.

I only mention multiple inheritance because having syntax to specify exactly whose version of a function you're calling is something that you HAVE to have once your language implements multiple inheritance. There's many an interview question on C++ based upon this type of crap ;). If you only have single inheritance, you can call your parent's implementation with a keyword like "base". One thing to realize is it doesn't matter if the methods return different types at all. Two functions can't have the same name and take the same parameters unless we can use a specific "vtable" to call each one. That said, think about this: namespace Test { public interface I { void MethodA(); } public class C : I { void Test.I.MethodA() { // I's version } public void MethodA() { // C's version } } } Given this code, instantiate an instance of C and call the I interface version of MethodA without first casting C to an I. AFAIK, it can't be done. So the mechanism we use to differentiate between which version we're calling is a cast to the specific class. Casting allows us to specify whose "vtable" (a table that points to functions) we want to use. Now in the case of a derived class, you can't do something like: DerivedClass d = new DerivedClass(); ((DerivedClass)d).MethodA(); because casting something that's already a given class doesn't really do anything. Casting something to a base class or an interface gives you the "vtable" of that class, which allows us to "specify" a particular method. The problem comes into the fact that the base class's vtable might have a pointer to the derived class in the case the method gets overridden. This is what happens to virtual functions that are redefined with an override. Abstract methods are automatically virtual, they just have no "default" implementation. You are required to supply one in the case of abstract methods. If we can't use casting to "filter" our vtable and specify which method we're calling, we would need some other method of specifying. C++ ends up using the "::" operator to do this. If you want to call a specific parent class version, you just call it with something like: ParentClass::MethodA() It becomes a real mess... :) Does any of this help at all? I'm probably not doing this discussion justice. Have you done any C++ in the past? I, for one, do not think the problem was that the band was down. I think that the problem may have been that there was a Stonehenge monu

I tried to see if I could reproduce your problem -- to no avail. I created the following code for an ASP.NET Web Form using VB.NET: Private Sub Page\_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Load 'Put user code to initialize the page here TextBox2.Text = "Page Loaded" End Sub Private Sub CheckBox1\_CheckedChanged(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles CheckBox1.CheckedChanged TextBox1.Text = "CheckBox1 Changed" End Sub No matter what properties I set on CheckBox1, when I click the "submit" button on the page, if I have changed the value of CheckBox1, the value of TextBox1 changes. Perhaps you somehow broke the binding of the CheckChanged event to the CheckBox1_CheckChanged method?

Wow, thanks alot Heath. You have always been the one to asnwer all my questions, and your always right :) Well, thanks again.

Ok, thanks very much for the help. That should help alot. :)

No, there is currently nothing in the .NET base class library that deals with NTFS permissions. There may be some third-party libraries out there and I'm sure "Longhorn" will introduce such encapsulation, but you either have to use the NTFS APIs or try to write a zero-byte file to the directory and catch any exceptions that are thrown. For more discussion about alternatives, please click the "Search Comments" link above. We have covered this in the past. There are also a few articles here on the CP web site. Use the search text box toward the top of the page (below the logo). -----BEGIN GEEK CODE BLOCK----- Version: 3.21 GCS/G/MU d- s: a- C++++ UL@ P++(+++) L+(--) E--- W+++ N++ o+ K? w++++ O- M(+) V? PS-- PE Y++ PGP++ t++@ 5 X+++ R+@ tv+ b(-)>b++ DI++++ D+ G e++>+++ h---* r+++ y+++ -----END GEEK CODE BLOCK-----

The coordinate system As we all know, drawing systems in .Net are based upon pixels that are arranged on a two-dimensional coordinate system. The origin, that is, the points (0, 0) lie on the far top-left of the screen. Each consecutive pixel towards the right of the origin forms the x-axis, and each consecutive pixels towards the bottom of the screen forms the y-axis. If you note carefully, the co-ordinate system for onscreen graphics is an inverted copy of the Cartesian Co-ordinate System used in Mathematical Geometry. Now, when we give the call to the system to draw a rectangle, we provide it with four arguments. The x-coordinate, the y-coordinate, width and the height of the rectangle. We will traverse through each step that the system undergoes to create a rectangle. Step 1: First, the point (x, y) or the pixel present on the point (x, y) is plotted or marked on the coordinate system as shown below. Step 2: Then, it adds the width provided as argument to the next consecutive x-coordinate. For instance, if the x-coordinate is 0 and the width is 10, then the resultant point on the x-axis (fx) will be: Because x-coordinate specified was 0, So the next x-coordinate will be 1 Final Point = next x-coordinate + width Final Point = 1 + 10 Final Point = 11; Same goes for the y-coordinate and the height to calculate the resultant point on the y-axis (fy). Step 3: System marks all the pixels from (0, 0) to the point (fx, 0) on the x-axis and also marks all the pixels from (0, 0) to (0, fy). This gives two straight lines joined at (0, 0) at an angle of 90 degrees. The points (fx, 0) and (0, fy) are then interconnected at the point (fx, fy). Thus giving the illusion of a perfect rectangle. What happens with GDI+ drawing routines If you keep the x-coordinate and the y-coordinate as (0, 0), then it is seen that: Resultant Point fx = width + 1 and Resultant Point fy = height + 1 So, if we specify the below mentioned statements in GDI+: g.DrawRectangle(new SolidBrush(Color.Blue), 0, 0, this.Width, this.Height); g.DrawRectangle(new SolidBrush(Color.Blue), new Rectangle(0, 0, this.Width, this.Height)); From these statements, it is clear that the resultant point to which the rectangle will be stretched is (this.Width+1, this.Height+1) which unfortunately exceeds the visible region of the Component or Custom Control. Did not understand a single word? Ask for a detailed and illustrated

Awesome, thanks alot Jeff, that is exaclty what I needed, i guess I can just call it in a seperate thread every minute or so. Thanks again :) The GetLastInputInfo function retrieves the time of the last input event. Syntax: BOOL GetLastInputInfo( PLASTINPUTINFO plii ); Parameters: plii - [out] - Pointer to a LASTINPUTINFO structure that receives the time of the last input event. Return Value: If the function succeeds, the return value is nonzero. If the function fails, the return value is zero. Remarks: This is useful for input idle detection. Function Information: Header Declared in Winuser.h, include Windows.h Import library User32.lib Minimum operating systems Windows 2000 See Also: Keyboard Input, LASTINPUTINFO