W3bbo said:

ploe said:

*snip*

Can you post your code?

I'm an idiot. I couldn't find the bug because it wasn't in the window's code, but our base class that it extends. The other windows where the title update does work inherits a different base class.

In our base class we disabled painting while the window was in a state of populating data (because we were getting flicker) with this line:

SendMessage(this.Handle, WM_SETREDRAW, 0, IntPtr.Zero);

We re-enabled painting when it is done populating with this line:

SendMessage(this.Handle, WM_SETREDRAW, 1, IntPtr.Zero);

Then we call Invalidate(true). But that just invalidates the client area, not the non-client area, hence why the title bar was not re-painting.

Solution:

Invalidate and paint the ENTIRE window by calling: InvalidateRect() and then UpdateWindow().

Sorry for the wild goose chase.

W3bbo said:

• Is the .Text property being set on the same thread that instantiated the form?
• Set a breakpoint to make sure it's been hit
• Make a copy of your form's code and reduce it down until you get the smallest amount of code that reproduces the problem, then compare it to a working sample.

I can't seem to find a different between the windows.

I have a method called UpdateTitle() that actually updates the Form's Text. InvokeRequired always returns false, so it's definately not in the wrong Thread. Nothing related to this window is multi-threaded so this was not surprising.

When I put in a breakpoint, the title does update. I suspect that's because Visual Studio takes focus and when I go back to the window, it triggers a re-paint of the non-client area. The title change also shows up if I minimize, then maximize the window.

I have about 100 or so Forms and this is the only Form that does this. I've compared properties with a window that does work and can't see anything odd that I'm doing in the broken Form. Has anyone run accross this or have an idea of things I can check?

Dexter said:

ploe said:

*snip*

 

Yes, it can. But try -78.884687963873147 instead. Or -78.884687963873143

 

The last digit is kind of bogus.

You're right! Those other values don't work. The '8' is bogus and it appears as though the '4' is also non-existent. Do you think it's just an odd behavior of the debugger?

Dexter said:

ploe said:

*snip*

Wait a moment, where did that value come from anyway?

 

It has 17 significant digits and that's more than double can represent. Is that a constant in your code? In that case you need to make it a decimal in the first place. Like:

 

const decimal x = -78.884687963873148m;

 

Note the m suffix. That tells the compiler it is a decimal literal. Otherwise double is implied.

 

 

It's definately a double, I got the value from the assembly as a double with that value in it. I've just been using a constant in my posts so that it's more understandable.

If you put that value in your watch of VS it does say the type is a double.

It's all a little confusing. If you run this bit of code you see that a double can store this value:

double d = -78.884687963873148;

Console.WriteLine(d.ToString("R"));

W3bbo said:

ploe said:

*snip*

I think that's because Decimal's ToString() method by default truncates the results.

 

Try working with Decimals throughout your program though.

Unfortunately the double comes from an external assembly.

(-78.884687963873148M).ToString() is not truncated though, so I feel like I'm losing data in the typecast.

The only thing that seems to convert it correctly is if I do this:
decimal d = Decimal.Parse((-78.884687963873148).ToString("R"));

...not exactly efficient.

W3bbo said:

phreaks said:

*snip*

http://sine.codeplex.com <-- My arbitrary-prescision library for .NET; note that I did some major refactoring in the latest revision and my code is unstable, unusable, gives inaccurate (if not just plain wrong) results, and is otherwise unfit for purpose. Use with caution. The earlier revisions (and the available download release) still work fine.

 

http://intx.codeplex.com <-- An integer-only library for .NET far, far superior to my own... but only does integers. The IntX class in this library is superior to the BigInteger class in .NET4.0 in most circumstances, so it's worth checking out.

 

EDIT: I see that F# comes with its own BigRational class. Note that it's a rational number (that is, any number representable by an integer numerator and denominator) so whilst it will always give you 'purer' results than a floating/decimal library like mine it won't necessarily be faster.

Okay I seem to have grasped a better understanding of the problem I'm running into:

The initial type I have is a double with the value -78.884687963873148. I typecast it to a decimal because I need slightly more precision on it based on the math I'm going to do. But typecasting the double -78.884687963873148 to a decimal, I actually lose precision.

(decimal)-78.884687963873148 = -78.8846879638731

:/

In our assembly, we have our own implementation of what the built in MessageBox class. It's called PopupBox. I'd like to discourage the use of MessageBox in our application. I thought a good way would be to make MessageBox deprecated so that it threw a compiler warning.

If this isn't possible, can you suggest an alternative?

