Hallo Endro.

Ich hab nach kurzem Googeln folgendes Buch gefunden:
GUI-Design von Ivo Wessel

Kenne es selbst nicht, aber die Beschreibung auf Amazon hört sich in etwa nach dem an, was du suchst.

[...] Ivo Wessel will mit seinem Buch der Willkür in der Applikationsgestaltung entgegenwirken. Richtlinien und Standards werden vermittelt. Diese sollen es ambitionierten Programmierern ermöglichen, den Gestaltungserwartungen eines Windows-Kenners zu entsprechen. [...]

Als allgemeine Einführung wie Vista-Icons funktionieren fand ich den Beitrag Introducing Windows Vista™ Icons auf Axialis ganz hilfreich.

Und als kostenlose Alternative zum dort angebotenen "Axialis IconWorkshop"-Tool emfpehle ich immer @icon sushi. Verwende das auch immer selbst. Sehr simples Programm, das nicht mit irgendwelchen Design-Funktionen daherkommt sondern mir ganz einfach erlaubt, aus meinen in Photoshop designten Icons (als PNG mit Alphakanal gespeichert) Windows-Icons zu erstellen. @icon sushi unterstützt auch die PNG-Kompression von Vista-Icons.

Ich weiß, dass der Thread schon über drei Monate als ist, aber da ich mich eben mit dem gleichen Problem konfrontiert sah, erscheint es mir angebracht, das ganze noch mal hochzubringen.

Das Problem an der Sache mit dem zweimal ausgelöstem Ereignis ist ja nur dann relevant, wenn man den Zustand, dass kein Eintrag in der ListView ausgewählt ist auch behandeln möchte.
Bei mir werden z.B. einige Controls deaktiviert, wenn kein ListView-Eintrag ausgewählt ist. In dem Fall kommt es zum hässlichen Flackern beim Auswählen eines anderen Elements, wenn schon eins ausgewählt war, da zwischenzeitlich das SelectedIndexChanged/SelectedItemChanged-Ereignis ausgelöst wurde, um die Deselektierung des vorherigen Elements zu kennzeichnen.

Ich hab jetzt herausgefunden, dass, wenn das Ereignis aufgrund einer vorherigen Deselektierung ausgelöst wird, die Eigenschaft FocusedItem der ListView auf null steht (bzw. in meinem Fall war es Nothing, da ich hier bei der Arbeit VB.NET benutze). Das ist aber nicht der Fall, wenn der Anwender die Auswahl im ListView zurückgesetzt hat, indem er auf eine leere Fläche im ListView geklickt hat.

Mit dem Wissen kann man dann einfach direkt am Anfang seiner Funktion die Verarbeitung abbrechen, wenn FocusedItem auf null/Nothing steht.

Ich hoffe das hilft später irgendjemandem mal weiter. Ich hab selbst zuvor lange gegoogelt aber wirklich keine "saubere" Lösung gefunden. Jedesmal wurde irgendetwas mit einem Timer gemacht.

Hi zommi,

und vielen Dank für die Klasse. Hab sie schon in Verwendung, wie du bereits weißt. 🙂

Planst du vielleicht in nächster Zeit eine Unterstützung von weiteren PixelFormats, außer Format24bppRgb? Momentan gehe ich so vor, dass ich aus einem in die Form geladenem Image-Objekt zuerst ein Bitmap-Objekt erzeuge, bei diesem dann das PixelFormat in Format24bppRgb ändere (in dem ich per Clone ein neues Bitmap-Objekt erzeuge) und aus diesem Bitmap-Objekt dann letzlich ein MemBitmap-Objekt erzeuge. Klappt alles, ich habe allerdings den Nachteil, dass ich keine transparenten Bilder verarbeiten kann, bzw. verarbeiten schon, aber die Transparenz-Informationen gehen leider verloren.

Grüße,

Isaac

Wow, danke allen schonmal für die sehr hilfreichen Beiträge. 🙂

@kleines_eichhoernchen & Kaji:
Ja, beide Threads fand ich auch bei meiner Suche. Hab mich letzlich für die MemBitmap-Klasse von zommi entschieden, die zum einen (nach meinen Tests) schneller ist als die RoBitmap-Klasse von Robertico (GetPixel und SetPixel um Längen geschlagen. 800 mal schneller). An dieser Stelle einmal ein riesiges Dankeschön an zommi. Die MemBitmap-Klasse ist wiklich absolut genial und ich find's toll, dass du die hier zur Verfügung stellst!

Mit Pointern möchte ich aber erstmal nichts machen. Zum einen, weil das etwas für jemanden, der hauptsächlich VB.NET programmiert, schonmal was ganz anderes ist, zum anderen, weil ich mich da ehrlich gesagt noch nicht so rantraue. ^^ Außerdem wird es dann für meine Zielplattform letzlich nicht hilfreich, da ich dort definitv keine Pointer verwenden können werde. (Ich sag besser nicht, was ich vorhab, sonst killt man mich hier noch. 😄)

