auf Desktop zeichnen

Tippokrates

Also eigentlich würde ich es schon gerne so einrichten, dass die Icons noch sichtbar / zu betätigen sind,
also mein Form sozusagen als Wallpaper.

Läuft das dann in etwa so:

TForm1 *Form1;
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
        : TForm(Owner)
{
    case WM_PAINT:
    {
        HDC hDC;
        PAINTSTRUCT ps;

        HDC hDesktopDC = GetDC(hDesktop);
        hDC = BeginPaint(hWnd, &ps);

    // malen

        EndPaint(hWnd, &ps);
        ReleaseDC(hDesktop, hDesktopDC);

        return 0;
    }
}
//---------------------------------------------------------------------------

Edit: So funzt es net, aber wie gesagt sowas hab ich noch nie gemacht und suche deshalb eure Hife

supersass1

Ja versuch es doch erstma so.

Edit: So funzt es net, aber wie gesagt sowas hab ich noch nie gemacht und suche deshalb eure Hife

Poste den ganzen Code, bzw. deine Fehler. Was hast du genau gemacht?
Versuch erstma was einfaches darzustellen, und wenn das klappt, ersetz dies mit deiner Grafik (oder was auch immer)

grüße
supersass1

Tippokrates

Unit1.cpp eines ganz leeren Forms, zum testen neu erstellt:

//---------------------------------------------------------------------------

#include <vcl.h>
#pragma hdrstop

#include "Unit1.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
        : TForm(Owner)
{
  case WM_PAINT:
    {
        HDC hDC;
        PAINTSTRUCT ps;

        HDC hDesktopDC = GetDC(hDesktop);
        hDC = BeginPaint(hWnd, &ps);

    // malen

        EndPaint(hWnd, &ps);
        ReleaseDC(hDesktop, hDesktopDC);

        return 0;
    }
}
//---------------------------------------------------------------------------

[C++ Fehler] Unit1.cpp(15): E2128 case-Marke außerhalb der switch-Anweisung
[C++ Fehler] Unit1.cpp(15): E2188 Ausdruckssyntax
[C++ Fehler] Unit1.cpp(31): E2379 In Anweisung fehlt ;

@supersass1: BIst du sicher, dass TForm1::TForm1 der richtige Platz für den Code ist?

Ich kenne die Case-Struktur ja, aber was di an der Stelle soll, und nur dieser Teil davon, das kann ich nicht nachvollziehen an dem gepostetem Code.

Wie gesagt, das Form ist leer, beste Vorraussetzung zum Testen, meine Grafik kommt dann erst wenn das hier funzt

Ich danke schon mal das ihr euch die Mühe macht! Echt super hier im Forum!
MfG
Tippo

supersass1

du hast den thread im Forum winAPI gepostet, also bin ich davon ausgegangen, dass deine Grundstruktur wie folgt lautet:

#define STRICT

#include <windows.h>
LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);

const char szAppName[] = "Ein eigenes Fenster";
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, 
                   PSTR szCmdLine, int iCmdShow)
{

   HWND       hWnd;
   MSG        msg;
   WNDCLASS   wc;

   wc.style         =  CS_HREDRAW | CS_VREDRAW;
   wc.lpfnWndProc   =  WndProc;
   wc.cbClsExtra    =  0;
   wc.cbWndExtra    =  0;
   wc.hInstance     =  hInstance;
   wc.hCursor       =  LoadCursor(NULL,IDC_ARROW);
   wc.hIcon         =  LoadIcon(NULL,IDI_APPLICATION);
   wc.hbrBackground =  (HBRUSH)GetStockObject(WHITE_BRUSH);
   wc.lpszClassName =  szAppName;
   wc.lpszMenuName  =  NULL;
   RegisterClass(&wc);
   hWnd = CreateWindow(szAppName,
                       "Titelleiste",
                       WS_OVERLAPPEDWINDOW,
                       CW_USEDEFAULT,          /* X-Position auf dem Monitor */
                       CW_USEDEFAULT,          /* Y-Position auf dem Monitor */
                       CW_USEDEFAULT,          /* Fensterbreite              */
                       CW_USEDEFAULT,          /* Fensterhoehe               */
                       NULL,
                       NULL,
                       hInstance,
                       NULL);

   ShowWindow(hWnd, iCmdShow);
   UpdateWindow(hWnd);
   while (GetMessage(&msg, NULL, 0, 0))
   {
      TranslateMessage(&msg);
      DispatchMessage(&msg);
   }
   return msg.wParam;
}
LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
   switch (message)
   {
 //----------------------------------->
 // siehe unten
   case WM_DESTROY:
      {
         PostQuitMessage(0);
         return 0;
      }
   }
   return DefWindowProc(hWnd, message, wParam, lParam);
}