cdwatkins said:

Your talking about a contra/co- variance problem.  The problem is that IList<Bob> isnt assignable to IList<Person> even though Bob is a type of person.  They fixed this problem in .NET 4.

Probably not the solution you are looking for, but you could do this:

Have only one Customer class and make your 'special' members internal so only you can use them. If it's in a different assembly from where you need it you can use this to gain access to the internal members: http://msdn.microsoft.com/en-us/library/0tke9fxk.aspx

ploe said:

ScanIAm said:

*snip*

Thanks. I knew it was going to be something little. I appended the equivalent of '\r\n' to the command I was sending at it wrote back the command I sent plus the response.

 

Edit: It was a GPRS/GSM device.

So people don't have to re-invent the wheel, this was the wrapper I ended up writing...may be of use to someone.

EDIT: code formatter doesn't work too well :/

    /// <summary>
    /// Class that allows for serial communication in Windows.
    /// </summary>
    public class SerialCom : IDisposable
    {
        #region Fields
 
        /// <summary>
        /// The baud rate at which the communications device operates.
        /// </summary>
        private readonly int baudRate;
 
        /// <summary>
        /// The number of bits in the bytes to be transmitted and received.
        /// </summary>
        private readonly byte byteSize;
 
        /// <summary>
        /// The system handle to the serial port connection ('file' handle).
        /// </summary>
        private IntPtr handle = IntPtr.Zero;
 
        /// <summary>
        /// The parity scheme to be used.
        /// </summary>
        private readonly Parity parity;
 
        /// <summary>
        /// The name of the serial port to connect to.
        /// </summary>
        private readonly string portName;
 
        /// <summary>
        /// The number of bits in the bytes to be transmitted and received.
        /// </summary>
        private readonly StopBits stopBits;
 
        #endregion
 
        /// <summary>
        /// Creates a new instance of SerialCom.
        /// </summary>
        /// <param>The name of the serial port to connect to</param>
        /// <param>The baud rate at which the communications device operates</param>
        /// <param>The number of stop bits to be used</param>
        /// <param>The parity scheme to be used</param>
        /// <param>The number of bits in the bytes to be transmitted and received</param>
        public SerialCom(string portName, int baudRate, StopBits stopBits, Parity parity, byte byteSize)
        {
            if (stopBits == StopBits.None)
                throw new ArgumentException("stopBits cannot be StopBits.None", "stopBits");
            if (byteSize < 5 || byteSize > 8)
                throw new ArgumentOutOfRangeException("The number of data bits must be 5 to 8 bits.", "byteSize");
            if (baudRate < 110 || baudRate > 256000)
                throw new ArgumentOutOfRangeException("Invalid baud rate specified.", "baudRate");
            if ((byteSize == 5 && stopBits == StopBits.Two) || (stopBits == StopBits.OnePointFive && byteSize > 5))
                throw new ArgumentException("The use of 5 data bits with 2 stop bits is an invalid combination, " +
                    "as is 6, 7, or 8 data bits with 1.5 stop bits.");
 
            this.portName = portName;
            this.baudRate = baudRate;
            this.byteSize = byteSize;
            this.stopBits = stopBits;
            this.parity = parity;
        }
 
        /// <summary>
        /// Creates a new instance of SerialCom.
        /// </summary>
        /// <param>The name of the serial port to connect to</param>
        /// <param>The baud rate at which the communications device operates</param>
        /// <param>The number of stop bits to be used</param>
        /// <param>The parity scheme to be used</param>
        public SerialCom(string portName, int baudRate, StopBits stopBits, Parity parity)
            : this(portName, baudRate, stopBits, parity, 8) { }
 
        /// <summary>
        /// Disconnects and disposes of the SerialCom instance.
        /// </summary>
        public void Dispose()
        {
            if (handle != IntPtr.Zero)
            {
                CloseHandle(handle);
                handle = IntPtr.Zero;
            }
        }
 
        /// <summary>
        /// Flushes the serial I/O buffers.
        /// </summary>
        /// <returns>Whether or not the operation succeeded</returns>
        public bool Flush()
        {
            FailIfNotConnected();
 
            const int PURGE_RXCLEAR = 0x0008; // input buffer
            const int PURGE_TXCLEAR = 0x0004; // output buffer
            return PurgeComm(handle, PURGE_RXCLEAR | PURGE_TXCLEAR);
        }
 
        /// <summary>
        /// Opens and initializes the serial connection.
        /// </summary>
        /// <returns>Whether or not the operation succeeded</returns>
        public bool Open()
        {
            handle = CreateFile(this.portName, FileAccess.ReadWrite, FileShare.None,
                IntPtr.Zero, FileMode.Open, 0, IntPtr.Zero);
            if (handle == IntPtr.Zero) return false;
 
            if (ConfigureSerialPort()) return true;
            else
            {
                Dispose();
                return false;
            }
        }
 
        /// <summary>
        /// Reads any bytes that have been received and writes them to the specified array.
        /// </summary>
        /// <param>The array to write the read data to</param>
        /// <returns>The number of bytes read (-1 if error)</returns>
        public int Read(byte[] data)
        {
            FailIfNotConnected();
            if (data == null) return 0;
 
            int bytesRead;
            if (ReadFile(handle, data, data.Length, out bytesRead, 0))
                return bytesRead;
            return -1;
        }
 
        /// <summary>
        /// Reads any data that has been received as a string.
        /// </summary>
        /// <param>The maximum number of bytes to read</param>
        /// <returns>The data received (null if no data)</returns>
        public string ReadString(int maxBytesToRead)
        {
            if (maxBytesToRead < 1) throw new ArgumentOutOfRangeException("maxBytesToRead");
 
            byte[] bytes = new byte[maxBytesToRead];
            int numBytes = Read(bytes);
            string data = ASCIIEncoding.ASCII.GetString(bytes, 0, numBytes);
            return data;
        }
 
        /// <summary>
        /// Transmits the specified array of bytes.
        /// </summary>
        /// <param>The bytes to write</param>
        /// <returns>The number of bytes written (-1 if error)</returns>
        public int Write(byte[] data)
        {
            FailIfNotConnected();
            if (data == null) return 0;
 
            int bytesWritten;
            if (WriteFile(handle, data, data.Length, out bytesWritten, 0))
                return bytesWritten;
            return -1;
        }
 
        /// <summary>
        /// Transmits the specified string.
        /// </summary>
        /// <param>The string to write</param>
        /// <returns>The number of bytes written (-1 if error)</returns>
        public int Write(string data)
        {
            FailIfNotConnected();
 
            // convert the string to bytes
            byte[] bytes;
            if (data == null) bytes = null;
            else bytes = ASCIIEncoding.ASCII.GetBytes(data);
            return Write(bytes);
        }
 
        /// <summary>
        /// Transmits the specified string and appends the carriage return to the end
        /// if it does not exist.
        /// </summary>
        /// <remarks>
        /// Note that the string must end in '\r\n' before any serial device will interpret the data
        /// sent. For ease of programmability, this method should be used instead of Write() when you
        /// want to automatically execute the specified command string.
        /// </remarks>
        /// <param>The string to write</param>
        /// <returns>The number of bytes written (-1 if error)</returns>
        public int WriteLine(string data)
        {
            if (data != null && !data.EndsWith("\r\n"))
                data += "\r\n";
            return Write(data);
        }
 
        #region Private Helpers
 
        /// <summary>
        /// Configures the serial device based on the connection parameters pased in by the user.
        /// </summary>
        /// <returns>Whether or not the operation succeeded</returns>
        private bool ConfigureSerialPort()
        {
            DCB serialConfig = new DCB();
            if (GetCommState(handle, ref serialConfig))
            {
                // setup the DCB struct with the serial settings we need
                serialConfig.BaudRate = (uint)this.baudRate;
                serialConfig.ByteSize = this.byteSize;
                serialConfig.fBinary = 1; // must be true
                serialConfig.fDtrControl = 1; // DTR_CONTROL_ENABLE "Enables the DTR line when the device is opened and leaves it on."
                serialConfig.fAbortOnError = 0; // false
                serialConfig.fTXContinueOnXoff = 0; // false
 
                serialConfig.fParity = 1; // true so that the Parity member is looked at
                switch (this.parity)
                {
                    case Parity.Even:
                        serialConfig.Parity = 2;
                        break;
                    case Parity.Mark:
                        serialConfig.Parity = 3;
                        break;
                    case Parity.Odd:
                        serialConfig.Parity = 1;
                        break;
                    case Parity.Space:
                        serialConfig.Parity = 4;
                        break;
                    case Parity.None:
                    default:
                        serialConfig.Parity = 0;
                        break;
                }
                switch (this.stopBits)
                {
                    case StopBits.One:
                        serialConfig.StopBits = 0;
                        break;
                    case StopBits.OnePointFive:
                        serialConfig.StopBits = 1;
                        break;
                    case StopBits.Two:
                        serialConfig.StopBits = 2;
                        break;
                    case StopBits.None:
                    default:
                        throw new ArgumentException("stopBits cannot be StopBits.None");
                }
 
                if (SetCommState(handle, ref serialConfig))
                {
                    // set the serial connection timeouts
                    COMMTIMEOUTS timeouts = new COMMTIMEOUTS();
                    timeouts.ReadIntervalTimeout = 1;
                    timeouts.ReadTotalTimeoutMultiplier = 0;
                    timeouts.ReadTotalTimeoutConstant = 0;
                    timeouts.WriteTotalTimeoutMultiplier = 0;
                    timeouts.WriteTotalTimeoutConstant = 0;
                    if (SetCommTimeouts(handle, ref timeouts))
                        return true;
                    else return false;
                }
                else return false;
            }
            else return false;
        }
 
        /// <summary>
        /// Helper that throws a InvalidOperationException if we don't have a serial connection.
        /// </summary>
        private void FailIfNotConnected()
        {
            if (handle == IntPtr.Zero)
                throw new InvalidOperationException("You must be connected to the serial port before performing this operation.");
        }
 
        #endregion
 
        #region Native Helpers
 
        // Used to get a handle to the serial port so that we can read/write to it.
        [DllImport("kernel32.dll", SetLastError = true, CharSet = CharSet.Auto)]
        static extern IntPtr CreateFile(string fileName,
           [MarshalAs(UnmanagedType.U4)] FileAccess fileAccess,
           [MarshalAs(UnmanagedType.U4)] FileShare fileShare,
           IntPtr securityAttributes,
           [MarshalAs(UnmanagedType.U4)] FileMode creationDisposition,
           int flags,
           IntPtr template);
 
        // Used to close the handle to the serial port.
        [DllImport("kernel32.dll", SetLastError = true)]
        static extern bool CloseHandle(IntPtr hObject);
 
        /// <summary>
        /// Defines the control setting for a serial communications device.
        /// </summary>
        [StructLayout(LayoutKind.Sequential)]
        struct DCB
        {
            public int DCBlength;
            public uint BaudRate;
            public uint Flags;
            public ushort wReserved;
            public ushort XonLim;
            public ushort XoffLim;
            public byte ByteSize;
            public byte Parity;
            public byte StopBits;
            public sbyte XonChar;
            public sbyte XoffChar;
            public sbyte ErrorChar;
            public sbyte EofChar;
            public sbyte EvtChar;
            public ushort wReserved1;
            public uint fBinary;
            public uint fParity;
            public uint fOutxCtsFlow;
            public uint fOutxDsrFlow;
            public uint fDtrControl;
            public uint fDsrSensitivity;
            public uint fTXContinueOnXoff;
            public uint fOutX;
            public uint fInX;
            public uint fErrorChar;
            public uint fNull;
            public uint fRtsControl;
            public uint fAbortOnError;
        }
 
        // Used to get the state of the serial port so that we can configure it.
        [DllImport("kernel32.dll")]
        static extern bool GetCommState(IntPtr hFile, ref DCB lpDCB);
 
        // Used to configure the serial port.
        [DllImport("kernel32.dll")]
        static extern bool SetCommState(IntPtr hFile, [In] ref DCB lpDCB);
 
        /// <summary>
        /// Contains the time-out parameters for a communications device.
        /// </summary>
        [StructLayout(LayoutKind.Sequential)]
        struct COMMTIMEOUTS
        {
            public uint ReadIntervalTimeout;
            public uint ReadTotalTimeoutMultiplier;
            public uint ReadTotalTimeoutConstant;
            public uint WriteTotalTimeoutMultiplier;
            public uint WriteTotalTimeoutConstant;
        }
 
        // Used to set the connection timeouts on our serial connection.
        [DllImport("kernel32.dll", SetLastError = true)]
        static extern bool SetCommTimeouts(IntPtr hFile, ref COMMTIMEOUTS lpCommTimeouts);
 
        // Used to read bytes from the serial connection.
        [DllImport("kernel32.dll")]
        static extern bool ReadFile(IntPtr hFile, byte[] lpBuffer,
           int nNumberOfBytesToRead, out int lpNumberOfBytesRead, int lpOverlapped);
 
        // Used to write bytes to the serial connection.
        [DllImport("kernel32.dll", SetLastError = true)]
        static extern bool WriteFile(IntPtr hFile, byte[] lpBuffer,
            int nNumberOfBytesToWrite, out int lpNumberOfBytesWritten, int lpOverlapped);
 
        // Used to flush the I/O buffers.
        [DllImport("kernel32.dll", SetLastError = true)]
        static extern bool PurgeComm(IntPtr hFile, int dwFlags);
 
        #endregion
    }

