/* Events.c */

#include "Constants.h"
#include "Locale.h"

#include <exec/types.h>
#include <exec/memory.h>
#include <exec/libraries.h>
#include <intuition/intuition.h>
#include <intuition/intuitionbase.h>
#include <intuition/gadgetclass.h>
#include <libraries/gadtools.h>
#include <libraries/commodities.h>
#include <libraries/asl.h>
#include <devices/scsidisk.h>
#include <devices/cd.h>
#include <graphics/rastport.h>
#include <libraries/screennotify.h>
#include <pragma/screennotify_lib.h>
#include <workbench/workbench.h>
#include "AsmLib/CD-ROM.h"
#include "Structures/Application.h"
#include "Structures/DirNode.h"
#include "Structures/MyPubScreenNode.h"

#include <clib/exec_protos.h>
#include <clib/dos_protos.h>
#include <clib/commodities_protos.h>
#include <clib/intuition_protos.h>
#include <clib/gadtools_protos.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include "ACDPlay_protos.h"

extern char *ls[ANZ_MSG];
extern struct Library *IntuitionBase;

BOOL HandleEvents(Application *app)
{
	struct IntuiMessage *imsg;
	struct Gadget *gad;
	struct Window *actwin;
	USHORT code, qualifier;
	ULONG class, seconds, micros;
	BOOL done = FALSE;
	BOOL exitloop = FALSE;
	BOOL changegui = FALSE;
	WORD win;
	int i;
	register struct CDStruct *cdstr = app->cdstr;

	while (imsg = GT_GetIMsg(app->idcmp))
	{
		/* Daten auslesen, damit Msg beantwortet werden kann */
		class 		= imsg->Class;
		code		= imsg->Code;
		qualifier	= imsg->Qualifier;
		seconds		= imsg->Seconds;
		micros		= imsg->Micros;
		gad		= (Gadget *)imsg->IAddress;

		actwin		= imsg->IDCMPWindow;

		/* Windownummer rausfinden */
		for (i = 0; i < ANZ_WINDOWS; i++)
			if (app->appwin[i].window == actwin)
			{
				win = i;
				break;
			}

		/* Msg beantworten */
		GT_ReplyIMsg(imsg);

  		switch (class)
		{
			case IDCMP_MENUPICK:
				while (code != MENUNULL)
				{
					switch (MENUNUM(code))	/* Menu-Nummer ermitteln */
					{
						case 0:		/* Projekt */
							switch (ITEMNUM(code))
							{
	  							case 0:		/* "Über..."-Fenster */
  									OpenAppWin(app, WINDOW_ABOUT);
  									break;
  								case 2:		/* "Verbergen" */
   									Iconify(app);
  									exitloop = TRUE;
  									break;
  								case 3:		/* "Entfernen" */
  									done = TRUE;
  									break;
	  						}
	  						break;

	  					case 1:		/* CD */
  							switch (ITEMNUM(code))
  							{
								case 0: /* Titelauswahlfenster */
									OpenAppWin(app, WINDOW_TITLES);
  									break;
								case 1: /* Titelprogrammierung */
  									OpenAppWin(app, WINDOW_PROGRAM);
  									break;
								case 2: /* Titeleingabe */
									OpenAppWin(app, WINDOW_EDIT);
									break;
								case 4: /* Lautstärke */
									OpenAppWin(app, WINDOW_VOLUME);
  									break;
  								case 5: /* A-B-Repeat */
  									OpenAppWin(app, WINDOW_AB);
  									break;
								case 6: /* Save Audio */
/*									OpenAppWin(app, WINDOW_SAVEAUDIO);
									OpenAppWin(app, WINDOW_AB);
									OpenAppWin(app, WINDOW_SAVING);
*/									break;
  								case 8: /* Informationen */
  									OpenAppWin(app, WINDOW_CDINFO);
  									break;
							}
							break;

						case 2:		/* Laufwerk */
							switch (ITEMNUM(code))
							{
								case 0: /* LUN */
								case 1: /* Unit */
									{
										struct CDxRequest *cdx = cdstr->cdx;
										BOOL suc;

										if (ITEMNUM(code)==1)
											suc = CDChangeDeviceA(cdx, SUBNUM(code), cdx->cdx_LUN);  /* neue Unit */
										else
											suc = CDChangeDeviceA(cdx, cdx->cdx_Unit, SUBNUM(code)); /* neue LUN */

										if (!suc)	/* Wechsel nicht erfolgreich? */
										{
											DisplayBeep(NULL);

											RemoveMenus(app);
											ItemAddress(app->menustrip, code)->Flags &= ~CHECKED;
											ItemAddress(app->menustrip, FULLMENUNUM(2,0,cdx->cdx_LUN))->Flags |= CHECKED;
											ItemAddress(app->menustrip, FULLMENUNUM(2,1,cdx->cdx_Unit))->Flags |= CHECKED;
											AttachMenus(app);
										}
										else
										{
											UpdateUnitLUN(app);
										}
									}
									break;
								case 2: /* Laufwerkssperre */
									CDLockA(cdstr->cdx, (ItemAddress(app->menustrip, code)->Flags) & CHECKED);
									break;
  								case 4: /* Öffnen */
  									CDEjectA(cdstr->cdx, TRUE);
  									break;
  								case 5: /* Schließen */
  									CDEjectA(cdstr->cdx, FALSE);
  									break;
								case 6: /* Stoppen */
									StopButton(app);
									break;
								case 8: /* Informationen */
									OpenAppWin(app, WINDOW_DRIVEINFO);
									break;
							}
							break;

						case 3:		/* GUI */
							switch (ITEMNUM(code))
							{
								case 0:	/* Magic-WB-Modus */
									app->magicwbmode = (ItemAddress(app->menustrip, code)->Flags) & CHECKED;
									changegui = TRUE;
									break;
								case 1:		/* GUI-Elemente */
									switch (SUBNUM(code))
									{
										case 0:	/* Direktwahl 1-10 */
											app->flag_main ^= FLAG_MAIN_DIRECTCHOICE0;
											break;
										case 1:	/* Direktwahl 11-20 */
											app->flag_main ^= FLAG_MAIN_DIRECTCHOICE1;
											break;
										case 2:	/* Titel */
											app->flag_main ^= FLAG_MAIN_TITLE;
											break;
										case 3:	/* Index/Spur/Zeit */
											app->flag_main ^= FLAG_MAIN_TIME;
											break;
										case 4:	/* Spielmodus/Wiederholung */
											app->flag_main ^= FLAG_MAIN_MODE;
											break;
										case 5:	/* Bedienungspanel */
											app->flag_main ^= FLAG_MAIN_PANEL;
											break;
										case 6:	/* Trackslider */
											app->flag_main ^= FLAG_MAIN_TRACKSLIDER;
											break;
									}
									changegui = TRUE;
									break;
 								case 3:		/* Public Screen */
									OpenAppWin(app, WINDOW_PUBSCREEN);
									break;
								case 5:		/* Fixieren */
									if (!SaveConfig(app, "ENVARC:acdplay.cfg") || !SaveConfig(app, "ENV:acdplay.cfg"))
										ShowMsgA(ls[MSG_ERROR_TITLE], ls[MSG_NO_SAVECFGFILE], NULL);
									break;
	  						}
	  						break;

						case 4: /* ARexx */
							MakeBusy(app, TRUE);
							ActivateCxObj(app->broker, 0L);
							if (ITEMNUM(code) == 0)
							{
								if (GetFileName(&app->appasl[ASL_AREXX], app->screen))
								{
									ExecuteARexxA(app->appasl[ASL_AREXX].pathname, app->arexx_mp, app);
									exitloop = TRUE;
								}
							}
							else
							{
								char command[45];	/* 30 + "ARexx/" + Nullbyte */
								strcpy(command, "ARexx/");
								AddPart(command, ((struct DirNode *)FindNode(app->arexxdir, ITEMNUM(code) - 2))->dn_Name, 45);
								ExecuteARexxA(command, app->arexx_mp, app);
								exitloop = TRUE;
							}
							ActivateCxObj(app->broker, 1L);
							CDReadTOCA(cdstr->cdx);
							CDUpdateA(cdstr->cdx);
							MakeBusy(app, FALSE);
							break;
					}

					if ((!exitloop) && (!done))
						code = (ItemAddress(app->menustrip, code))->NextSelect;
					else
						code = MENUNULL;
				}

				if (changegui)		/* Fenster schließen und öffnen, um Änderungen */
				{					/* am Layout durchzuführen */
					CloseAppWin(app, WINDOW_MAIN, FALSE);
					OpenAppWin(app, WINDOW_MAIN);
					actwin = app->appwin[WINDOW_MAIN].window
				}
				break;

			case IDCMP_CHANGEWINDOW:
				if (actwin->Flags & WFLG_ZOOMED)
				{
					app->appwin[win].minsize[LEFT]	= actwin->LeftEdge;
					app->appwin[win].minsize[TOP]	= actwin->TopEdge;

				}
				else
				{
					app->appwin[win].maxsize[LEFT]	= actwin->LeftEdge;
					app->appwin[win].maxsize[TOP]	= actwin->TopEdge;
				}
				break;

			case IDCMP_REFRESHWINDOW:
				GT_BeginRefresh(actwin);
				GT_EndRefresh(actwin, TRUE);
				break;
		}

		switch (win)
		{
			case WINDOW_MAIN:		/* Hauptfenster */
				switch (class)
				{
					static BOOL backward_pressed, forward_pressed;
					static WORD searched;

					case IDCMP_RAWKEY:
						switch (code)
						{				
							case 76:	/* Cursor hoch */
								JumpBackwardButton(app);
								break;
							case 77:	/* Cursor runter */
								JumpForwardButton(app);
								break;
							case 78:	/* Cursor rechts */
								SearchForwardButton(app, 10);
								break;
							case 79:	/* Cursor links */
								SearchBackwardButton(app, 10);
								break;
						}
						break;

					case IDCMP_VANILLAKEY:
						switch (code)
						{
							case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9':
								if (qualifier & (IEQUALIFIER_LSHIFT | IEQUALIFIER_RSHIFT))
									DirectChoice(app, code - 48 + 10);
								else if (qualifier & (IEQUALIFIER_LALT | IEQUALIFIER_RALT))
									DirectChoice(app, code - 48 + 20);
								else
									DirectChoice(app, code - 48);
								break;
							case '0':
								if (qualifier & (IEQUALIFIER_LSHIFT | IEQUALIFIER_RSHIFT))
									DirectChoice(app, 20);
								else if (qualifier & (IEQUALIFIER_LALT | IEQUALIFIER_RALT))
									DirectChoice(app, 30);
								else
									DirectChoice(app, 10);
								break;
						}
						break;

					case IDCMP_GADGETUP:
						switch (gad->GadgetID)
						{
							case GADGET_MAIN_DIRECTCHOICE0: case GADGET_MAIN_DIRECTCHOICE0 + 1: case GADGET_MAIN_DIRECTCHOICE0 + 2: case GADGET_MAIN_DIRECTCHOICE0 + 3: case GADGET_MAIN_DIRECTCHOICE0 + 4: case GADGET_MAIN_DIRECTCHOICE0 + 5: case GADGET_MAIN_DIRECTCHOICE0 + 6: case GADGET_MAIN_DIRECTCHOICE0 + 7: case GADGET_MAIN_DIRECTCHOICE0 + 8: case GADGET_MAIN_DIRECTCHOICE0 + 9:
							case GADGET_MAIN_DIRECTCHOICE1: case GADGET_MAIN_DIRECTCHOICE1 + 1: case GADGET_MAIN_DIRECTCHOICE1 + 2: case GADGET_MAIN_DIRECTCHOICE1 + 3: case GADGET_MAIN_DIRECTCHOICE1 + 4: case GADGET_MAIN_DIRECTCHOICE1 + 5: case GADGET_MAIN_DIRECTCHOICE1 + 6: case GADGET_MAIN_DIRECTCHOICE1 + 7: case GADGET_MAIN_DIRECTCHOICE1 + 8: case GADGET_MAIN_DIRECTCHOICE1 + 9:
								DirectChoice(app, gad->GadgetID + 1 - GADGET_MAIN_DIRECTCHOICE0);
								break;

							case GADGET_MAIN_POPUP:
								OpenAppWin(app, WINDOW_TITLES);
								break;

							case GADGET_MAIN_TIMESWITCH:
								cdstr->timemode++;
								if (cdstr->timemode > TIMEMODE_ALLREM)
									cdstr->timemode = TIMEMODE_TRACKCUR;

								UpdateTimeGadget(app);
								break;

							case GADGET_MAIN_PLAYMODE:
								i = cdstr->playmode;

								switch (code)
								{
									case 0:
										cdstr->playmode = PLAYMODE_CD;
										cdstr->playrandom = FALSE;
										break;
									case 1:
										cdstr->playmode = PLAYMODE_CD;
										cdstr->playrandom = TRUE;
										break;
									case 2:
										cdstr->playmode = PLAYMODE_PROGRAM;
										cdstr->playrandom = FALSE;
										break;
									case 3:
										cdstr->playmode = PLAYMODE_PROGRAM;
										cdstr->playrandom = TRUE;
										break;
								}

								/* Wenn sich der playmode geändert hat */
								if (app->appwin[WINDOW_TITLES].window && cdstr->playmode != i)
								{
									GT_SetGadgetAttrs(app->appwin[WINDOW_TITLES].gadget[GADGET_TITLES_LISTVIEW], app->appwin[WINDOW_TITLES].window, NULL, GTLV_Labels, NULL, TAG_END);
									GT_SetGadgetAttrs(app->appwin[WINDOW_TITLES].gadget[GADGET_TITLES_LISTVIEW], app->appwin[WINDOW_TITLES].window, NULL, GTLV_Labels, cdstr->playlist[cdstr->playmode], TAG_END);
								}

								if ((cdstr->active == AUDIO_STAT_PLAYING) || (cdstr->active == AUDIO_STAT_PAUSED))
								{
									if (PlayListStart(cdstr))
									{
										if (cdstr->active == AUDIO_STAT_PAUSED)
											CDPauseA(cdstr->cdx, TRUE);
									}
									else
										CDStopA(cdstr->cdx);

									cdstr->useraction = TRUE;
								}
								break;

							case GADGET_MAIN_REPEATMODE:
								app->cdstr->repeatmode = code;
								break;

							case GADGET_MAIN_CDOUT:
								EjectButton(app);
								break;
							case GADGET_MAIN_JUMPBWRD:
								JumpBackwardButton(app);
								break;
							case GADGET_MAIN_JUMPFWRD:
								JumpForwardButton(app);
								break;
							case GADGET_MAIN_SRCHBWRD:
							case GADGET_MAIN_SRCHFWRD:
								searched = 0;
								if (cdstr->searchmode == SEARCHMODE_STANDARD)
								{
									backward_pressed = FALSE;
									forward_pressed = FALSE;
								}
								else
									CDFastModeA(cdstr->cdx, FASTMODE_OFF, app->cdstr->searchmode-1);
								break;
							case GADGET_MAIN_STOP:
								StopButton(app);
								break;
							case GADGET_MAIN_PAUSE:
								PauseButton(app);
								break;
							case GADGET_MAIN_PLAY:
								PlayButton(app);
								break;
						/*	case GADGET_MAIN_TRACKSLIDER:
								Trackslider(app, code);
								break;*/
						}
						break;

					case IDCMP_GADGETDOWN:
						switch (gad->GadgetID)
						{
							case GADGET_MAIN_SRCHBWRD:
								if (cdstr->searchmode == SEARCHMODE_STANDARD)
									backward_pressed = TRUE;
								else
								{
									CDFastModeA(cdstr->cdx, FASTMODE_BACKWARD, cdstr->searchmode - 1);
									searched = 1;
								}
								break;
							case GADGET_MAIN_SRCHFWRD:
								if (cdstr->searchmode == SEARCHMODE_STANDARD)
									forward_pressed = TRUE;
								else
								{
									CDFastModeA(cdstr->cdx, FASTMODE_FORWARD, cdstr->searchmode - 1);
									searched = 1;
								}
								break;
						}
						break;

					case IDCMP_MOUSEBUTTONS:
						if (code == SELECTUP)
						{
							if (cdstr->searchmode == SEARCHMODE_STANDARD)
							{
								backward_pressed = FALSE;
								forward_pressed = FALSE;
							}
							else if (searched)
								CDFastModeA(cdstr->cdx, FASTMODE_OFF, cdstr->searchmode - 1);
							searched = 0;
						}
						break;

					case IDCMP_CLOSEWINDOW:
						if (app->flag_tool & FLAG_TOOL_QUITONCLOSE)
						{
							done = TRUE;
						}
						else
						{
							Iconify(app);
							exitloop = TRUE;
						}
						break;

					case IDCMP_MOUSEMOVE:
						if (gad->GadgetID == GADGET_MAIN_TRACKSLIDER)
						{
							Trackslider(app, code);
						}
						break;

					case IDCMP_INTUITICKS:
						if (backward_pressed || forward_pressed)
						{
							WORD value;
							if (searched < 10)
								value = 2;
							else if (searched > 9 && searched < 20)
								value = 4;
							else if (searched > 19 && searched < 30)
								value = 8;
							else if (searched > 29 && searched < 40)
								value = 16;
							else if (searched > 39 && searched < 50)
								value = 32;
							else
								value = 64;

							searched++;

							if (backward_pressed) SearchBackwardButton(app, value);
							else SearchForwardButton(app, value);
						}

						/* Hier wird alles ziemlich aktualisiert.          */
						/* Ich denke, daß das ziemlich wichtig ist.		   */
						/* Man hat dann wirklich das Gefühl, daß schneller */
						/* gespult wird. */
						/* Ich hoffe, es ist nicht zu rechenzeitintensiv.. */
						/* Allerdings spult man ja auch nicht andauernd... */

						if (searched)
						{
							CDUpdateA(cdstr->cdx);
							UpdateGadgets(app);
						}
						break;
				}
				break;

			case WINDOW_ABOUT:		/* Über-Fenster */
				switch (class)
				{
					case IDCMP_GADGETUP:
					case IDCMP_CLOSEWINDOW:
						CloseAppWin(app, WINDOW_ABOUT, TRUE);
						exitloop = TRUE;	/* Damit nicht mehr auf den IDCMP zugegriffen
											wird, sprich, damit ACDPlay nicht abstürzt */
						break;

					case IDCMP_INTUITICKS:
						UpdateScrollObject(app->scroller, app->appwin[WINDOW_ABOUT].window);
						break;
				}
				break;

			case WINDOW_CDINFO:		/* CD-Fenster */
				switch (class)
				{
					case IDCMP_GADGETUP:
					case IDCMP_CLOSEWINDOW:
						CloseAppWin(app, WINDOW_CDINFO, TRUE);
						exitloop = TRUE;	/* Damit nicht mehr auf den IDCMP zugegriffen
											wird, sprich, damit ACDPlay nicht abstürzt */
						break;

					case IDCMP_NEWSIZE:
						ManageNewSize(app, WINDOW_CDINFO);
						break;
				}
				break;

			case WINDOW_DRIVEINFO:		/* Laufwerks-Fenster */
				switch (class)
				{
					case IDCMP_GADGETUP:
					case IDCMP_CLOSEWINDOW:
						CloseAppWin(app, WINDOW_DRIVEINFO, TRUE);
						exitloop = TRUE;	/* Damit nicht mehr auf den IDCMP zugegriffen
											wird, sprich, damit ACDPlay nicht abstürzt */
						break;

					case IDCMP_NEWSIZE:
						ManageNewSize(app, WINDOW_DRIVEINFO);
						break;
				}
				break;

			case WINDOW_PUBSCREEN:		/* Pubscreen-Fenster */
				switch (class)
				{
					case IDCMP_GADGETUP:
						switch (gad->GadgetID)
						{
							case GADGET_PUBSCREEN_LISTVIEW:
								{
									static ULONG startseconds, startmicros;

									if (DoubleClick(startseconds, startmicros, seconds, micros))
									{
										if (strcmp(app->pubscreenname, ((MyPubScreenNode *)FindNode(app->pubscreenlist, code))->mpsn_pubscreenname))
										{
											strcpy(app->pubscreenname, ((MyPubScreenNode *)FindNode(app->pubscreenlist, code))->mpsn_pubscreenname);
											CloseAppWin(app, WINDOW_PUBSCREEN, TRUE);
											CloseApplication(app);
											OpenApplication(app);
										}
										else CloseAppWin(app, WINDOW_PUBSCREEN, TRUE);
										exitloop = TRUE;
									}
									else
									{
										startseconds 	= seconds;
										startmicros	= micros;
									}
								}
								break;

							case GADGET_PUBSCREEN_UPDATE:
								GetPubScreenList(app);
								break;
						}
						break;
					case IDCMP_CLOSEWINDOW:
						CloseAppWin(app, WINDOW_PUBSCREEN, TRUE);
						exitloop = TRUE;	/* Damit nicht mehr auf den IDCMP zugegriffen
											wird, sprich, damit ACDPlay nicht abstürzt */
						break;
					case IDCMP_NEWSIZE:
						ManageNewSize(app, WINDOW_PUBSCREEN);
						break;
				}
				break;

			case WINDOW_TITLES:		/* Titelauswahl-Fenster */
				switch (class)
				{
					case IDCMP_GADGETUP:
						{
							static ULONG startseconds, startmicros;

							/* aktives Element wiederherstellen */
							if (cdstr->active == AUDIO_STAT_PLAYING || cdstr->active == AUDIO_STAT_PAUSED)
								GT_SetGadgetAttrs(app->appwin[WINDOW_TITLES].gadget[GADGET_TITLES_LISTVIEW], actwin, NULL, GTLV_Selected, GetNodeNumber(cdstr->playlist[cdstr->playmode], (struct Node *)cdstr->currentlyplayed), TAG_END);
							if (cdstr->active == AUDIO_STAT_STOPPED)
								GT_SetGadgetAttrs(app->appwin[WINDOW_TITLES].gadget[GADGET_TITLES_LISTVIEW], actwin, NULL, GTLV_Selected, 0xFFFF, TAG_END);

							if (DoubleClick(startseconds, startmicros, seconds, micros))
							{
								if (cdstr->active != AUDIO_STAT_NO_DISK)
								{
									cdstr->currentlyplayed = (struct PlayListNode *)FindNode(cdstr->playlist[cdstr->playmode], code);
									if (CDPlayA(cdstr->cdx, cdstr->currentlyplayed->pln_track, 1) == RETURN_OK)
										if (cdstr->active == AUDIO_STAT_PAUSED)
											CDPauseA(cdstr->cdx, TRUE);

									cdstr->useraction = TRUE;
								}
							}
							else
							{
								startseconds 	= seconds;
								startmicros	= micros;
							}
						}
						break;

					case IDCMP_RAWKEY:
						switch (code)
						{
							case 76:	/* Cursor hoch */
								JumpBackwardButton(app);
								break;
							case 77:	/* Cursor runter */
								JumpForwardButton(app);
								break;
						}
						break;

					case IDCMP_CLOSEWINDOW:
						CloseAppWin(app, WINDOW_TITLES, TRUE);
						exitloop = TRUE;	/* Damit nicht mehr auf den IDCMP zugegriffen
											wird, sprich, damit ACDPlay nicht abstürzt */
						break;

					case IDCMP_NEWSIZE:
						ManageNewSize(app, WINDOW_TITLES);
						break;
				}
				break;

			case WINDOW_EDIT:		/* Titeleingabe-Fenster */
				switch (class)
				{
					case IDCMP_GADGETUP:
						{
							SHORT anzvisible;		/* Wieviele Einträge im LV zu sehen */

							switch(gad->GadgetID)	/* Eintrag merken */
							{
								case GADGET_EDIT_TITLE:
									if (app->appwin[WINDOW_CDINFO].window)
										GT_SetGadgetAttrs(app->appwin[WINDOW_CDINFO].gadget[GADGET_CDINFO_TITLE], app->appwin[WINDOW_CDINFO].window, NULL, GTTX_Text, NULL, TAG_END);
									strncpy(cdstr->cdname, ((struct StringInfo *)gad->SpecialInfo)->Buffer, MAXCDNAME);
									if (app->appwin[WINDOW_CDINFO].window)
										GT_SetGadgetAttrs(app->appwin[WINDOW_CDINFO].gadget[GADGET_CDINFO_TITLE], app->appwin[WINDOW_CDINFO].window, NULL, GTTX_Text, cdstr->cdname, TAG_END);
									break;
								case GADGET_EDIT_ARTIST:
									if (app->appwin[WINDOW_CDINFO].window)
										GT_SetGadgetAttrs(app->appwin[WINDOW_CDINFO].gadget[GADGET_CDINFO_AUTHOR], app->appwin[WINDOW_CDINFO].window, NULL, GTTX_Text, NULL, TAG_END);
									strncpy(cdstr->artistname, ((struct StringInfo *)gad->SpecialInfo)->Buffer, MAXARTISTNAME);
									if (app->appwin[WINDOW_CDINFO].window)
										GT_SetGadgetAttrs(app->appwin[WINDOW_CDINFO].gadget[GADGET_CDINFO_AUTHOR], app->appwin[WINDOW_CDINFO].window, NULL, GTTX_Text, cdstr->artistname, TAG_END);
									break;
								case GADGET_EDIT_LISTVIEW:
									if (app->appwin[WINDOW_EDIT].gadget[GADGET_EDIT_TRACKTITLE]->Flags & GFLG_DISABLED)
										GT_SetGadgetAttrs(app->appwin[WINDOW_EDIT].gadget[GADGET_EDIT_TRACKTITLE], app->appwin[WINDOW_EDIT].window, NULL, GA_Disabled, FALSE, TAG_END);
									ActivateGadget(app->appwin[WINDOW_EDIT].gadget[GADGET_EDIT_TRACKTITLE], app->appwin[WINDOW_EDIT].window, NULL);

									/* String ggf. löschen */
									if (IsDefaultTitle(((struct StringInfo *)app->appwin[WINDOW_EDIT].gadget[GADGET_EDIT_TRACKTITLE]->SpecialInfo)->Buffer, code + 1))
										GT_SetGadgetAttrs(app->appwin[WINDOW_EDIT].gadget[GADGET_EDIT_TRACKTITLE], app->appwin[WINDOW_EDIT].window, NULL, GTST_String, NULL, TAG_END);

									app->edit_pos = code;
									break;
								case GADGET_EDIT_TRACKTITLE:
									/* Titel-Gadget in WINDOW_MAIN */
									if (app->appwin[WINDOW_MAIN].gadget[GADGET_MAIN_TITLESHOW] && (app->edit_pos + 1) == cdstr->cur_track)
										GT_SetGadgetAttrs(app->appwin[WINDOW_MAIN].gadget[GADGET_MAIN_TITLESHOW], app->appwin[WINDOW_MAIN].window, NULL, GTTX_Text, NULL, TAG_END);
									/* Listen */
									if (app->appwin[WINDOW_TITLES].window)
										GT_SetGadgetAttrs(app->appwin[WINDOW_TITLES].gadget[GADGET_TITLES_LISTVIEW], app->appwin[WINDOW_TITLES].window, NULL, GTLV_Labels, ~0, TAG_END);
									GT_SetGadgetAttrs(app->appwin[WINDOW_EDIT].gadget[GADGET_EDIT_LISTVIEW], app->appwin[WINDOW_EDIT].window, NULL, GTLV_Labels, ~0, TAG_END);
									if (app->appwin[WINDOW_PROGRAM].window)
									{
										GT_SetGadgetAttrs(app->appwin[WINDOW_PROGRAM].gadget[GADGET_PROGRAM_LVCD], app->appwin[WINDOW_PROGRAM].window, NULL, GTLV_Labels, ~0, TAG_END);
										GT_SetGadgetAttrs(app->appwin[WINDOW_PROGRAM].gadget[GADGET_PROGRAM_LVPRG], app->appwin[WINDOW_PROGRAM].window, NULL, GTLV_Labels, ~0, TAG_END);
									}
									strncpy(cdstr->tracknames[app->edit_pos], ((struct StringInfo *)gad->SpecialInfo)->Buffer, MAXTITLENAME);
									/* Listen */
									if (app->appwin[WINDOW_TITLES].window)
										GT_SetGadgetAttrs(app->appwin[WINDOW_TITLES].gadget[GADGET_TITLES_LISTVIEW], app->appwin[WINDOW_TITLES].window, NULL, GTLV_Labels, cdstr->playlist[cdstr->playmode], TAG_END);
									GT_SetGadgetAttrs(app->appwin[WINDOW_EDIT].gadget[GADGET_EDIT_LISTVIEW], app->appwin[WINDOW_EDIT].window, NULL, GTLV_Labels, cdstr->playlist[PLAYLIST_CD], TAG_END);
									if (app->appwin[WINDOW_PROGRAM].window)
									{
										GT_SetGadgetAttrs(app->appwin[WINDOW_PROGRAM].gadget[GADGET_PROGRAM_LVCD], app->appwin[WINDOW_PROGRAM].window, NULL, GTLV_Labels, cdstr->playlist[PLAYLIST_CD], TAG_END);
										GT_SetGadgetAttrs(app->appwin[WINDOW_PROGRAM].gadget[GADGET_PROGRAM_LVPRG], app->appwin[WINDOW_PROGRAM].window, NULL, GTLV_Labels, cdstr->playlist[PLAYLIST_PROGRAM], TAG_END);
									}
									/* Titel-Gadget in WINDOW_MAIN */
									if (app->appwin[WINDOW_MAIN].gadget[GADGET_MAIN_TITLESHOW] && (app->edit_pos + 1) == cdstr->cur_track)
										GT_SetGadgetAttrs(app->appwin[WINDOW_MAIN].gadget[GADGET_MAIN_TITLESHOW], app->appwin[WINDOW_MAIN].window, NULL, GTTX_Text, cdstr->tracknames[cdstr->cur_track - 1], TAG_END);

									if (app->edit_pos + 1 < cdstr->num_track)
									{
										app->edit_pos++;

										anzvisible = (app->appwin[WINDOW_EDIT].maxsize[HEIGHT] - YOFFSET - 4 * BUTTONHEIGHT - 4 * INTERHEIGHT - 2 - 4) / app->font->ta_YSize;

										GT_SetGadgetAttrs(app->appwin[WINDOW_EDIT].gadget[GADGET_EDIT_LISTVIEW], app->appwin[WINDOW_EDIT].window, NULL, GTLV_Selected, app->edit_pos, TAG_END);
										if (app->edit_pos > anzvisible - 1)
											GT_SetGadgetAttrs(app->appwin[WINDOW_EDIT].gadget[GADGET_EDIT_LISTVIEW], app->appwin[WINDOW_EDIT].window, NULL, GTLV_Top, app->edit_pos - anzvisible + 1, TAG_END);
										ActivateGadget(app->appwin[WINDOW_EDIT].gadget[GADGET_EDIT_TRACKTITLE], app->appwin[WINDOW_EDIT].window, NULL);

										/* String ggf. löschen */
										if (IsDefaultTitle(((struct StringInfo *)app->appwin[WINDOW_EDIT].gadget[GADGET_EDIT_TRACKTITLE]->SpecialInfo)->Buffer, app->edit_pos + 1))
											GT_SetGadgetAttrs(app->appwin[WINDOW_EDIT].gadget[GADGET_EDIT_TRACKTITLE], app->appwin[WINDOW_EDIT].window, NULL, GTST_String, NULL, TAG_END);
									}
									break;

								case GADGET_EDIT_SAVE:
									if (SaveTitles(app))
									{
										CloseAppWin(app, WINDOW_EDIT, TRUE);
										exitloop = TRUE;
									}
									else
										ShowMsgA(ls[MSG_ERROR_TITLE], ls[MSG_NOSAVE_TITLES], NULL);

									break;
							}
							if (gad->GadgetID == GADGET_EDIT_TITLE || gad->GadgetID == GADGET_EDIT_ARTIST)
							{
								/* Window-Titel updaten */
								UpdateWinTitle(app);
							}
						}
						break;
					case IDCMP_CLOSEWINDOW:
						CloseAppWin(app, WINDOW_EDIT, TRUE);
						exitloop = TRUE;	/* Damit nicht mehr auf den IDCMP zugegriffen
											wird, sprich, damit ACDPlay nicht abstürzt */
						break;

					case IDCMP_NEWSIZE:
						ManageNewSize(app, WINDOW_EDIT);
						break;
				}
				break;

			case WINDOW_PROGRAM:		/* Programmierfenster */
				switch (class)
				{
					case IDCMP_GADGETUP:
						switch(gad->GadgetID)
						{
							case GADGET_PROGRAM_LVCD:
								{
									static ULONG startseconds, startmicros;

									if (DoubleClick(startseconds, startmicros, seconds, micros))
										ProgramAppendElement(app, code + 1);
									else
									{
										startseconds 	= seconds;
										startmicros		= micros;
									}
								}
								break;

							case GADGET_PROGRAM_LVPRG:
								{
									static ULONG startseconds, startmicros;

									if (DoubleClick(startseconds, startmicros, seconds, micros))
										ProgramDeleteElement(app, code);
									else
									{
										startseconds 	= seconds;
										startmicros	= micros;
									}
								}
								break;

							case GADGET_PROGRAM_COPYALL:
								ProgramCopyAll(app);
								break;
							case GADGET_PROGRAM_DEL:
								ProgramDelete(app);
								break;
							case GADGET_PROGRAM_LOAD:
								ProgramLoad(app);
								break;
							case GADGET_PROGRAM_SAVE:
								if (!ProgramSave(app))
									ShowMsgA(ls[MSG_ERROR_TITLE], ls[MSG_NOSAVE_PROGRAM], NULL);
								break;
						}
						break;
					case IDCMP_CLOSEWINDOW:
						CloseAppWin(app, WINDOW_PROGRAM, TRUE);
						exitloop = TRUE;
						break;

					case IDCMP_NEWSIZE:
						ManageNewSize(app, WINDOW_PROGRAM);
						break;
				}
				break;

			case WINDOW_VOLUME:
				switch (class)
				{
					case IDCMP_MOUSEMOVE:
						switch (gad->GadgetID)
						{
							case GADGET_VOLUME_LEFT:
								cdstr->cdx->cdx_Volume[0] = code;
								break;
							case GADGET_VOLUME_RIGHT:
								cdstr->cdx->cdx_Volume[1] = code;
								break;
							case GADGET_VOLUME_MASTER:
								{
									/* Differenz die für links/rechts zum Masterslider addiert/subtrahiert wird */
									WORD diff = (code && code!=255)?(cdstr->cdx->cdx_Volume[0] - cdstr->cdx->cdx_Volume[1])/2:0;
									cdstr->cdx->cdx_Volume[0] = (cdstr->cdx->cdx_Flags & SPECIALF_ATAPI)?(UBYTE)code:(UBYTE)FitInteger(code + diff, 0, 255);
									cdstr->cdx->cdx_Volume[1] = (cdstr->cdx->cdx_Flags & SPECIALF_ATAPI)?(UBYTE)code:(UBYTE)FitInteger(code - diff, 0, 255);
									GT_SetGadgetAttrs(app->appwin[WINDOW_VOLUME].gadget[GADGET_VOLUME_LEFT], app->appwin[WINDOW_VOLUME].window, NULL, GTSL_Level, cdstr->cdx->cdx_Volume[0], TAG_END);
									GT_SetGadgetAttrs(app->appwin[WINDOW_VOLUME].gadget[GADGET_VOLUME_RIGHT], app->appwin[WINDOW_VOLUME].window, NULL, GTSL_Level, cdstr->cdx->cdx_Volume[1], TAG_END);
								}
								break;
						}
						if (gad->GadgetID != GADGET_VOLUME_MASTER)
							GT_SetGadgetAttrs(app->appwin[WINDOW_VOLUME].gadget[GADGET_VOLUME_MASTER], app->appwin[WINDOW_VOLUME].window, NULL, GTSL_Level, (app->cdstr->cdx->cdx_Volume[0]+app->cdstr->cdx->cdx_Volume[1])/2, TAG_END);

						CDVolumeA(cdstr->cdx, SET_VOLUME);
						break;
					case IDCMP_CLOSEWINDOW:
						CloseAppWin(app, WINDOW_VOLUME, TRUE);
						exitloop = TRUE;
						break;
					case IDCMP_NEWSIZE:
						ManageNewSize(app, WINDOW_VOLUME);
						/* RefreshGList() reicht nicht */
						GT_RefreshWindow(app->appwin[WINDOW_VOLUME].window, NULL);
						break;
				}
				break;

			case WINDOW_AB:
				switch (class)
				{
					case IDCMP_GADGETUP:
						switch(gad->GadgetID)
						{
							case GADGET_AB_A:
								CDUpdateA(cdstr->cdx);
								cdstr->a_track	= cdstr->cdx->cdx_CurrentTrack;
								cdstr->a_adr	= cdstr->cdx->cdx_CurrentRelAddr + cdstr->cdx->cdx_TOCData->Entry[cdstr->a_track].Address;
								break;
							case GADGET_AB_B:
								CDUpdateA(cdstr->cdx);
								cdstr->b_track	= cdstr->cdx->cdx_CurrentTrack;
								cdstr->b_adr	= cdstr->cdx->cdx_CurrentRelAddr + cdstr->cdx->cdx_TOCData->Entry[cdstr->b_track].Address;
								break;
							case GADGET_AB_A_TIME:
							case GADGET_AB_B_TIME:
								{
									char *str = (char *)((struct StringInfo *)gad->SpecialInfo)->Buffer;
									short mins, secs, frms;

									str[2] = 0;
									mins = FitInteger(atoi(str), 0, 99);
									str[5] = 0;
									secs = FitInteger(atoi(str + 3), 0, 59);
									frms = FitInteger(atoi(str + 6), 0, 74);

									if (gad->GadgetID == GADGET_AB_A_TIME)
										cdstr->a_adr = FitInteger(mins * 60 * 75 + secs * 75 + frms, 0, cdstr->cdx->cdx_TOCData->Entry[cdstr->a_track + 1].Address - cdstr->cdx->cdx_TOCData->Entry[cdstr->a_track].Address) + cdstr->cdx->cdx_TOCData->Entry[cdstr->a_track].Address;
									else
										cdstr->b_adr = FitInteger(mins * 60 * 75 + secs * 75 + frms, 0, cdstr->cdx->cdx_TOCData->Entry[cdstr->b_track + 1].Address - cdstr->cdx->cdx_TOCData->Entry[cdstr->b_track].Address) + cdstr->cdx->cdx_TOCData->Entry[cdstr->b_track].Address;
								}
								break;
							case GADGET_AB_A_TRACK:
							case GADGET_AB_B_TRACK:
								{
									short entry = FitInteger(((struct StringInfo *)gad->SpecialInfo)->LongInt, 1, cdstr->num_track);

									/* Überprüfen, ob die Zeit-Angabe noch stimmt */
									if (gad->GadgetID == GADGET_AB_A_TRACK)
									{
										cdstr->a_adr = FitInteger(cdstr->a_adr - cdstr->cdx->cdx_TOCData->Entry[cdstr->a_track].Address, 0, cdstr->cdx->cdx_TOCData->Entry[entry + 1].Address - cdstr->cdx->cdx_TOCData->Entry[entry].Address) + cdstr->cdx->cdx_TOCData->Entry[entry].Address;
										cdstr->a_track = entry;
									}
									else
									{
										cdstr->b_adr = FitInteger(cdstr->b_adr - cdstr->cdx->cdx_TOCData->Entry[cdstr->b_track].Address, 0,  cdstr->cdx->cdx_TOCData->Entry[entry + 1].Address - cdstr->cdx->cdx_TOCData->Entry[entry].Address) + cdstr->cdx->cdx_TOCData->Entry[entry].Address;
										cdstr->b_track = entry;
									}
								}
								break;
						}

						/* Anzeigen aktualisieren */
						DoABBuffer(app);
						DoSizeBuffer(app);
						break;

					case IDCMP_CLOSEWINDOW:
						CloseAppWin(app, WINDOW_AB, TRUE);
						exitloop = TRUE;
						break;
					case IDCMP_NEWSIZE:
						{
							/* Alles retten */
							char time_a[9], time_b[9];
							UBYTE track_a = ((struct StringInfo *)app->appwin[WINDOW_AB].gadget[GADGET_AB_A_TRACK]->SpecialInfo)->LongInt;
							UBYTE track_b = ((struct StringInfo *)app->appwin[WINDOW_AB].gadget[GADGET_AB_B_TRACK]->SpecialInfo)->LongInt;
							strcpy(time_a, ((struct StringInfo *)app->appwin[WINDOW_AB].gadget[GADGET_AB_A_TIME]->SpecialInfo)->Buffer);
							strcpy(time_b, ((struct StringInfo *)app->appwin[WINDOW_AB].gadget[GADGET_AB_B_TIME]->SpecialInfo)->Buffer);

							ManageNewSize(app, WINDOW_AB);

							/* Alles restaurieren */
							GT_SetGadgetAttrs(app->appwin[WINDOW_AB].gadget[GADGET_AB_A_TRACK], app->appwin[WINDOW_AB].window, NULL, GTIN_Number, track_a, TAG_END);
							GT_SetGadgetAttrs(app->appwin[WINDOW_AB].gadget[GADGET_AB_B_TRACK], app->appwin[WINDOW_AB].window, NULL, GTIN_Number, track_b, TAG_END);
							GT_SetGadgetAttrs(app->appwin[WINDOW_AB].gadget[GADGET_AB_A_TIME], app->appwin[WINDOW_AB].window, NULL, GTST_String, time_a, TAG_END);
							GT_SetGadgetAttrs(app->appwin[WINDOW_AB].gadget[GADGET_AB_B_TIME], app->appwin[WINDOW_AB].window, NULL, GTST_String, time_b, TAG_END);
						}
						break;
				}
				break;

			case WINDOW_SAVEAUDIO:		/* Audio-Save-Fenster */
				switch (class)
				{
					case IDCMP_GADGETUP:
						switch(gad->GadgetID)
						{
							case GADGET_SAVEAUDIO_FORMAT:
								cdstr->fileformat = code;
								break;

							case GADGET_SAVEAUDIO_FILENAME:
								strcpy(app->appasl[ASL_SAVEAUDIO].pathname, ((struct StringInfo *)app->appwin[WINDOW_SAVEAUDIO].gadget[GADGET_SAVEAUDIO_FILENAME]->SpecialInfo)->Buffer);

								/* In Ordner- und Dateiname zerlegen */
								strncpy(app->appasl[ASL_SAVEAUDIO].filename, FilePart(app->appasl[ASL_SAVEAUDIO].pathname), FILENAMELENGTH);
								i = (int)(PathPart(app->appasl[ASL_SAVEAUDIO].pathname) - (STRPTR)app->appasl[ASL_SAVEAUDIO].pathname);
								strncpy(app->appasl[ASL_SAVEAUDIO].dirname, app->appasl[ASL_SAVEAUDIO].pathname, i);

								/* dirname hat noch kein Nullzeichen... */
								app->appasl[ASL_SAVEAUDIO].dirname[i] = 0;
								break;

							case GADGET_SAVEAUDIO_GETFILE:
								if (GetFileName(&app->appasl[ASL_SAVEAUDIO], app->screen))
									 GT_SetGadgetAttrs(app->appwin[WINDOW_SAVEAUDIO].gadget[GADGET_SAVEAUDIO_FILENAME], app->appwin[WINDOW_SAVEAUDIO].window, NULL, GTST_String, app->appasl[ASL_SAVEAUDIO].pathname, TAG_END);
								break;

							case GADGET_SAVEAUDIO_SAVE:
								/* Überprüfen, ob noch genug Platz ist */
								if (CalcAudioSize(cdstr->a_adr, cdstr->b_adr, 44100) <= ExamineDiskSpace(app->appasl[ASL_SAVEAUDIO].dirname)) {
										CopyRange(app);
								}
								else {
										struct EasyStruct req = {
												sizeof(struct EasyStruct),	/* es_StructSize */
												0,							/* es_Flags */
												ls[MSG_WARNING_TITLE],		/* es_Title */
												ls[MSG_NO_DISKSPACE],		/* es_TextFormat */
												ls[MSG_YESNO_REQ] };		/* es_GadFormat */

										if (EasyRequestArgs(NULL, &req, NULL, NULL))
												CopyRange(app);
								}
								break;
						}
						break;

					case IDCMP_CLOSEWINDOW:
						CloseAppWin(app, WINDOW_SAVEAUDIO, TRUE);
						exitloop = TRUE;	/* Damit nicht mehr auf den IDCMP zugegriffen
											wird, sprich, damit ACDPlay nicht abstürzt */
						break;
					case IDCMP_NEWSIZE:
						{
							char tempstr[DISKPATHLENGTH + 1];
							strcpy(tempstr, ((struct StringInfo *)app->appwin[WINDOW_SAVEAUDIO].gadget[GADGET_SAVEAUDIO_FILENAME]->SpecialInfo)->Buffer);
							ManageNewSize(app, WINDOW_SAVEAUDIO);
							GT_SetGadgetAttrs(app->appwin[WINDOW_SAVEAUDIO].gadget[GADGET_SAVEAUDIO_FILENAME], app->appwin[WINDOW_SAVEAUDIO].window, NULL, GTST_String, tempstr, TAG_END);
						}
						break;
				}
				break;

			case WINDOW_SAVING:		/* Zustandsanzeige für Audiosaving */
				switch (class)
				{
					case IDCMP_GADGETUP:
						switch(gad->GadgetID)
						{
							case GADGET_SAVING_CANCEL:
								CloseAppWin(app, WINDOW_SAVING, TRUE);
								exitloop = TRUE;
								break;
						}
						break;
				}
				break;
		}

		if (exitloop || done) break;		/* while-Schleife gegebenenfalls beenden */
	}
	return (done);
}

