gdi+

The LinearGradientBrush in .net (or even in GDI+ as a whole?) seems to have a severe bug: Sometimes, it introduces artifacts. (See here or here - essentially, the first line of a linear gradient is drawn in the endcolor, i.e. a gradient from White to Black will start with a Black line and then with the proper White to Black gradient) I wonder if anyone found a working workaround for this? This is a really annoying bug :-( Here is a picture of the Artifacts, note that there are 2 LinearGradientBrushes: alt text http://img142.imageshack.us/img142/7711/gradientartifactmm6.jpg I have noticed this

I am wracking my brains in trying to understand the discrepancy between the font sizes users select or specify (for example, using a FontDialog ) and the em-size reported by the Font class in .NET. For example: using (FontDialog dlg = new FontDialog()) { if (dlg.ShowDialog() == DialogResult.OK) { Console.WriteLine("Selected font size: " + dlg.Font.SizeInPoints.ToString("0.##")); } } Using the above code, you will get some confusing results: Selecting 11 in the dialog produces 11.25 Selecting 12 in the dialog produces 12 Selecting 14 in the dialog produces 14.25 Selecting 16 in the dialog

I need a fast way to draw an overlay on a screen with transparency support. I've done a lot of searching and found one potential solution (which has its own problems) and another solution that does not fit my requirements; specifically transparency support. I'll start with the latter and then touch on the former. Solution 1 Using a borderless form with a TransparencyKey, this is one of the most recommended solutions I've found and the least helpful. This solution works by having a new Form, have it borderless, set the background to something like Colour.White and set the TransparencyKey to the

Many GDI+ classes implement IDisposable, but I'm not sure when I should call Dispose. It's clear for instances I create with new or static methods like Graphics.CreateGraphics . But what about objects that are returned by property getters? I often write code like this: var oldRgn = g.Clip; using (var rectRegion = new Region(rectangle)) { g.Clip = rectRegion; // draw something } g.Clip = oldRgn; Am I supposed to dispose oldRgn after that? My memory profiler tells me there are undisposed instances if I don't. And looking at the implementation in reflector at least confirms that the getter

I'm trying to create a non-rectangular window with semi-transparent pixels. The image does not come from a PNG but is drawn on-the-fly using GDI+ calls. I create the window as follows: WNDCLASSEX wc = WNDCLASSEX(); wc.cbSize = sizeof(wc); HINSTANCE instance = GetModuleHandle(nullptr); std::wstring classname(L"gditest ui window class"); if (!GetClassInfoEx(instance, classname.c_str(), &wc)) { //wc.cbSize; //wc.style = CS_DROPSHADOW; wc.lpfnWndProc = process_messages; //wc.cbClsExtra; //wc.cbWndExtra; wc.hInstance = instance; wc.hIcon; wc.hCursor = LoadCursor(0, IDC_ARROW); //wc.hbrBackground; /

I have an application that does a lot of drawing, let's pretend it's a Viso-like application. It has objects that have multiple sub-objects that are drawn, things can be connected, resized etc. Currently when I call paint on a particular sub-object or object, I do the following: using(var pen = new Pen(this.ForeColor)) { // Paint for this object. } I've read conflicting answers that this should be done for an application that is constantly drawing the same thing (maybe just resized, moved etc). Should I store the Pen/Brush with the object and then dispose them all when the application is