ScanIAm said:

ManipUni said:

*snip*

~7 years modem support in the early 90s

Thanks. I knew it was going to be something little. I appended the equivalent of '\r\n' to the command I was sending at it wrote back the command I sent plus the response.

Edit: It was a GPRS/GSM device.

Anyway, I feel like I'm missing some fundamental understanding of how serial communication works. When I send a command using WriteFile(), ReadFile() returns the exact command I sent instead of the response to my command. If I send "AT", for example, my read returns "AT". I feel like I'm not truly reading the devices response, but just what I wrote.

So I thought I'd give the .Net SerialPort class a trying. I found this sample (http://msdn.microsoft.com/en-us/library/y2sxhat8.aspx), but when I run this it too just returns exactly what I sent instead of the device's response.

I know the device works because I can connect with it via Putty and I get the responses I expect. Can anyone point me in the right direction?

Maddus Mattus said:

So if I understand correctly, you only want rows included that have a ten minute intersect?

 

And if no rows are found you want a default selection?

 

Then I would suggest you develop a cursor to fill a temp table and if the table has 0 rows, fire off another query,..

Then select the temp table as a resultset,..

Yes, if a row overlaps a specified datetime, not only return that row, but all the rows that are in the 10-minute adjacent set this row belongs to.

Let's say you have a table called WINDOW that has a START date, an END date and a unique ID.