BOOL HandleCommodityEvents(Application *app)
{
	CxMsg 	*cmsg;
	ULONG 	msgid, msgtype;
	static  UWORD delaycount = 0;
	BOOL 	done = FALSE;

	while (cmsg = (CxMsg *)GetMsg(app->broker_mp))
	{
		msgid = CxMsgID(cmsg);				/* Informationen auslesen, damit die */
		msgtype = CxMsgType(cmsg);			/* Message möglichst schnell beantwortet */
		ReplyMsg((struct Message *)cmsg);	/* werden kann... */

		switch (msgtype)
		{
			case CXM_COMMAND:			/* Ein Kommando wurde gesandt */
				switch (msgid)
				{
					case CXCMD_DISABLE:	/* Abschalten */
						ActivateCxObj(app->broker, 0L);
						break;
					case CXCMD_ENABLE:	/* Anschalten */
						ActivateCxObj(app->broker, 1L);
						CDReadTOCA(app->cdstr->cdx);
						CDUpdateA(app->cdstr->cdx);
						break;
					case CXCMD_KILL:	/* Entfernen */
						done = TRUE;
						break;
					case CXCMD_APPEAR:	/* Fenster öffnen */
						UnIconify(app);
						break;
					case CXCMD_DISAPPEAR:	/* Fenster schließen */
						Iconify(app);
						break;
				}
				break;
			case CXM_IEVENT:
				switch (msgid)
				{
					case EVENT_HOTKEYPRESSED:
						if (app->screen == NULL)
							UnIconify(app);
						else
							switch (app->hotkeymode)
							{
								case HOTKEYMODE_SCREENTOFRONT:
									OpenApplication(app);
									break;
								case HOTKEYMODE_FRONTMOST:
									{
										/* Zuerst locken... */
										ULONG lockreturn = LockIBase(0);

										if (((struct IntuitionBase *)IntuitionBase)->FirstScreen == app->screen)
											OpenApplication(app);
										else
										{
											if (GetPubScreenName(((struct IntuitionBase *)IntuitionBase)->FirstScreen, app->pubscreenname))
											{
												/* Hier wird zuerst der Screenname überschrieben, und dann die Application */
												/* geschlossen. Ich hoffe, das ist in Ordnung... */
												CloseApplication(app);
												OpenApplication(app);
											}
											else
											{
												DisplayBeep(((struct IntuitionBase *)IntuitionBase)->FirstScreen);
											}
										}
										UnlockIBase(lockreturn);
									}
									break;
								case HOTKEYMODE_HIDE:
									Iconify(app);
									break;
							}
						break;
					case EVENT_TIMER:
						if (++delaycount == app->cdstr->updatedelay)
						{
							/* Sicherheitshalber, damit die Diskdaten in jedem Fall stimmen */
							if (app->cdstr->updatedelay > 30)
								CDReadTOCA(app->cdstr->cdx);
							CDUpdateA(app->cdstr->cdx);
							UpdateGadgets(app);

							delaycount = 0;
						}
						break;
				}
				break;
		}
	}
	return (done);
}