dies sollte/ist der StandartCode einer WinAPI-anwedung.

nun fügst du in die switch-Anweisung folgendes ein:

case WM_PAINT:
    {
        HDC hDC;
        PAINTSTRUCT ps;

        HDC hDesktopDC = GetDC(hDesktop);
        hDC = BeginPaint(hWnd, &ps);

// malen

        EndPaint(hWnd, &ps);
        ReleaseDC(hDesktop, hDesktopDC);

        return 0;
    }

dort wo malen steht, muss natürlich das hin, was du zeichnen willst...

Bei deiner vorgeschlagenen Lösung müsstet du eigentlich nur das case entfernen, etwas so:

//---------------------------------------------------------------------------

#include <vcl.h>
#pragma hdrstop

#include "Unit1.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
        : TForm(Owner)
{
 // case WM_PAINT:
 //   {
        HDC hDC;
        PAINTSTRUCT ps;

        HDC hDesktopDC = GetDC(hDesktop);
        hDC = BeginPaint(hWnd, &ps);

    // malen

        EndPaint(hWnd, &ps);
        ReleaseDC(hDesktop, hDesktopDC);

        return 0;
  //  }
}
//---------------------------------------------------------------------------

//Edit:
Achja, nich vergessen:

include <windows.h>

Tippokrates

Hallo supersass1 und alle anderen!
Ich begrüße den einen Herrn mal zuerst, weil er schon so viel für mich gepostet hat.

Leider hat das für mich einige Klippen mit denen ich nicht so leicht umgehe kann wie ich das gerne könnte. Ich muss zugeben das es meine erste Anwendung sein soll die WinApi nutzen soll, und ich keine Ahnung habe... Nur zum Verständnis.

Soweit ich das sehe, muss ich ersteinmal mit

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
                   PSTR szCmdLine, int iCmdShow)

einige Veriablen besorgen und "bescheid geben" das was mit Api kommen soll, richtig?

hWnd = CreateWindow(szAppName,
                       "Titelleiste",
                       WS_OVERLAPPEDWINDOW,
                       CW_USEDEFAULT,          /* X-Position auf dem Monitor */
                       CW_USEDEFAULT,          /* Y-Position auf dem Monitor */
                       CW_USEDEFAULT,          /* Fensterbreite              */
                       CW_USEDEFAULT,          /* Fensterhoehe               */
                       NULL,
                       NULL,
                       hInstance,
                       NULL);

Das verwirrt mich, CreateWindow erstellt doch ein normales Fenster so wie ich es von "Form1" gewöhnt bin. Aber ich will doch auf den Desktop kommen.

Nun also hab ich das mal versucht, und habe an der im code von superass gekennzeichneten Stelle den WM_PAINT Teil eingefügt.

Da kam ein Fehler mit hDesktop, das ich dann als

HWND hDesktop=GetDesktopWindow();

vereinbart habe.

Aber dann muss ich ja auch noch was zeichnen. Gut, ok, eine Ellipse, kein Problem, aber wohin? Form1->Canvas->Ellipse(...) aber Form1 muss ich ja iwi mit dem Desktop vertauschen, oder?

Gut, wenn ich den Code nun ausführe gibt es keine Fehler mehr, aber ein normales Fenster öffnet sich, und nichts wird gezeichnet, egal was ich bei //malen reinschreibe.