I want to select all the rows that are within 10 minutes of each other and at least one of the rows falls within a given datetime (which I pass in my query).

Here's a sample dataset:

ID, START, END

1,  9/21/09 00:00:00,  9/21/09 00:30:00

2,  9/21/09 00:38:00,  9/21/09 02:00:00

3,  9/21/09 02:05:00,  9/21/09 04:00:00

4,  9/21/09 04:15:00,  9/21/09 04:30:00

5,  9/21/09 04:35:00,  9/21/09 07:30:00

Rows 1 -> 2 -> 3 are a set because 2's START is only 8 minutes greater than 1's END and 3's START is only 5 greater than 2's END. Following that rule, 4 and 5 are a set as well.

Passing in the datetime 9/21/09 02:00:00 should return rows 1, 2, and 3 because that time falls within the min and max time those 3 rows cover. If I were to pass in 9/21/09 04:20:00, I would expect rows 4 and 5 to be returned.

I started with this query, but that's only going to return rows 2 and 3 (the immediately adjacent rows), not N rows.

SELECT * FROM WINDOW WHERE ABS(DATEDIFF(mi, END, '9/21/09 02:00:00')) <= 10 OR ABS(DATEDIFF(mi, START, '9/21/09 02:00:00')) <= 10

And I tried another approach, but this will return rows 4 and 5 too when I only want 1, 2, and 3