void HandleScreenNotify(Application *app)
{
	struct ScreenNotifyMessage *smsg;

	while (smsg = (struct ScreenNotifyMessage *)GetMsg(app->scrnotify_mp))
	{
		if ((smsg->snm_Type == SCREENNOTIFY_TYPE_WORKBENCH) && (app->Flags & APPF_WORKBENCH))
			if (smsg->snm_Value)
			{
				/* Nur öffnen wenn auch durch CloseWorkBench() geschlossen */
				if ((!app->screen) && (app->Flags & APPF_SNCLOSED))
				{
					/* öffnen ohne zu aktivieren */
					OpenApplication(app, FALSE);
					/* Application ist jetzt wieder offen: */
					/* Flag wird in OpenApplication gelöscht */
				}
			}
			else
			{
				if (app->screen)
				{
					CloseApplication(app);
					/* Application wurde durch CloseWorkBench() geschlossen: */
					/* Kann also durch OpenWorkBench() wieder geöffnet werden */
					app->Flags |= APPF_SNCLOSED;
				}
			}

		/* Erst antworten wenn alle Fenster geschlossen/offen sind */
		ReplyMsg((struct Message *)smsg);
	}
}

void HandleAppItemEvents(struct Application *app)
{
	struct AppMessage *appmsg	= NULL;
	LONG num;

	while (appmsg = (struct AppMessage *)GetMsg(app->appitem_mp))
	{
		num = appmsg->am_NumArgs;
		ReplyMsg((struct Message *)appmsg);

		if (!num)
		{
			UnIconify(app);
			break;
		}
	}
}