Für die ganz harten nun noch mein ganzer QT: (kann ich auf Wunsch auch wieder wegeditieren, wenn zu lang)

//---------------------------------------------------------------------------

#include <vcl.h>
#include <windows.h>
#pragma hdrstop

#include "Unit1.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
//---------------------------------------------------------------------------
#define STRICT

LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);

const char szAppName[] = "Ein eigenes Fenster";
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
                   PSTR szCmdLine, int iCmdShow)
{

   HWND       hWnd;
   MSG        msg;
   WNDCLASS   wc;

   wc.style         =  CS_HREDRAW | CS_VREDRAW;
   wc.lpfnWndProc   =  WndProc;
   wc.cbClsExtra    =  0;
   wc.cbWndExtra    =  0;
   wc.hInstance     =  hInstance;
   wc.hCursor       =  LoadCursor(NULL,IDC_ARROW);
   wc.hIcon         =  LoadIcon(NULL,IDI_APPLICATION);
   wc.hbrBackground =  (HBRUSH)GetStockObject(WHITE_BRUSH);
   wc.lpszClassName =  szAppName;
   wc.lpszMenuName  =  NULL;
   RegisterClass(&wc);
   hWnd = CreateWindow(szAppName,
                       "Titelleiste",
                       WS_OVERLAPPEDWINDOW,
                       CW_USEDEFAULT,          /* X-Position auf dem Monitor */
                       CW_USEDEFAULT,          /* Y-Position auf dem Monitor */
                       CW_USEDEFAULT,          /* Fensterbreite              */
                       CW_USEDEFAULT,          /* Fensterhoehe               */
                       NULL,
                       NULL,
                       hInstance,
                       NULL);

   ShowWindow(hWnd, iCmdShow);
   UpdateWindow(hWnd);
   while (GetMessage(&msg, NULL, 0, 0))
   {
      TranslateMessage(&msg);
      DispatchMessage(&msg);
   }
   return msg.wParam;
}
LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
   switch (message)
   {
   //----------------------------------->
   // siehe unten
   case WM_PAINT:
   {
        HDC hDC;
        PAINTSTRUCT ps;

        HWND hDesktop=GetDesktopWindow(); 
        HDC hDesktopDC = GetDC(hDesktop);
        hDC = BeginPaint(hWnd, &ps);

        // malen
        Form1->Canvas->Brush->Color = clRed;
        Form1->Canvas->Ellipse(0,0,Form1->ClientWidth,Form1->ClientHeight); 

        EndPaint(hWnd, &ps);
        ReleaseDC(hDesktop, hDesktopDC);

        return 0;
   }
   case WM_DESTROY:
      {
         PostQuitMessage(0);
         return 0;
      }
   }
   return DefWindowProc(hWnd, message, wParam, lParam);
}
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
        : TForm(Owner)
{
}
//---------------------------------------------------------------------------

Jedenfalls kann ich mir bei der Sache nicht selber weiterhelfen. Was läuft falsch. Sicher mache ich etwas grundlegendes falsch...

MfG
Tippo

supersass1

hi Tippo,

ich habe grad nicht viel Zeit, deshalb ist der Post nicht so ausführlich.

Jedenfalls kann ich mir bei der Sache nicht selber weiterhelfen. Was läuft falsch. Sicher mache ich etwas grundlegendes falsch...

Ja in der Tat, du musst dich entscheiden, zwischen winApi oder deinem TForm-"kram".

Möchtest du weiter wie gewohnt arbeiten, müsstest du dies im andern Thread posten, bleibst du hierbei, müsstest du dich mit WinApi anvertrauen.

Kurzes Tutorial: http://www.win-api.de/tutorials.php?tutid=3
Das Ist außerderm der Quelltext, den ich dir als Grundlage vorgeschlagen habe.

dWie du zeichnen kannst steht hier:
http://win-api.de/tutorials.php?tutid=9

Doch das ist für dich wohl zu un-umfassend.
Ich werde dir später (habe wenig Zeit grade) noch ausführlicherer Infos schicken.

übrigens:
Steht dein "Radar" schon oder was du zeichnen wolltest?
Also kannst du es in deinem Fesnter zeichnen?