SELECT * FROM WINDOW w WHERE EXISTS(SELECT TOP 1 ID FROM WINDOW w2 WHERE w2.ID != w.ID AND ABS(DATEDIFF(mi, w2.END, w.START)) <= 10 OR ABS(DATEDIFF(mi, w2.START, w.END)) <= 10)

Grr

protected override CreateParams CreateParams
{
    get
    {
        CreateParams createParams = base.CreateParams;
        if (PaintMode == PanelPaintMode.Transparent)
            createParams.ExStyle |= 0x00000020; // WS_EX_TRANSPARENT
        return createParams;
    }
}

Has anyone successfully been able to get this working correctly? Or is there some other way I can do this?

It seems like a managed MdiClient is not aware of the native child windows that I've added...

TommyCarlier said:

Console applications are not meant to be closed by the user. They don't have a message loop and should shut down when their task has been performed.

This console app performs calculations that are particularly expensive. So I cache them in a hash_map. What I am doing is writing the hash_map to disk so that I can repopulate the cache when the app starts up again. I do also save the cache to disk once in a while just in case the app were to crash.

I guess what I could do is increase the frequency to which I save the cache while the app is running, but I will lose any calculations between when I last saved and when I close the app.

Custa1200 wrote:

We use SVN via TortoiseSVN and ankhSVN inside of VS2003/2005. Works a treat.

Ditto.

/// <summary>Some comment</summary>
public ref class Class1 {
public:
/// <summary>Creates a new instance of Class1</summary>
Class1(void) {}
/// <summary>Does something</summary>
/// <returns>Some integer</returns>
int DoSomething() { return 0; }
};

None of the documentation above shows up when using Class1 in a C# project.