(Ich muss noch dazu sagen, dass ich mich erst seit etwas über einem Jahr aufgrund meiner Ausbildung zum Fachinformatiker mit (VB) .NET beschäftige. Möchte jetzt aber doch vermehrt mit C# arbeiten, auch wenn der Umstieg gewöhnungsbedürftiger ist, als ich annahm. Nunja, wird alles noch.)

@wolpertinger & zommi:
Super! Genau auf solche Optimierungen habe ich gehofft. Ich bin ja bei meiner Version so vorgegangen, dass ich mir in Photoshop einige Testfarben anlege, dann den Filter anwende, den ich entsprechend umsetzen möchte und mir dann die veränderten Farbwerte anschaue, um dann drauf zu kommen, was genau gemacht werden muss. Bei meinem Graustufen-Filter bin ich, wie aus der Farbbrechnung hervorgeht, darauf gekommen, dass der Grauwert dem Mittel von dunkelstem und hellstem Farbwert entspricht.*
Eure Vorschläge sind da aber um einiges toller. Werde wohl nicht drumherum kommen, mich wirklich intensiv mit diesem Thema zu beschäftigen. Interesse ist jedenfalls ausreichend vorhanden, bin ja eh ein "halber" Grafiker und interessiere mich sehr für das Thema Bildbearbeitung.

Ich werde jetzt mal den Vorschlag von wolpertinger und zommi umsetzen und danach mal einen "Farben umkehren"-Filter implementieren. Danke bis hierher schonmal. 🙂

Grüße,

Isaac

*Nachtrag: Meine Version änderte wohl nur die Sättigung des Bildes auf -100%. Das entspricht aber wohl nicht genau dem Luminanz-Wert der Farben. Wieder etwas gelernt. ^^

Hallo herbivore,

danke für die schnelle Antwort. Da bin ich ja gleich ins Fettnäpfchen als Neuling getreten. Hätte die Suchfunktion wirklich vorher verwenden sollen, mein Fehler. 🙁

Ich bin jetzt auf auf die Klassen RoBitmap von Robertico und MemBitmap von zommi gestoßen und habe jetzt auch beide schon erfolgreich angewendet. Die sind schonmal beide um einiges schneller als die Bitmap-Klasse aus dem .NET Framework. Wobei MemBitmap nochmals die RoBitmap um einiges schlägt.

Ich denke damit lässt sich erstmal gut arbeiten. Ich verwende ja C# jetzt wie gesagt nur, um allgemein zu testen, ob die Bildumfärbungen so klappen, wie ich sie mir vorstelle. Da hilft es ja auch, dass das Testen schneller geht.

Vielen Dank nochmal! 🙂

Hallo. 🙂

Ich interessiere mich für das Thema Bildbearbeitung und hab mich daher heute an ein kleines Programm rangesetzt, mit dem man ganz simpel Bilder in die Graustufen umfärben kann. Es ist funktioniert wirklich ganz simpel. Das Bild wird Pixel für Pixel durchlaufen und die entsprechend durch die passende Graustufe ersetzt.

Das funktioniert an sich problemlos. Aber es läuft verdammt langsam. Wenn ich das mit bekannten Bildbearbeitungsprogrammen vergleiche (Photoshop, GIMP, Paint.NET), wo das innerhalb weniger Millisekunden geht, ist da meine erste Version doch sehr enttäuschend.

Das hier ist mein Umfärbe-Algorithmus. Wie gesagt, wirklich nichts besonderes, ich fang gerade erst an. ^^

private Image createGreyscale(Image image)
{
	Bitmap bitmap = new Bitmap(image);

	for (int x = 0; x < bitmap.Width; x++)
	{
		for (int y = 0; y < bitmap.Height; y++)
		{
			Color currentColor = bitmap.GetPixel(x, y);
			bitmap.SetPixel(x, y, greyscaleColor(currentColor));
		}
	}

	return (Image)bitmap;
}

private Color greyscaleColor(Color color)
{
	byte darkColor = color.R;
	if (color.G < darkColor) darkColor = color.G;
	if (color.B < darkColor) darkColor = color.B;

	byte lightColor = color.R;
	if (color.G > lightColor) lightColor = color.G;
	if (color.B > lightColor) lightColor = color.B;

	byte greyscaleTone = (byte)((darkColor + lightColor) / 2);

	return Color.FromArgb(greyscaleTone, greyscaleTone, greyscaleTone);
}

Ich hab mal zusätzlich noch das komplette C#-Projekt angehängt.

Nunja, vermutlich werden die Verbesserungsvorschläge auf Multi-Threading hinauslaufen. Da wird sich wohl das meiste rausholen lassen.
Aber gäb's vielleicht noch Verbesserungen im Algorithmus selbst? Ich brauch das letzlich nicht für ein C#-Projekt, da teste ich nur die Grundfunktionen, wie z.B. Farbkorrekturen (sollen noch einige dazukommen, später), daher wären Optimierungen für das Umfärben ansich hilfreicher. Wobei mir selbst auch keine Alternative dazu einfallen würde, als einfach alle Pixel nacheinander umzufärben.

Bin aber dennoch über jeden Verbesserungsvorschlag froh, auch wenn er C#-spezifisch ist.

Bin gespannt auf eure Antworten. 🙂

Meine Alltime-Favourites sind die Silk/Flag-Icons von famfamfam.
Außerdem sind noch die Fugue/Diagona-Icons von pinvoke sehr empfehlenswert.
Sehr hübsch sind auch die Tango-Icons vom Tango Desktop Project.

Zur Verwendung in eigenen Projekten: Die Icons (außer famfamfam-Flag), die ich verlinkt habe, stehen unter einer Creative-Commons-Namensnennung-Lizenz. Genauere Informationen kann man den verlinkten Seiten entnehmen. 🙂