viele liebe grüße
supersass1

//Edit1:

Form1->Canvas->Brush->Color = clRed;
        Form1->Canvas->Ellipse(0,0,Form1->ClientWidth,Form1->ClientHeight);

das erinnert mich an Delphi, ich könnte dir erklären wie man in Delphi zeichnent, das ist recht einfach.

//Edit2:
ich habe etwas interessantes gefunden http://www.bytesandmore.de/rad/index.htm?http://www.bytesandmore.de/rad/cpp/snipp/sc03027.php
Das sollte auch für dich ansrpechenen, wenn man den Handle dementsprechen verändert.

Badestrand

Evtl kannst du das Desktopfenster hooken (Boardsuche nach SetWindowsHookEx) und beim Hintergrund-zeichnen dein Fenster draufzeichnen lassen?

Tippokrates

supersass1 schrieb:

hi Tippo,
Form1->Canvas->Brush->Color = clRed;
        Form1->Canvas->Ellipse(0,0,Form1->ClientWidth,Form1->ClientHeight);
das erinnert mich an Delphi, ich könnte dir erklären wie man in Delphi zeichnent, das ist recht einfach.

Wenn du mir das evtl für Delphi zeigen kannst, dann wäre das sicher nen Versuch wert! Dann könnte ich das auch weiter mit der VCL machen. Denn ich kann nur ehrlich sagen das ich mich jetzt nicht noch so tief in die WinAPI einarbeiten will, und auch nicht kann.

Vlt können wir das ja so lösen?!

PS: Ja, die Grafik ist eigentlich fertig, habs zu angucken mal auf meinen Server gepackt als exe, da kann man sich das vlt besser vorstellen.

http://tippo.webnerd.de/radar.exe

Wie gesagt, ist kein Virus oder so drauf, ist ja von mir und auch auf meinem Server.

Tippokrates schrieb:

Wie gesagt, ist kein Virus oder so drauf, ist ja von mir und auch auf meinem Server.

Freiheit statt Angst - Für die Grundrechte - und wenn du keinen Virus verbreiten willst, lad ich mir auch nix von deinem Server. Informatikstudenten sind mir eh ein Greuel.

Schurke

könntest du zu dem radar noch den source code stellen bitte?

Tippokrates

Dan Zulla schrieb:

Tippokrates schrieb:

Wie gesagt, ist kein Virus oder so drauf, ist ja von mir und auch auf meinem Server.

Freiheit statt Angst - Für die Grundrechte - und wenn du keinen Virus verbreiten willst, lad ich mir auch nix von deinem Server. Informatikstudenten sind mir eh ein Greuel.

Hi Dan: Is doch dein Server ^^ Nur wenn ich schreibe der Server von wem anders dann klingt das nicht so ob ich dem Server selber vertraue, oder?

Informatikstudent bin ich auch noch nicht, hab zwar meinen Studienplatz, kann aber noch nicht loslegen (zu jung)

So, zurück zum Thema: Ja ok, ich schiebe heute abend noch ne zip mit dem ganzen Projekt auf die Adresse. habe jetzt keinen Zugriff, wegen Schule...

MfG
Tippo

supersass1

Tippokrates schrieb:

Wenn du mir das evtl für Delphi zeigen kannst, dann wäre das sicher nen Versuch wert! Dann könnte ich das auch weiter mit der VCL machen.

Ja das ist kein Problem,in Delphi sieht das wie folgt aus:

Deklarieren der Variablen

var
  DC        : HDC;
  Canvas    : TCanvas;
  Bitmap    : TBitmap;
//nach dem : steht der Typ

DC vom Desktop holen

DC := GetWindowDC(GetDesktopWindow());

Canvas erstellen, handlen, und zeichnen

Canvas := TCanvas.Create();
Canvas.Handle := DC;
Canvas.Draw(0,0, "das zu malenen Bitmap");

canvas freigeben

ReleaseDC(0, DC);

das ganze sieht dan folgendermaßen aus:

procedure TForm1.DrawPicture(c1:integer=0;c2:integer=0;c3:integer=0;c4:integer=0);
var
  DC        : HDC;
  Canvas    : TCanvas;
  Bitmap    : TBitmap;

begin
  begin
    Bitmap := TBitmap.Create();
    try
        Bitmap.Height := 600;
        Bitmap.Width := 600;
      Bitmap.Canvas.Brush.Color:=RGB(255,0,50);
      Bitmap.Canvas.Brush.Style:=bsSolid;
      Bitmap.Canvas.Pen.Width:=5;
      Bitmap.Canvas.Ellipse(c1,c2,c3,c4);

      // Wir holen uns den 'Device Context' vom Desktop
      DC := GetWindowDC(GetDesktopWindow());

      //DC := GetWindowDC(GetForegroundWindow());

      try
        Canvas := TCanvas.Create();
        try
          // Wir weisen den DC dem Canvas zu
          Canvas.Handle := DC;
          // Das Bild wird an Left / Top auf den Desktop gezeichnet
          Canvas.Draw(0,0, Bitmap);
        finally
          Canvas.Free;
        end;
      finally
        ReleaseDC(0, DC);
      end;
    finally
      Bitmap.Free;
    end;
  end;
end;

Aufrufen tut man die Funktion dann mit den 4 Parametern:

Draw.Picture(1,2,3,4);

Es ist nichts besonderes, es wird ledigliche ein Kreis gezeichnet.

PS: Ja, die Grafik ist eigentlich fertig, habs zu angucken mal auf meinen Server gepackt als exe, da kann man sich das vlt besser vorstellen.

http://tippo.webnerd.de/radar.exe

Mich interessiert, wie du das gemacht hast, mit VCL. Ich kann mit Delphi zeichnen, aber nich mit C++, oder nur schwer mit C++. Hast du vielleicht ein Tutorial dazu?

viele liebe grüße
supersass1

P.S.: Welche Klasse gehst du, dass du dich schon um ein Studiumplatz kümmerst?

Tippokrates

Jo, danke für den Delphi Code, ich denke das ist einen Versuch wert das mal umzuschreiben, denn an sich ist da alles ziemlich ähnlich in der VCL und mit dem BCB 6 ist das ja eh alle mit Delphi und so...
Leider werde ich erst heute abend oder nächste Woche dazu kommen, muss viel lernen weil Klausuren anstehen.

Also ich gehe zZt in die 12. Klasse in Thüringen, und mache also nächstes Jahr Abitur. Was ich studiere weiss ich daher, da ich mich bei der Bundeswehr beworben hae und ein Informatikstudium an der Universität in München zugesagt bekommen habe.

Das Projekt findest du unter http://tippo.webnerd.de/radar_project.rar. Ist alles drin was du brauchst. Für Canvas kenne ich kein gutes Tutorial, ich habs aus nem Buch, aber die Hilfe dazu ist eigentlich gut dokumentiert, und eigentlich genau wie in Delphi

Einen schönen Tag noch,
Tippo

Edit wie angekündigt

void __fastcall TForm1::Button1Click(TObject *Sender)
{
  HDC DC;
  TCanvas * FCanvas = new TCanvas();
  Graphics::TBitmap *BrushBmp = new Graphics::TBitmap;
  BrushBmp->Width = 800;
  BrushBmp->Height = 600;
  BrushBmp->Canvas->Brush->Color = clRed;
  BrushBmp->Canvas->Ellipse(0,0,800,600);

  DC = GetWindowDC(GetDesktopWindow());
  FCanvas->Handle = DC;
  FCanvas->Draw(0,0,BrushBmp);

  ReleaseDC(0, DC);

  delete BrushBmp;
  delete FCanvas;
}

Jop! Das zeichnet schon mal... zwar auf den Desktop soweit ich das beurteilen kann, aber ich will es ja HINTER die Icons und nicht davor so wie das wäre.

Aber ich hab da schon so eine idee... aber vlt sieht ja wer wie ich das hinter die icosn bringe... morgen mehr...

supersass1

du zeichnest ja momentan ein Bitmap, und diese lädst du dann in den DC des Desktops.

