C
Danke, ja SetDlgItemInt kannte ich nicht; scheint dies zu vereinfachen. Ich verwende auch ziemlich oft SendMessage und sonst "altmodischen C-Stil", bin ich mir besser gewohnt in diesem Zusammenhang irgendwie.
EIne eigene Klasse habe ich mir auch schon überlegt, so wie beim C#-Projekt:
namespace Bildbearbeitungsprogramm
{///<summary>
///Dieses Interface definiert die grundlegensten Methoden der Version 1.6 (Okt. 2008)
///</summary>
#region Interface
public interface IBildbearbeitung
{
Bitmap GetBitmap();
void addFile(string Filename);
Bitmap GetBitmapZoom(int percent);
Bitmap Bildverkleinern(int height, int width);
Size Bildgroesse();
Bitmap Bilddrehen();
#endregion
}
/// <summary>
/// Dieses Interface implementiert die Erweiterungen für die Versionen nach 1.6
/// </summary>
public interface IBildbearbeitung2
{
void replaceBitmap(Bitmap neuesBild);
Bitmap Brighten(int nBrightness);
}
///<summary>
///In dieser Klasse wird die gesamte Funktionalität des Programmes bereitgestellt
/// </summary>
#region Class Bildbearbeitung Basisklasse
public class Bildbearbeitung : IBildbearbeitung
{
protected Bitmap bild; //enthält das Bild; dieses wird bearbeitet, keine Kopie des Originales behalten.
public Bildbearbeitung(string Filename)
{
string Dateiname = Filename;
bild = new Bitmap(Dateiname, true);
}
public Bildbearbeitung(Bitmap BildBitmap)
{
bild = BildBitmap;
}
public Bildbearbeitung() { }
///<summary>
///Datei hinzufügen (öffnen)
///</summary>
public void addFile(string Filename)
{
string Dateiname = Filename;
bild = new Bitmap(Dateiname, true);
}
/// <summary>
/// Das Bild wird als Bitmap zurückgeliefert (wenn bearbeitet dann die bearbeitete Version)
/// </summary>
/// <returns>Bitmap-Objekt (ggf. gedreht, ggf. bearbeitet)</returns>
public Bitmap GetBitmap()
{
return bild;
}
/// <summary>
/// Liefert das Bitmap verkleinert/vergrössert zurück; falls es gedreht wurde dann in der Bearbeiteten Version; int-Wert=Faktor. Die Originalversion bleibt bestehen! Für Zoom-Ansicht
/// </summary>
/// <param name="percent"></param>
/// <returns>verkleinertes/vergrössertes Bitmap-Obj</returns>
public Bitmap GetBitmapZoom(int percent)
{
int pSize = percent;
/*Bitmap bild2 = (Bitmap)bild.GetThumbnailImage((bild.Width * 100) / percent, (bild.Height * 100) / percent, null, IntPtr.Zero);
return bild2;
*/
Bitmap pImage = bild;
int x, y;
if (pImage.Width > pImage.Height)
{
x = pSize;
y = Convert.ToInt32(((float)pImage.Height / (float)pImage.Width * pSize));
}
else
{
y = pSize;
x = Convert.ToInt32(((float)pImage.Width / (float)pImage.Height * pSize));
}
Image ret = new Bitmap(x, y);
Graphics g = Graphics.FromImage(ret);
g.InterpolationMode = System.Drawing.Drawing2D.InterpolationMode.HighQualityBicubic;
g.DrawImage(pImage, 0, 0, x, y);
g.Dispose();
return ret as Bitmap;
}
/// <summary>
/// Verkleinert/vergrössert das Bild nach Höhe/Breite DEFINITIV (keine Kopie wird behalten)
/// </summary>
/// <param name="height"></param>
/// <param name="width"></param>
/// <returns>Bearbeitetes Bitmap-Obj</returns>
public Bitmap Bildverkleinern(int height, int width)
{
int x, y;
x = width;
y = height;
Image ret = new Bitmap(x, y);
Graphics g = Graphics.FromImage(ret);
g.InterpolationMode = System.Drawing.Drawing2D.InterpolationMode.HighQualityBicubic;
g.DrawImage(bild, 0, 0, x, y);
g.Dispose();
bild = ret as Bitmap;
return bild;
}
/// <summary>
/// Dreht das Bild (Original) um 90 Grad und liefert es zurück
/// </summary>
/// <returns>Gedrehtes Bitmap-Obj</returns>
public Bitmap Bilddrehen()
{
bild.RotateFlip(RotateFlipType.Rotate90FlipNone);
return bild;
}
/// <summary>
/// Liefert Bildgrösse zurück
/// </summary>
/// <returns>Size-Objekt</returns>
public Size Bildgroesse()
{
return bild.Size;
}
}
#endregion
/// <summary>
/// Dies ist die erweiterte Klasse der Versionen über 1.6 (bis auf Weiters)
/// </summary>
public class Bildbearbeitung_extended : Bildbearbeitung, IBildbearbeitung2
{
public Bildbearbeitung_extended(string Filename) : base(Filename) { }
public Bildbearbeitung_extended(Bitmap BildBitmap) : base(BildBitmap) { }
public Bildbearbeitung_extended() { }
/// <summary>
/// Fügt ein neues Bitmap hinzu resp. ersetzt das Bild in der Objektinstanz
/// </summary>
/// <param name="neuesBild"></param>
public void replaceBitmap(Bitmap neuesBild)
{
bild = neuesBild;
}
/// <summary>
/// Verändert die Helligkeit. Verwendet unsafe-Code! Rückgabewert ist das veränderte Bitmap. Verändert Bild definitiv.
/// </summary>
public Bitmap Brighten(int nBrightness)
{
System.Drawing.Imaging.BitmapData bmData
= bild.LockBits(new Rectangle(0, 0, bild.Width, bild.Height), System.Drawing.Imaging.ImageLockMode.ReadWrite, System.Drawing.Imaging.PixelFormat.Format24bppRgb);
int stride = bmData.Stride;
System.IntPtr Scan0 = bmData.Scan0;
unsafe
usw.......
vorerst entschloss ich mich in C++ noch dies nicht so zu tun, aber je nach Funktionsumfang welchen ich in der C++-Version dann anstrebe werde ich es noch tun; bin halt in C++ weniger gut wie in C#