Würdest du das Bitmap speichern können, wäre sicherlichauch soetwas möglich:
http://www.c-plusplus.net/forum/viewtopic-var-p-is-83030.html

Ansonsten könnte ich mir vorstellen, dass es eine Funktion gibts, um das Background-Picture des Desktops zu ändern, da dann einem dein Bitmap einsetzen.

mfg supersass1

Badestrand

Badestrand schrieb:

Evtl kannst du das Desktopfenster hooken (Boardsuche nach SetWindowsHookEx) und beim Hintergrund-zeichnen dein Fenster draufzeichnen lassen?

Mal ausprobiert? Irgendwie gehts auf jeden Fall, der VLC Media Player kann auch die Videos hinter den Desktop-Icons abspielen, als Hintergrundbild quasi; und weil der OpenSource ist, könnte man da abgucken, dürfte aber nicht so einfach sein, ich glaube der löst das irgendwie mit DirectX.. Naja, Hook ausprobiert?

Tippokrates

SetWindowsHookEx

Sagt mir leider gar nichts... Da müsste ich mir jetzt erst mal Grundlagen zu aneigenen eh ich an dem Projekt weiter arbeiten kann.

Das Problem ist, wenn ich eine neue TBitmap erstelle, sie speichere, und als Wallpaper setze, dann funzt das auch.

Nur Meine Grafik wird in einem Timer erzeugt (siehe exe), also ziemlich häufig, und wenn ich dann alle (paar) Sekunde(n) ein neues Wallpaper setze, dann gibts das große Flackern. Und das will ja niemand sehen.

Hat denn noch niemand sowas mal gemacht, was bewegtes auf den Desktop bringen? Das von dem VLC Player das kenne ich, aber da spielen noch ganz andere Sachen eine Rolle von denen ich nichts verstehe. Ich will das ja auch einfach halten und nicth Videos abspielen...

MfG
Tippo

supersass1

mit der HOOK-Geschichte kann ich dir auch nicht weiterhelfen, da habe ich auch nur von gehört.

Das mit dem Flackern kommt mir bekannt vor, aus Delphi
Ich würde deine .exe gerne mal sehen.

Ich könnte mir vorstellen, dass du vielleicht ein Bitmap unter das, welches sich milli-sekündlich ändert, malst, vielleicht verhindert dies ein flackern.

Ansonsten würde ich das mit dem Hook versuchen, versuche statt eines Bitmaps, dein Windows als Background zu malen.

Halt uns auf dem laufenden
mfg supersass1

sarabande

Tippokrates schrieb:

Hat denn noch niemand sowas mal gemacht, was bewegtes auf den Desktop bringen?

Hi! Die Antwort wird dir nicht gefallen. Diese Idee verwirft ein Profi, weil er weiß, welche Funktion ein Desktop hat! HTH - sarabande

geeky

Die meiner Meinung nach beste Methode: HTML-Datei mit eingebettetem ActiveX-Objekt als Desktop-Hintergrund einbetten.

oder eine feste Hintergrundfarbe setzen und mit DirectX/DirectShow nen Overlay drauf kloppen.

Tippokrates

Hm, mit Overlay da hab ich schon mal was mit Delphi gesehen bzw. auch hier liegen.

@Sarabande: Tja der Desktop soll ja nicht mehr nur noch zum Arbeiten sein, er soll ja auch gut aussehen ^^ Aber Recht haste ja eigentlich.

Aber bei vielen Problemen geht es doch ehr darum WIE und OB es geht, nicht ob man es wirklich braucht.

Ja gut, eine HTML als Desktophintergrund funzt auch, is richtig. Aber ist halt nicht C++

Ich sehe schon hier gibt es noch ein paar die das intreressiert, ich stelle mein Projekt nochmal online und verlinke es hier, aber heute werde ich nicht mehr dazu kommen.

MfG
Tippo

Edit: bin doch noch schnell dazu gekommen:

Das Beispielproject. Anmerkungen finden sich im Quelltext!

http://tippo.webnerd.de/Desktop.rar