#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <string.h>
#include <proto/exec.h>
#include <proto/dos.h>
#include <proto/intuition.h>
#include <proto/graphics.h>
#include <proto/gadtools.h>
#include <proto/asl.h>
#include <proto/diskfont.h>
#include <proto/iffparse.h>
#include <proto/utility.h>
#include <exec/execbase.h>
#include <exec/memory.h>
#include <devices/prtbase.h>
#include <devices/printer.h>
#include <graphics/gfxbase.h>
#include <graphics/videocontrol.h>
#include <intuition/intuition.h>
#include <intuition/gadgetclass.h>
// #include <iffp/ilbmapp.h>

#define VERSION  "FlashMandel 1.0ß"      /* ß = LALT + 223 NumPad */
#define BY       " by "
#define AUTHOR   "Dino Papararo"
#define DATE     " (13.06.96)"
#define ADDRESS  "         Via Manzoni 184\n\n        80123 Napoli Italia"

// #define __USE_SYSBASE

#define LIBVER   37L

#define RAW_ESC      0x045
#define VAN_ESC      0x01B
#define TAB          0x042

#define FIXED_POINT      (26L)                /* Bit di Precisione */
#define HALF_FIXED_POINT (FIXED_POINT >> 1L)
#define MAX_POT          (1L << FIXED_POINT)  /*   2^FIXED_POINT   */

#define MINLIMIT 2

#define NERO     0
#define BIANCO   31
#define BLU      30
#define ROSSO    19
#define GIALLO   13
#define VERDE    7
#define VIOLA    25
#define CIANO    1

#define PUNTI    4

#define INITIALZOOMDIM 2

#define ZPW      15
#define ZPH      15
#define ZPXO     -8
#define ZPYO     -7

#define ZZZPW    16
#define ZZZPH    16
#define ZZZPXO   -6
#define ZZZPYO   -0

#define ACCEPT       (1)
#define PROPORTIONAL (2)
#define CANCEL       (3)

#define TOODEEP      4
#define ATTACHFAIL   5
#define NOTAVAILABLE 6
#define FDIFAIL      7
#define GDIFAIL      8
#define FONTFAIL     9
#define NOMONITOR    10
#define LOWMODEL     11
#define NOMEM        12
#define NOCHIPMEM    13
#define PUBNOTUNIQUE 14
#define UNKNOWNMODE  15
#define WINDOWFAIL   16
#define MENUFAIL     17
#define RASTFAIL     18
#define VINFOFAIL    19
#define GADGETFAIL   20
#define ALLOCIFFFAIL 21
#define OPENFILEFAIL 22
#define OPENLIBFAIL  23
#define UNKNOWNERROR 31

#define LOAD_MSG        0x1
#define SAVE_MSG        0x2
#define DUMP_MSG        0x4
#define REDRAW_MSG      0x8
#define UNDO_MSG        0x10
#define DRAW_MSG        0x20
#define PREVIEW_MSG     0x40
#define NEWDISPLAY_MSG  0x80
#define STOP_MSG        0x100
#define EXIT_MSG        0x200
#define COORDS_MSG      0x400
#define ITER_MSG        0x800
#define ABOUT_MSG       0x1000
#define TITLE_MSG       0x2000

#define IDCMP_STANDARD  IDCMP_RAWKEY|IDCMP_MOUSEBUTTONS|IDCMP_MOUSEMOVE|IDCMP_MENUPICK

TEXT VERSION_STRING [] = "$VER: " VERSION DATE BY AUTHOR;

BOOL TITLE = TRUE , NEWPICTURE = TRUE , A_SCROLL = FALSE;

UBYTE COMMAND [125] , PATH [90] , BAR_MESSAGE [40];

WORD COORDINATE [PUNTI << 1] , PRIORITY = 0 , WIDTH = STDSCREENWIDTH , HEIGHT = STDSCREENHEIGHT;

UWORD DEPTH = 8 , OVERSCAN = OSCAN_TEXT;

ULONG ITERAZIONI = 255L , DISPLAY = LORES_KEY;

DOUBLE UX1=-2.0,X1=-2.0,UX2=1.0,X2=1.0,UY1=-1.20,Y1=-1.20,UY2=1.20,Y2=1.20,Sx=0,Sy=0,Cre=0,Cim=0;

APTR VINFO = 0L;

ULONG (*FUNCTION) (ULONG,DOUBLE,DOUBLE);

UBYTE *FontError              = "\x00\x64\x20" "Font Failed" "\x00";
UBYTE *NoMonitor              = "\x00\x64\x20" "No Monitor" "\x00";
UBYTE *NoChips                = "\x00\x64\x20" "No Chips" "\x00";
UBYTE *NoMem                  = "\x00\x64\x20" "No Mem" "\x00";
UBYTE *NoChipMem              = "\x00\x64\x20" "No ChipMem" "\x00";
UBYTE *PubNotUnique           = "\x00\x64\x20" "Pub Not Unique" "\x00";
UBYTE *UnknownMode            = "\x00\x64\x20" "Unknown Mode" "\x00";
UBYTE *ScreenTooDeep          = "\x00\x64\x20" "Screen Too Deep" "\x00";
UBYTE *AttachScreen           = "\x00\x64\x20" "Attach Screen Failed" "\x00";
UBYTE *ModeNotAvailableError  = "\x00\x64\x20" "Mode Not Available" "\x00";
UBYTE *UnknownScrError        = "\x00\x64\x20" "Unknown Screen Error" "\x00";
UBYTE *VisualInfoError        = "\x00\x64\x20" "VisualInfo Failed" "\x00";
UBYTE *WindowError            = "\x00\x64\x20" "OpenWindow Failed" "\x00";
UBYTE *MinKickVer             = "\x00\x64\x20" "Sorry !!! I need O.S. 2.1+ to work !" "\x00";
UBYTE *IntuitionLibrary       = "\x00\x64\x20" "Intuition.library Error" "\x00";
UBYTE *GraphicsLibrary        = "\x00\x64\x20" "Graphics.library Error" "\x00";
UBYTE *DosLibrary             = "\x00\x64\x20" "Dos.library Error" "\x00";
UBYTE *DiskfontLibrary        = "\x00\x64\x20" "Diskfont.library Error" "\x00";
UBYTE *GadToolsLibrary        = "\x00\x64\x20" "GadTools.library Error" "\x00";
UBYTE *AslLibrary             = "\x00\x64\x20" "Asl.library Error: I need V38+" "\x00";
UBYTE *IFFParseLibrary        = "\x00\x64\x20" "IFFParse.library Error" "\x00";
UBYTE *UtilityLibrary         = "\x00\x64\x20" "Utility.library Error" "\x00";
UBYTE *MathIeeeDoubBasLibrary = "\x00\x64\x20" "MathIeeeDoubBas.library Error" "\x00";
UBYTE *MenuError              = "\x00\x64\x20" "Menu Failed" "\x00";
UBYTE *GadgetError            = "\x00\x64\x20" "Gadget Error" "\x00";
UBYTE *WindowGadgetError      = "\x00\x64\x20" "Window Gadget Error" "\x00";
UBYTE *PreviewWindowError     = "\x00\x64\x20" "Preview Window Failed" "\x00";
UBYTE *CreateDisplayError     = "\x00\x64\x20" "CreateDisplay Error" "\x00";
UBYTE *QueryOverscanError     = "\x00\x64\x20" "QueryOverscan Error" "\x00";
UBYTE *DimensionInfoError     = "\x00\x64\x20" "DimensionInfo Error" "\x00";
UBYTE *DisplayInfoError       = "\x00\x64\x20" "DisplayInfo Error" "\x00";

// VOID __regargs __chkabort (VOID) {}

LONG   About         (struct Window *);
LONG   Quit          (struct Window *);
ULONG  CheckCPU      (UWORD);
ULONG  CheckFPU      (UWORD);
ULONG  Integer_00    (ULONG,DOUBLE,DOUBLE);
ULONG  Integer_20    (ULONG,DOUBLE,DOUBLE);
ULONG  Integer_30    (ULONG,DOUBLE,DOUBLE);
ULONG  Integer_40    (ULONG,DOUBLE,DOUBLE);
ULONG  Real_00       (ULONG,DOUBLE,DOUBLE);
ULONG  Real_20       (ULONG,DOUBLE,DOUBLE);
ULONG  Real_30       (ULONG,DOUBLE,DOUBLE);
ULONG  Real_40       (ULONG,DOUBLE,DOUBLE);
VOID   ShowTime      (struct Window *,ULONG);
ULONG  IntegerGad    (struct Screen *,struct Window *,ULONG);
BOOL   MakeDisplay   (ULONG,WORD,WORD,UWORD,UWORD,BOOL);
VOID   VLine         (struct RastPort *,REGISTER WORD,REGISTER WORD,REGISTER const WORD);
VOID   HLine         (struct RastPort *,REGISTER WORD,REGISTER WORD,REGISTER const WORD);
BOOL   CheckBox      (struct RastPort *,REGISTER WORD,REGISTER WORD,REGISTER WORD,REGISTER WORD);
BOOL   Rectangle     (struct Window *,WORD,WORD,WORD,WORD);
BOOL   NewCoords     (struct Window *,WORD,WORD,WORD,WORD);
BOOL   DrawFrame     (struct Window *,WORD,WORD,WORD,WORD);
ULONG  DrawFractal   (struct Window *,WORD,WORD,WORD,WORD);
BOOL   Preview       (struct Screen *,struct Window *,WORD,WORD,WORD,WORD);
BOOL   ShowCoords    (struct Screen *,struct Window *);
VOID   Undo          (VOID);
BOOL   FileRequest   (struct Window *,STRPTR);
BOOL   SMRequest     (struct Screen *,struct Window *);
VOID   SetMenuStart  (struct Window *);
VOID   SetMenuStop   (struct Window *);
ULONG  ProcessMenu   (struct Window *,UWORD);
VOID   ProcessMouse  (struct Window *,WORD,WORD);
ULONG  HandleEvents  (struct Screen *,struct Window *);
UWORD  ScreenDump    (struct Screen *,WORD,WORD,WORD,WORD,LONG,UWORD);
VOID   Fail          (UBYTE *);
VOID   main          (VOID);

struct TextAttr  MyFontStruct = {"topaz.font",8,FS_NORMAL,FPF_ROMFONT};

struct ColorSpec SCREENCOLORS_ECS [] = {0,0x00,0x00,0x00,1,0x00,0x0F,0x0E,2,0x00,0x0F,0x0C,
                                        3,0x00,0x0F,0x0A,4,0x00,0x0F,0x08,5,0x00,0x0F,0x06,
                                        6,0x00,0x0F,0x04,7,0x03,0x0F,0x00,8,0x05,0x0F,0x00,
                                        9,0x07,0x0F,0x00,10,0x09,0x0F,0x00,11,0x0B,0x0F,0x00,
                                        12,0x0D,0x0F,0x00,13,0x0F,0x0E,0x00,14,0x0F,0x0C,0x00,
                                        15,0x0F,0x0A,0x00,16,0x0F,0x08,0x00,17,0x0F,0x06,0x00,
                                        18,0x0F,0x04,0x00,19,0x0F,0x00,0x03,20,0x0F,0x00,0x05,
                                        21,0x0F,0x00,0x07,22,0x0F,0x00,0x09,23,0x0F,0x00,0x0B,
                                        24,0x0F,0x00,0x0D,25,0x0E,0x00,0x0F,26,0x0C,0x00,0x0F,
                                        27,0x0A,0x00,0x0F,28,0x08,0x00,0x0F,29,0x06,0x00,0x0F,
                                        30,0x04,0x00,0x0F,31,0x0F,0x0F,0x0F,-1,0x00,0x00,0x00};
/*
UWORD SCREENCOLORS_ECS [] = {0x000,0x0FE,0x0FC,0x0FA,0x0F8,0x0F6,0x0F4,0x3F0,0x5F0,0x7F0,
                             0x9F0,0xBF0,0xDF0,0xFE0,0xFC0,0xFA0,0xF80,0xF60,0xF40,0xF03,
                             0xF05,0xF07,0xF09,0xF0B,0xF0D,0xE0F,0xC0F,0xA0F,0x80F,0x60F,
                             0x40F,0xFFF};
*/

ULONG SCREENCOLORS_AGA [] = {256L << 16,0 << 24,0 << 24,0 << 24,0 << 24,255 << 24,250 << 24,0 << 24,255 << 24,245 << 24,0 << 24,255 << 24,240 << 24,0 << 24,255 << 24,235 << 24,
                                        0 << 24,255 << 24,230 << 24,0 << 24,255 << 24,225 << 24,0 << 24,255 << 24,220 << 24,0 << 24,255 << 24,215 << 24,0 << 24,255 << 24,210 << 24,
                                        0 << 24,255 << 24,205 << 24,0 << 24,255 << 24,200 << 24,0 << 24,255 << 24,195 << 24,0 << 24,255 << 24,190 << 24,0 << 24,255 << 24,185 << 24,
                                        0 << 24,255 << 24,180 << 24,0 << 24,255 << 24,175 << 24,0 << 24,255 << 24,170 << 24,0 << 24,255 << 24,165 << 24,0 << 24,255 << 24,160 << 24,
                                        0 << 24,255 << 24,155 << 24,0 << 24,255 << 24,150 << 24,0 << 24,255 << 24,145 << 24,0 << 24,255 << 24,140 << 24,0 << 24,255 << 24,135 << 24,
                                        0 << 24,255 << 24,130 << 24,0 << 24,255 << 24,125 << 24,0 << 24,255 << 24,120 << 24,0 << 24,255 << 24,115 << 24,0 << 24,255 << 24,110 << 24,
                                        0 << 24,255 << 24,105 << 24,0 << 24,255 << 24,100 << 24,0 << 24,255 << 24,95 << 24,0 << 24,255 << 24,90 << 24,0 << 24,255 << 24,85 << 24,
                                        0 << 24,255 << 24,80 << 24,0 << 24,255 << 24,75 << 24,0 << 24,255 << 24,70 << 24,0 << 24,255 << 24,65 << 24,0 << 24,255 << 24,60 << 24,
                                        0 << 24,255 << 24,55 << 24,0 << 24,255 << 24,50 << 24,0 << 24,255 << 24,45 << 24,0 << 24,255 << 24,40 << 24,0 << 24,255 << 24,35 << 24,
                                        0 << 24,255 << 24,30 << 24,0 << 24,255 << 24,25 << 24,0 << 24,255 << 24,20 << 24,0 << 24,255 << 24,15 << 24,0 << 24,255 << 24,10 << 24,
                                        0 << 24,255 << 24,05 << 24,0 << 24,255 << 24,0 << 24,5 << 24,255 << 24,0 << 24,10 << 24,255 << 24,0 << 24,15 << 24,255 << 24,0 << 24,
                                        20 << 24,255 << 24,0 << 24,25 << 24,255 << 24,0 << 24,30 << 24,255 << 24,0 << 24,35 << 24,255 << 24,0 << 24,40 << 24,255 << 24,0 << 24,
                                        45 << 24,255 << 24,0 << 24,50 << 24,255 << 24,0 << 24,55 << 24,255 << 24,0 << 24,60 << 24,255 << 24,0 << 24,65 << 24,255 << 24,0 << 24,
                                        70 << 24,255 << 24,0 << 24,75 << 24,255 << 24,0 << 24,80 << 24,255 << 24,0 << 24,85 << 24,255 << 24,0 << 24,90 << 24,255 << 24,0 << 24,
                                        95 << 24,255 << 24,0 << 24,100 << 24,255 << 24,0 << 24,105 << 24,255 << 24,0 << 24,110 << 24,255 << 24,0 << 24,115 << 24,255 << 24,0 << 24,
                                        120 << 24,255 << 24,0 << 24,125 << 24,255 << 24,0 << 24,130 << 24,255 << 24,0 << 24,135 << 24,255 << 24,0 << 24,140 << 24,255 << 24,0 << 24,
                                        145 << 24,255 << 24,0 << 24,150 << 24,255 << 24,0 << 24,155 << 24,255 << 24,0 << 24,160 << 24,255 << 24,0 << 24,165 << 24,255 << 24,0 << 24,
                                        170 << 24,255 << 24,0 << 24,175 << 24,255 << 24,0 << 24,180 << 24,255 << 24,0 << 24,185 << 24,255 << 24,0 << 24,190 << 24,255 << 24,0 << 24,
                                        195 << 24,255 << 24,0 << 24,200 << 24,255 << 24,0 << 24,205 << 24,255 << 24,0 << 24,210 << 24,255 << 24,0 << 24,215 << 24,255 << 24,0 << 24,
                                        220 << 24,255 << 24,0 << 24,225 << 24,255 << 24,0 << 24,230 << 24,255 << 24,0 << 24,235 << 24,255 << 24,0 << 24,240 << 24,255 << 24,0 << 24,
                                        245 << 24,255 << 24,0 << 24,250 << 24,255 << 24,0 << 24,255 << 24,255 << 24,0 << 24,255 << 24,250 << 24,0 << 24,255 << 24,245 << 24,0 << 24,
                                        255 << 24,240 << 24,0 << 24,255 << 24,235 << 24,0 << 24,255 << 24,230 << 24,0 << 24,255 << 24,225 << 24,0 << 24,255 << 24,220 << 24,0 << 24,
                                        255 << 24,215 << 24,0 << 24,255 << 24,210 << 24,0 << 24,255 << 24,205 << 24,0 << 24,255 << 24,200 << 24,0 << 24,255 << 24,195 << 24,0 << 24,
                                        255 << 24,190 << 24,0 << 24,255 << 24,185 << 24,0 << 24,255 << 24,180 << 24,0 << 24,255 << 24,175 << 24,0 << 24,255 << 24,170 << 24,0 << 24,
                                        255 << 24,165 << 24,0 << 24,255 << 24,160 << 24,0 << 24,255 << 24,155 << 24,0 << 24,255 << 24,150 << 24,0 << 24,255 << 24,145 << 24,0 << 24,
                                        255 << 24,140 << 24,0 << 24,255 << 24,135 << 24,0 << 24,255 << 24,130 << 24,0 << 24,255 << 24,125 << 24,0 << 24,255 << 24,120 << 24,0 << 24,
                                        255 << 24,115 << 24,0 << 24,255 << 24,110 << 24,0 << 24,255 << 24,105 << 24,0 << 24,255 << 24,100 << 24,0 << 24,255 << 24,95 << 24,0 << 24,
                                        255 << 24,90 << 24,0 << 24,255 << 24,85 << 24,0 << 24,255 << 24,80 << 24,0 << 24,255 << 24,75 << 24,0 << 24,255 << 24,70 << 24,0 << 24,
                                        255 << 24,65 << 24,0 << 24,255 << 24,60 << 24,0 << 24,255 << 24,55 << 24,0 << 24,255 << 24,50 << 24,0 << 24,255 << 24,45 << 24,0 << 24,
                                        255 << 24,40 << 24,0 << 24,255 << 24,35 << 24,0 << 24,255 << 24,30 << 24,0 << 24,255 << 24,25 << 24,0 << 24,255 << 24,20 << 24,0 << 24,
                                        255 << 24,15 << 24,0 << 24,255 << 24,10 << 24,0 << 24,255 << 24,05 << 24,0 << 24,255 << 24,0 << 24,0 << 24,255 << 24,0 << 24,5 << 24,
                                        255 << 24,0 << 24,10 << 24,255 << 24,0 << 24,15 << 24,255 << 24,0 << 24,20 << 24,255 << 24,0 << 24,25 << 24,255 << 24,0 << 24,30 << 24,
                                        255 << 24,0 << 24,35 << 24,255 << 24,0 << 24,40 << 24,255 << 24,0 << 24,45 << 24,255 << 24,0 << 24,50 << 24,255 << 24,0 << 24,55 << 24,
                                        255 << 24,0 << 24,60 << 24,255 << 24,0 << 24,65 << 24,255 << 24,0 << 24,70 << 24,255 << 24,0 << 24,75 << 24,255 << 24,0 << 24,80 << 24,
                                        255 << 24,0 << 24,85 << 24,255 << 24,0 << 24,90 << 24,255 << 24,0 << 24,95 << 24,255 << 24,0 << 24,100 << 24,255 << 24,0 << 24,105 << 24,
                                        255 << 24,0 << 24,110 << 24,255 << 24,0 << 24,115 << 24,255 << 24,0 << 24,120 << 24,255 << 24,0 << 24,125 << 24,255 << 24,0 << 24,130 << 24,
                                        255 << 24,0 << 24,135 << 24,255 << 24,0 << 24,140 << 24,255 << 24,0 << 24,145 << 24,255 << 24,0 << 24,150 << 24,255 << 24,0 << 24,155 << 24,
                                        255 << 24,0 << 24,160 << 24,255 << 24,0 << 24,165 << 24,255 << 24,0 << 24,170 << 24,255 << 24,0 << 24,175 << 24,255 << 24,0 << 24,180 << 24,
                                        255 << 24,0 << 24,185 << 24,255 << 24,0 << 24,190 << 24,255 << 24,0 << 24,195 << 24,255 << 24,0 << 24,200 << 24,255 << 24,0 << 24,205 << 24,
                                        255 << 24,0 << 24,210 << 24,255 << 24,0 << 24,215 << 24,255 << 24,0 << 24,220 << 24,255 << 24,0 << 24,225 << 24,255 << 24,0 << 24,230 << 24,
                                        255 << 24,0 << 24,235 << 24,255 << 24,0 << 24,240 << 24,255 << 24,0 << 24,245 << 24,255 << 24,0 << 24,250 << 24,255 << 24,0 << 24,255 << 24,
                                        250 << 24,0 << 24,255 << 24,245 << 24,0 << 24,255 << 24,240 << 24,0 << 24,255 << 24,235 << 24,0 << 24,255 << 24,230 << 24,0 << 24,255 << 24,
                                        225 << 24,0 << 24,255 << 24,220 << 24,0 << 24,255 << 24,215 << 24,0 << 24,255 << 24,210 << 24,0 << 24,255 << 24,205 << 24,0 << 24,255 << 24,
                                        200 << 24,0 << 24,255 << 24,195 << 24,0 << 24,255 << 24,190 << 24,0 << 24,255 << 24,185 << 24,0 << 24,255 << 24,180 << 24,0 << 24,255 << 24,
                                        175 << 24,0 << 24,255 << 24,170 << 24,0 << 24,255 << 24,165 << 24,0 << 24,255 << 24,160 << 24,0 << 24,255 << 24,155 << 24,0 << 24,255 << 24,
                                        150 << 24,0 << 24,255 << 24,145 << 24,0 << 24,255 << 24,140 << 24,0 << 24,255 << 24,135 << 24,0 << 24,255 << 24,130 << 24,0 << 24,255 << 24,
                                        125 << 24,0 << 24,255 << 24,120 << 24,0 << 24,255 << 24,115 << 24,0 << 24,255 << 24,110 << 24,0 << 24,255 << 24,105 << 24,0 << 24,255 << 24,
                                        100 << 24,0 << 24,255 << 24,95 << 24,0 << 24,255 << 24,90 << 24,0 << 24,255 << 24,85 << 24,0 << 24,255 << 24,80 << 24,0 << 24,255 << 24,
                                        75 << 24,0 << 24,255 << 24,70 << 24,0 << 24,255 << 24,65 << 24,0 << 24,255 << 24,60 << 24,0 << 24,255 << 24,55 << 24,0 << 24,255 << 24,
                                        50 << 24,0 << 24,255 << 24,45 << 24,0 << 24,255 << 24,40 << 24,0 << 24,255 << 24,35 << 24,0 << 24,255 << 24,30 << 24,0 << 24,255 << 24,
                                        25 << 24,0 << 24,255 << 24,20 << 24,0 << 24,255 << 24,15 << 24,0 << 24,255 << 24,10 << 24,0 << 24,255 << 24,5 << 24,0 << 24,255 << 24,255 << 24,255 << 24,255 << 24,0};

UWORD PENS [] = {NERO,BIANCO,ROSSO,BIANCO,BIANCO,ROSSO,NERO,NERO,ROSSO,0xFFFF};

UWORD chip ZZZPointer[]  = {0x0000, 0x0000, 0x0400, 0x07C0, 0x0000, 0x07C0, 0x0100, 0x0380,0x0000, 0x07E0, 0x07C0, 0x1FF8, 0x1FF0, 0x3FEC, 0x3FF8, 0x7FDE,0x3FF8, 0x7FBE, 0x7FFC, 0xFF7F, 0x7EFC, 0xFFFF, 0x7FFC, 0xFFFF,
                            0x3FF8, 0x7FFE, 0x3FF8, 0x7FFE, 0x1FF0, 0x3FFC, 0x07C0, 0x1FF8,0x0000, 0x07E0, 0x0000, 0x0000};

UWORD chip ZoomPointer[] = {0x0000,0x0000,0x0100,0x0000,0x0100,0x0000,0x0000,0x0100,0x0000,0x0100,0x0100,0x0100,0x0100,0x0100,0x0000,0x0000,0xCC66,0x3C78,0x0000,0x0000,0x0100,0x0100,0x0100,0x0100,
                            0x0000,0x0100,0x0000,0x0100,0x0100,0x0000,0x0100,0x0000,0x0000,0x0000};

struct NewMenu ProgMenu[] = { NM_TITLE,"Project",0,0,0,0,
                              NM_ITEM,"About...","A",NM_ITEMDISABLED,0,0,
                              NM_ITEM,NM_BARLABEL,0,0,0,0,
                              NM_ITEM,"Load...","L",NM_ITEMDISABLED,0,0,
                              NM_ITEM,"Save...","S",NM_ITEMDISABLED,0,0,
                              NM_ITEM,NM_BARLABEL,0,0,0,0,
                              NM_ITEM,"Dump","D",NM_ITEMDISABLED,0,0,
                              NM_ITEM,NM_BARLABEL,0,0,0,0,
                              NM_ITEM,"Quit","Q",NM_ITEMDISABLED,0,0,

                              NM_TITLE,"Options",0,0,0,0,
                              NM_ITEM,"Title","T",CHECKIT|CHECKED|MENUTOGGLE|NM_ITEMDISABLED,0,0,
                              NM_ITEM,"Limits...","C",NM_ITEMDISABLED,0,0,
                              NM_ITEM,"Iterations",0,NM_ITEMDISABLED,0,0,
                              NM_SUB,"16",0,CHECKIT,~(1<<0),0,
                              NM_SUB,"32",0,CHECKIT,~(1<<1),0,
                              NM_SUB,"64",0,CHECKIT,~(1<<2),0,
                              NM_SUB,"128",0,CHECKIT,~(1<<3),0,
                              NM_SUB,"256",0,CHECKIT|CHECKED,~(1<<4),0,
                              NM_SUB,"512",0,CHECKIT,~(1<<5),0,
                              NM_SUB,"1024",0,CHECKIT,~(1<<6),0,
                              NM_SUB,NM_BARLABEL,0,0,0,0,
                              NM_SUB,"Custom...","I",CHECKIT,~(1<<8),0,

                              NM_ITEM,"Priority",0,0,0,0,
                              NM_SUB,"-5","1",CHECKIT,~(1<<0),0,
                              NM_SUB,"-3","2",CHECKIT,~(1<<1),0,
                              NM_SUB," 0","3",CHECKIT|CHECKED,~(1<<2),0,
                              NM_SUB,"+3","4",CHECKIT,~(1<<3),0,
                              NM_SUB,"+5","5",CHECKIT,~(1<<4),0,

                              NM_ITEM,"Precision",0,0,0,0,
                              NM_SUB,"Integer",0,CHECKIT|CHECKED,~(1<<0),0,
                              NM_SUB,"Ieee",0,CHECKIT,~(1<<1),0,

                              NM_TITLE,"Calculate",0,0,0,0,
                              NM_ITEM,"PreView","P",NM_ITEMDISABLED,0,0,
                              NM_ITEM,NM_BARLABEL,0,0,0,0,
                              NM_ITEM,"ReCalculate","R",NM_ITEMDISABLED,0,0,
                              NM_ITEM,NM_BARLABEL,0,0,0,0,
                              NM_ITEM,"Undo","U",NM_ITEMDISABLED,0,0,
                              NM_ITEM,NM_BARLABEL,0,0,0,0,
                              NM_ITEM,"Zoom","Z",NM_ITEMDISABLED,0,0,
                              NM_ITEM,"Stop","-",0,0,0,

                              NM_TITLE,"Video",0,0,0,0,
                              NM_ITEM,"Screen Mode...","V",NM_ITEMDISABLED,0,0,

                              NM_END,0,0,0,0,0 };

extern struct ExecBase *SysBase;

struct Screen       *MAINSCR = 0;

struct Window       *MAINWIN = 0;

struct Menu         *MAINMENU = 0;

struct TextFont     *MYFONT = 0;

// struct ILBMInfo     MyIlbm = {0};

// extern ULONG __asm Int_10 (register __d0 ULONG,register __d1 LONG,register __d2 LONG);

extern ULONG Int_20 (ULONG *,LONG *,LONG *);

extern ULONG Int_30 (ULONG *,LONG *,LONG *);

extern ULONG Int_40 (ULONG *,LONG *,LONG *);

extern ULONG Ieee_20 (ULONG *,DOUBLE *,DOUBLE *);

extern ULONG Ieee_30 (ULONG *,DOUBLE *,DOUBLE *);

extern ULONG Ieee_40 (ULONG *,DOUBLE *,DOUBLE *);

// extern LONG screensave (struct ILBMInfo *,struct Screen *,struct Chunk *,struct Chunk *,UBYTE *);

ULONG CheckCPU (UWORD CpuFlags)
{
 if (AFF_68040 & CpuFlags) return 68040L;

 if (AFF_68030 & CpuFlags) return 68030L;

 if (AFF_68020 & CpuFlags) return 68020L;

 if (AFF_68010 & CpuFlags) return 68010L;

 return 68000L;
}

ULONG CheckFPU (UWORD CpuFlags)
{
 if (AFF_FPU40 & CpuFlags) return 68883L;

 if (AFF_68882 & CpuFlags) return 68882L;

 if (AFF_68881 & CpuFlags) return 68881L;

 return 0L;
}

BOOL MakeDisplay (ULONG Display,WORD Width,WORD Height,UWORD Depth,UWORD OverScan,BOOL AutoScroll)
{
struct Rectangle ScreenArea;

ULONG ErrorCode = 0L;

  if (MAINWIN)
  {
      ClearMenuStrip (MAINWIN);

      ClearPointer   (MAINWIN);

      CloseWindow    (MAINWIN);
  }

  if (MYFONT)        CloseFont (MYFONT);

  if (VINFO)         FreeVisualInfo (VINFO);

  if (MAINSCR)       CloseScreen (MAINSCR);

  if ((Display & SUPERLACE_KEY) || (Display & SUPER_KEY))
  {
      MyFontStruct.ta_YSize = 11;

      MyFontStruct.ta_Flags = FPF_WIDEDOT | FPF_TALLDOT | FPF_DISKFONT;
  }

  if (Display & HIRESLACE_KEY)
  {
     MyFontStruct.ta_YSize = 9;

     MyFontStruct.ta_Flags = FPF_ROMFONT | FPF_WIDEDOT | FPF_TALLDOT;
  }

  if (Display & HIRES_KEY)
  {
     MyFontStruct.ta_YSize = 9;

     MyFontStruct.ta_Flags = FPF_ROMFONT | FPF_TALLDOT;
  }

  if (Display & LORESLACE_KEY)
  {
     MyFontStruct.ta_YSize = 8;

     MyFontStruct.ta_Flags = FPF_ROMFONT | FPF_WIDEDOT;
  }

  if (Display & LORES_KEY)
  {
     MyFontStruct.ta_YSize = 8;

     MyFontStruct.ta_Flags = FPF_ROMFONT;
  }

  if (Display & EXTRAHALFBRITELACE_KEY)
  {
     MyFontStruct.ta_YSize = 8;

     MyFontStruct.ta_Flags = FPF_ROMFONT | FPF_WIDEDOT;
  }

  if (Display & EXTRAHALFBRITE_KEY)
  {
     MyFontStruct.ta_YSize = 8;

     MyFontStruct.ta_Flags = FPF_ROMFONT;
  }

  if (! (MYFONT = OpenDiskFont (&MyFontStruct)))
  {
        Fail (FontError);

        return FALSE;
  }

  if (! QueryOverscan (Display,&ScreenArea,OverScan))
  {
        Fail (QueryOverscanError);

        return FALSE;
  }

  MAINSCR = OpenScreenTags (NULL,
                            SA_Left,ScreenArea.MinX - ((Width - (ScreenArea.MaxX - ScreenArea.MinX + 1)) >> 1),
                            SA_Top,min (ScreenArea.MinY , ScreenArea.MinY - ((Height - (ScreenArea.MaxY - ScreenArea.MinY + 1)) >> 1)),
                            SA_Width,Width,
                            SA_Height,Height,
                            SA_Depth,(UBYTE) Depth,
                            SA_Overscan,OverScan,
                            SA_AutoScroll,AutoScroll,
                            SA_Colors,SCREENCOLORS_ECS,
                            SA_Colors32,(GfxBase->LibNode.lib_Version >= 39 && ((Depth > 5) && (! ((Display & EXTRAHALFBRITE_KEY) || (Display & EXTRAHALFBRITELACE_KEY))))) ? SCREENCOLORS_AGA : 0L,
                            SA_Interleaved,(GfxBase->LibNode.lib_Version >= 39 ) ? TRUE : FALSE,
                            SA_DetailPen,NERO,
                            SA_BlockPen,BIANCO,
                            SA_Font,(ULONG) ((struct TextAttr *) &MyFontStruct),
                            SA_Title,VERSION,
                            SA_ErrorCode,&ErrorCode,
                            SA_DisplayID,Display,
                            SA_Pens,(ULONG) PENS,
                            SA_FullPalette,TRUE,
                            SA_ShowTitle,TITLE,
                            TAG_DONE,NULL);

  if (! MAINSCR)
  {
     switch (ErrorCode)
     {
              case OSERR_NOMONITOR   : Fail (NoMonitor);

                                       break;

              case OSERR_NOCHIPS     : Fail (NoChips);

                                       break;

              case OSERR_NOMEM       : Fail (NoMem);

                                       break;

              case OSERR_NOCHIPMEM   : Fail (NoChipMem);

                                       break;

              case OSERR_PUBNOTUNIQUE: Fail (PubNotUnique);

                                       break;

              case OSERR_UNKNOWNMODE : Fail (UnknownMode);

                                       break;

              case OSERR_TOODEEP     : Fail (ScreenTooDeep);

                                       break;

              case OSERR_ATTACHFAIL  : Fail (AttachScreen);

                                       break;

              case OSERR_NOTAVAILABLE: Fail (ModeNotAvailableError);

                                       break;

              default                : Fail (UnknownScrError);

                                       break;
     }

     return FALSE;
  }

  if (! (VINFO = GetVisualInfo (MAINSCR,TAG_DONE,0)))
  {
        Fail (VisualInfoError);

        return FALSE;
  }

  if (! (LayoutMenus (MAINMENU,VINFO,GTMN_TextAttr,&MyFontStruct,GTMN_NewLookMenus,TRUE,TAG_DONE,0)))
  {
        Fail (FontError);

        return FALSE;
  }

  MAINWIN = OpenWindowTags (NULL,
                            WA_Left,MAINSCR->LeftEdge,
                            WA_Top,MAINSCR->TopEdge,
                            WA_Width,MAINSCR->Width,
                            WA_Height,MAINSCR->Height,
                            WA_ScreenTitle,VERSION " - Giftware -",
                            WA_CustomScreen,MAINSCR,
                            WA_IDCMP,IDCMP_STANDARD,
                            WA_Flags,WFLG_ACTIVATE|WFLG_BACKDROP|WFLG_NOCAREREFRESH|WFLG_SMART_REFRESH|WFLG_BORDERLESS|WFLG_REPORTMOUSE|WFLG_NEWLOOKMENUS,
                            TAG_DONE,0);

  if (! MAINWIN)
  {
     Fail (WindowError);

     return FALSE;
  }

  SetMenuStrip (MAINWIN,MAINMENU);

  SetFont (MAINWIN->RPort,MYFONT);

  return TRUE;
}

VOID ShowTime (struct Window *Win,ULONG Sec)
{
  sprintf (BAR_MESSAGE,"Elapsed time: %u Ours %u Mins %u Secs",Sec / 3600L,(Sec / 60L) % 60L,Sec % 60L);

  SetWindowTitles (Win,(UBYTE *) ~0,BAR_MESSAGE);
}

VOID Undo (VOID)
{
  X1 = UX1;

  X2 = UX2;

  Y1 = UY1;

  Y2 = UY2;
}

BOOL NewCoords (struct Window *Win,WORD X,WORD Y,WORD W,WORD H)
{
DOUBLE Kre , Kim;

  if (! (W && H)) return FALSE;

  Kre = (abs (X2-X1)) / ((DOUBLE) Win->Width);

  Kim = (abs (Y2-Y1)) / ((DOUBLE) Win->Height);

  UX1 = X1;

  UX2 = X2;

  UY1 = Y1;

  UY2 = Y2;

  X2 = X1 + ((DOUBLE) (X + W) * Kre);

  Y1 = Y2 - ((DOUBLE) (Win->Height - 1 - Y) * Kim);

  X1 += ((DOUBLE) X * Kre);

  Y2 -= ((DOUBLE) (Win->Height - 1 - (Y + H)) * Kim);

  return TRUE;
}

LONG About (struct Window *Win)
{
struct EasyStruct MyReq_1 = { sizeof (struct EasyStruct),0,"Informations...","          " VERSION "\n\n" "Copyright © 1996 " BY " " AUTHOR "\n\n" ADDRESS "\n\nReal: %s ; %s\n\nImag: %s ; %s","Ok|More..." };

struct EasyStruct MyReq_2 = { sizeof (struct EasyStruct),0,"Workgroup...","      Greetings & thanks to:\n\nLelio della Pietra : Fixed point\n\nClaudio Pucci      : Debug & docs\n\nSergio Tassi       : Beta testing\n\n\n             Remember:\n\nCall Leonardo BBS  (+39-81-5404613)","Ok" };

UBYTE XMin [16],YMin [16],XMax [16],YMax [16];

LONG More;

 sprintf (XMin,"%1.10lf",X1);

 sprintf (XMax,"%1.10lf",X2);

 sprintf (YMin,"%1.10lf",Y1);

 sprintf (YMax,"%1.10lf",Y2);

 More = EasyRequest (Win,&MyReq_1,0,XMin,XMax,YMin,YMax);

 if (! More) EasyRequest (Win,&MyReq_2,0);

 return More;
}

LONG Quit (struct Window *Win)
{
struct EasyStruct MyReq = { sizeof (struct EasyStruct),0,"Exit requester","Are you sure ?","Yes|No" };

 return EasyRequest (Win,&MyReq,0);
}

BOOL ShowCoords (struct Screen *Scr,struct Window *Win)
{
struct NewGadget StringGad = {95,10,125,14,"_real Min ",&MyFontStruct,0,PLACETEXT_LEFT,0,0};

struct NewGadget ButtonGad = {10,90,60,20,"_Accept",&MyFontStruct,ACCEPT,0,0,0};

struct Gadget *GadList = 0,*StringGad_1,*StringGad_2,*StringGad_3,*StringGad_4,*MyButtonGad,*MyGad;

struct Window *GadWin;

struct IntuiMessage *Message;

BOOL Exit = FALSE , Error = FALSE;

UBYTE String [51];

UWORD MyCode;

WORD HScrX = Scr->Width >> 1 , HScrY = Scr->Height >> 1 , WinWidth = 240 , WinHeight = 130;

ULONG MyClass;

APTR VInfo;

VInfo = GetVisualInfo (Scr,TAG_DONE,0);

if (VInfo)
 {
  StringGad.ng_VisualInfo = VInfo;

  ButtonGad.ng_VisualInfo = VInfo;

  MyButtonGad = CreateContext (&GadList);

  MyButtonGad = CreateGadget (BUTTON_KIND,MyButtonGad,&ButtonGad,GT_Underscore,'_',TAG_DONE,0);

  ButtonGad.ng_LeftEdge += 75;

  ButtonGad.ng_GadgetText = "_Scale";

  ButtonGad.ng_GadgetID = PROPORTIONAL;

  MyButtonGad = CreateGadget (BUTTON_KIND,MyButtonGad,&ButtonGad,GT_Underscore,'_',GA_Disabled,TRUE,TAG_DONE,0);

  ButtonGad.ng_LeftEdge += 75;

  ButtonGad.ng_GadgetText = "_Cancel";

  ButtonGad.ng_GadgetID = CANCEL;

  MyButtonGad = CreateGadget (BUTTON_KIND,MyButtonGad,&ButtonGad,GT_Underscore,'_',TAG_DONE,0);

  sprintf (String,"%1.50lf",X1);

  StringGad_1 = CreateGadget (STRING_KIND,MyButtonGad,&StringGad,GTST_String,String,STRINGA_ReplaceMode,TRUE,GTST_MaxChars,50,GT_Underscore,'_',TAG_DONE,0);

  StringGad.ng_TopEdge += 18;

  StringGad.ng_GadgetText="_Real Max ";

  sprintf (String,"%1.50lf",X2);

  StringGad_2 = CreateGadget (STRING_KIND,StringGad_1,&StringGad,GTST_String,String,STRINGA_ReplaceMode,TRUE,GTST_MaxChars,50,GT_Underscore,'_',TAG_DONE,0);

  StringGad.ng_TopEdge += 18;

  StringGad.ng_GadgetText="_imag Min ";

  sprintf (String,"%1.50lf",Y1);

  StringGad_3 = CreateGadget (STRING_KIND,StringGad_2,&StringGad,GTST_String,String,STRINGA_ReplaceMode,TRUE,GTST_MaxChars,50,GT_Underscore,'_',TAG_DONE,0);

  StringGad.ng_TopEdge += 18;

  StringGad.ng_GadgetText="_Imag Max ";

  sprintf (String,"%1.50lf",Y2);

  StringGad_4 = CreateGadget (STRING_KIND,StringGad_3,&StringGad,GTST_String,String,STRINGA_ReplaceMode,TRUE,GTST_MaxChars,50,GT_Underscore,'_',TAG_DONE,0);

  if (StringGad_4)
  {
     GadWin = OpenWindowTags (NULL,WA_Left,HScrX - (WinWidth >> 1),
                                   WA_Top,HScrY - (WinHeight >> 1),
                                   WA_Width,WinWidth,
                                   WA_Height,WinHeight,
                                   WA_Gadgets,GadList,
                                   WA_Title,"Coordinates requester",
                                   WA_ScreenTitle,"Insert new range ...",
                                   WA_CustomScreen,Scr,
                                   WA_IDCMP,IDCMP_CLOSEWINDOW|IDCMP_REFRESHWINDOW|IDCMP_VANILLAKEY|STRINGIDCMP|BUTTONIDCMP,
                                   WA_Flags,WFLG_ACTIVATE|WFLG_DRAGBAR|WFLG_SIMPLE_REFRESH|WFLG_GIMMEZEROZERO|WFLG_RMBTRAP,
                                   TAG_DONE,NULL);
     if (GadWin)
     {
        GT_RefreshWindow (GadWin,0);

        do {
              WaitPort (GadWin->UserPort);

              Message = (struct IntuiMessage *) GT_GetIMsg (GadWin->UserPort);

              MyGad = (struct Gadget *) Message->IAddress;

              MyClass = Message->Class;

              MyCode = Message->Code;

              GT_ReplyIMsg ((struct IntuiMessage *) Message);

              switch (MyClass)
              {
                     case IDCMP_REFRESHWINDOW : GT_BeginRefresh (GadWin);

                                                GT_EndRefresh (GadWin,TRUE);

                                                break;

                     case IDCMP_VANILLAKEY    : switch (MyCode)
                                                {
                                                       case 'r' : ActivateGadget (StringGad_1,GadWin,0);

                                                                  break;

                                                       case 'R' : ActivateGadget (StringGad_2,GadWin,0);

                                                                  break;

                                                       case 'i' : ActivateGadget (StringGad_3,GadWin,0);

                                                                  break;

                                                       case 'I' : ActivateGadget (StringGad_4,GadWin,0);

                                                                  break;

                                                       case 'A' : Exit = TRUE;

                                                                  X1 = atof (((struct StringInfo *) StringGad_1->SpecialInfo)->Buffer);

                                                                  X2 = atof (((struct StringInfo *) StringGad_2->SpecialInfo)->Buffer);

                                                                  Y1 = atof (((struct StringInfo *) StringGad_3->SpecialInfo)->Buffer);

                                                                  Y2 = atof (((struct StringInfo *) StringGad_4->SpecialInfo)->Buffer);

                                                                  break;

                                                       case 'S' :

                                                                  break;

                                                       case 'C' : Exit = TRUE;

                                                                  break;

                                                    case VAN_ESC: Exit = TRUE;

                                                                  break;
                                                }

                                                break;

                     case IDCMP_GADGETUP      : switch (MyGad->GadgetID)
                                                {
                                                     case ACCEPT  :   Exit = TRUE;

                                                                      X1 = atof (((struct StringInfo *) StringGad_1->SpecialInfo)->Buffer);

                                                                      X2 = atof (((struct StringInfo *) StringGad_2->SpecialInfo)->Buffer);

                                                                      Y1 = atof (((struct StringInfo *) StringGad_3->SpecialInfo)->Buffer);

                                                                      Y2 = atof (((struct StringInfo *) StringGad_4->SpecialInfo)->Buffer);

                                                                      break;

                                                 case PROPORTIONAL:

                                                                      break;

                                                       case CANCEL:   Exit = TRUE;

                                                                      break;
                                                }

                                                break;

                     case IDCMP_CLOSEWINDOW   : Exit = TRUE;

                                                break;
              }

           } while (Exit == FALSE);

       CloseWindow (GadWin);

     }

     else
     {
        Fail (WindowGadgetError);

        Error = TRUE;
     }
  }

  else
  {
     Fail (GadgetError);

     Error = TRUE;
  }

  FreeGadgets (GadList);

  FreeVisualInfo (VInfo);
 }

else
{
   Fail (VisualInfoError);

   Error = TRUE;
}

return Error;
}

ULONG IntegerGad (struct Screen *Scr,struct Window *Win,ULONG Var)
{
struct NewGadget IntGad = {120,5,50,12,"_Iterations:",&MyFontStruct,0,PLACETEXT_LEFT,0,0};

struct NewGadget ButtonGad = {20,30,60,20,"_Accept",&MyFontStruct,ACCEPT,0,0,0};

struct IntuiMessage *Message;

struct Gadget *GadList = 0 , *MyIntGad , *MyButtonGad , *MyGad;

struct Window *GadWin;

BOOL Exit = FALSE , NewIterations = FALSE;

WORD HScrX = Scr->Width >> 1 , HScrY = Scr->Height >> 1 , WinWidth = 200 , WinHeight = 70;

UWORD MyCode;

ULONG MyClass;

APTR VInfo;

VInfo = GetVisualInfo (Scr,TAG_DONE,0);

if (VInfo)
 {
  IntGad.ng_VisualInfo = VInfo;

  ButtonGad.ng_VisualInfo = VInfo;

  MyButtonGad = CreateContext (&GadList);

  MyButtonGad = CreateGadget (BUTTON_KIND,MyButtonGad,&ButtonGad,GT_Underscore,'_',TAG_DONE,0);

  ButtonGad.ng_LeftEdge += 100;

  ButtonGad.ng_GadgetText = "_Cancel";

  ButtonGad.ng_GadgetID = CANCEL;

  MyButtonGad = CreateGadget (BUTTON_KIND,MyButtonGad,&ButtonGad,GT_Underscore,'_',TAG_DONE,0);

  MyIntGad = CreateGadget (INTEGER_KIND,MyButtonGad,&IntGad,GTIN_Number,Var,GTIN_MaxChars,6,STRINGA_ReplaceMode,TRUE,GT_Underscore,'_',TAG_DONE,0);

  if (MyIntGad)
  {
     GadWin = OpenWindowTags (NULL,WA_Left,HScrX - (WinWidth >> 1),
                                   WA_Top,HScrY - (WinHeight >> 1),
                                   WA_Width,WinWidth,
                                   WA_Height,WinHeight,
                                   WA_Gadgets,GadList,
                                   WA_Title,"Iterations requester",
                                   WA_ScreenTitle,"Insert new iterations ...",
                                   WA_CustomScreen,Scr,
                                   WA_IDCMP,IDCMP_CLOSEWINDOW|IDCMP_REFRESHWINDOW|IDCMP_VANILLAKEY|INTEGERIDCMP|BUTTONIDCMP,
                                   WA_Flags,WFLG_ACTIVATE|WFLG_DRAGBAR|WFLG_SIMPLE_REFRESH|WFLG_GIMMEZEROZERO|WFLG_RMBTRAP,
                                   TAG_DONE,NULL);

     if (GadWin)
     {
        GT_RefreshWindow (GadWin,0);

        do {
              WaitPort (GadWin->UserPort);

              Message = (struct IntuiMessage *) GT_GetIMsg (GadWin->UserPort);

              MyGad = (struct Gadget *) Message->IAddress;

              MyClass = Message->Class;

              MyCode = Message->Code;

              GT_ReplyIMsg ((struct IntuiMessage *) Message);

              switch (MyClass)
              {
                case IDCMP_REFRESHWINDOW : GT_BeginRefresh (GadWin);

                                           GT_EndRefresh (GadWin,TRUE);

                                           break;

                case IDCMP_VANILLAKEY    : switch (MyCode)
                                           {
                                                  case 'I' : ActivateGadget (MyIntGad,GadWin,0);

                                                             break;

                                                  case 'A' : Exit = TRUE;

                                                             NewIterations = TRUE;

                                                             break;

                                                  case 'C' : Exit = TRUE;

                                                             break;

/* VANILLA_ESC */                              case VAN_ESC: Exit = TRUE;

                                                             break;
                                           }

                                           break;

                case IDCMP_GADGETUP      : switch (MyGad->GadgetID)
                                           {
                                                case ACCEPT  : Exit = TRUE;

                                                               NewIterations = TRUE;

                                                               break;

                                                case CANCEL  : Exit = TRUE;

                                                               break;
                                           }

                                           break;

                case IDCMP_CLOSEWINDOW   : Exit = TRUE;

                                           break;
              }

           } while (Exit == FALSE);

        CloseWindow (GadWin);

        if (NewIterations) Var = ((struct StringInfo *) MyIntGad->SpecialInfo)->LongInt;
     }

     else Fail (WindowError);
  }

  else Fail (GadgetError);

  FreeGadgets (GadList);

  FreeVisualInfo (VInfo);
 }

else Fail (VisualInfoError);

if (Var < 16L) Var = 16L;

return Var;
}

ULONG Integer_00 (ULONG Iterazioni,DOUBLE Cre,DOUBLE Cim)
{
LONG Fixed_Cre = (LONG) (Cre * MAX_POT) , Fixed_Cim = (LONG) (Cim * MAX_POT);

LONG zr = Fixed_Cre , zi = Fixed_Cim;

ULONG zr2 , zi2;

  FOREVER
  {
       zr >>= (HALF_FIXED_POINT);

       zi >>= (HALF_FIXED_POINT);

       zr2 = zr * zr;

       zi2 = zi * zi;

       if ((zr2 + zi2) > (4L << FIXED_POINT)) break;

       if (--Iterazioni)
       {
          zi *= zr;

          zr = zr2 - zi2 + Fixed_Cre;

          zi <<= 1;

          zi += Fixed_Cim;
       }

       else break;
  }

  return Iterazioni;
}

ULONG Integer_20 (ULONG Iterazioni,DOUBLE Cre,DOUBLE Cim)
{
LONG Fixed_Cre = (LONG) (Cre * MAX_POT) , Fixed_Cim = (LONG) (Cim * MAX_POT);

      return Int_20 (&Iterazioni,&Fixed_Cre,&Fixed_Cim);
}

ULONG Integer_30 (ULONG Iterazioni,DOUBLE Cre,DOUBLE Cim)
{
LONG Fixed_Cre = (LONG) (Cre * MAX_POT) , Fixed_Cim = (LONG) (Cim * MAX_POT);

      return Int_30 (&Iterazioni,&Fixed_Cre,&Fixed_Cim);
}

ULONG Integer_40 (ULONG Iterazioni,DOUBLE Cre,DOUBLE Cim)
{
LONG Fixed_Cre = (LONG) (Cre * MAX_POT) , Fixed_Cim = (LONG) (Cim * MAX_POT);

      return Int_40 (&Iterazioni,&Fixed_Cre,&Fixed_Cim);
}

ULONG Real_00 (ULONG Iterazioni,DOUBLE Cre,DOUBLE Cim)
{
DOUBLE zr = Cre , zi = Cim , zr2 , zi2;

  FOREVER
  {
     zr2 = zr * zr;

     zi2 = zi * zi;

     if ((zr2 + zi2) > 4.0) break;

     if (--Iterazioni)
     {
        zi *= zr;

        zr = zr2 - zi2 + Cre;

        zi += zi;

        zi += Cim;
     }

     else break;
  }

  return Iterazioni;
}

ULONG Real_20 (ULONG Iterazioni,DOUBLE Cre,DOUBLE Cim)
{
      return Ieee_20 (&Iterazioni,&Cre,&Cim);
}

ULONG Real_30 (ULONG Iterazioni,DOUBLE Cre,DOUBLE Cim)
{
      return Ieee_30 (&Iterazioni,&Cre,&Cim);
}

ULONG Real_40 (ULONG Iterazioni,DOUBLE Cre,DOUBLE Cim)
{
      return Ieee_40 (&Iterazioni,&Cre,&Cim);
}

VOID VLine (struct RastPort *RP,REGISTER WORD b1,REGISTER WORD b2,REGISTER const WORD x)
{
REGISTER WORD y;

 Cre = X1 + (((DOUBLE) x) * Sx);

 Cim = Y1 + (((DOUBLE) b1) * Sy);

 for (y = b1; y <= b2; y++)
 {
     SetAPen (RP,FUNCTION (ITERAZIONI,Cre,Cim));

     WritePixel (RP,x,y);

     Cim += Sy;
 }
}

VOID HLine (struct RastPort *RP,REGISTER WORD a1,REGISTER WORD a2,REGISTER const WORD y)
{
REGISTER WORD x;

 Cre = X1 + (((DOUBLE) a1) * Sx);

 Cim = Y1 + (((DOUBLE) y) * Sy);

 for (x = a1; x <= a2; x++)
 {
     SetAPen (RP,FUNCTION (ITERAZIONI,Cre,Cim));

     WritePixel (RP,x,y);

     Cre += Sx;
 }
}

BOOL CheckBox (struct RastPort *RP,REGISTER WORD a1,REGISTER WORD b1,REGISTER WORD a2,REGISTER WORD b2)
{
REGISTER WORD Var;

REGISTER LONG Color;

  Color = ReadPixel (RP,a1,b1);

  for (Var = (a1 + 1); Var <= a2; Var++)
  {
      if (Color != ReadPixel (RP,Var,b1)) return FALSE;

      if (Color != ReadPixel (RP,Var,b2)) return FALSE;
  }

  for (Var = (b1 + 1); Var <= b2; Var++)
  {
      if (Color != ReadPixel (RP,a1,Var)) return FALSE;

      if (Color != ReadPixel (RP,a2,Var)) return FALSE;
  }

  return TRUE;
}

BOOL Rectangle (struct Window *Win,WORD a1,WORD b1,WORD a2,WORD b2)
{
struct IntuiMessage *Message;

WORD hx , hy , k;

UWORD MyCode;

ULONG MyClass;

 if (Message = (struct IntuiMessage *) GT_GetIMsg (Win->UserPort))
 {
    MyClass = Message->Class;

    MyCode = Message->Code;

    GT_ReplyIMsg ((struct IntuiMessage *) Message);

    switch (MyClass)
    {
      case IDCMP_MENUPICK    : if (MyCode != MENUNULL)
                               {
                                  if (ProcessMenu (Win,MyCode) & STOP_MSG) return TRUE;
                               }

                               break;

      case IDCMP_RAWKEY      : if (MyCode == TAB) return FALSE;

                               if (MyCode == RAW_ESC) return TRUE;

                               break;

      case IDCMP_CLOSEWINDOW : return TRUE;
    }
 }

 hy = b2 - b1;

 if (hy < MINLIMIT) return FALSE;

 hx = a2 - a1;

 if (hx < MINLIMIT) return FALSE;

 if ((hx < (MINLIMIT << 1)) || (hy < (MINLIMIT << 1)))
 {
    for (k = (b1 + 1); k <= (b2 - 1); k++)
    {
        HLine (Win->RPort,a1+1,a2-1,k);
    }

    return FALSE;
 }

 if (CheckBox (Win->RPort,a1,b1,a2,b2))
 {
    SetAPen (Win->RPort,ReadPixel (Win->RPort,a1,b1));

    RectFill (Win->RPort,a1,b1,a2,b2);

    return FALSE;
 }

 hx = (hx + 1) >> 1;

 hy = (hy + 1) >> 1;

 hx += a1;

 hy += b1;

 HLine (Win->RPort,a1+1,a2-1,hy);

 VLine (Win->RPort,b1+1,b2-1,hx);

 if (Rectangle (Win,a1,b1,hx,hy)) return TRUE;

 if (Rectangle (Win,hx,b1,a2,hy)) return TRUE;

 if (Rectangle (Win,a1,hy,hx,b2)) return TRUE;

 if (Rectangle (Win,hx,hy,a2,b2)) return TRUE;

 return FALSE;
}

ULONG DrawFractal (struct Window *Win,WORD a1,WORD b1,WORD a2,WORD b2)
{
ULONG StartSec = 0L , EndSec = 0L , Dummy = 0L;

 CurrentTime (&StartSec,&Dummy);

 Sx = (abs (X2-X1)) / ((DOUBLE) (a2 - a1 + 1));

 Sy = (abs (Y2-Y1)) / ((DOUBLE) (b2 - b1 + 1));

 HLine (Win->RPort,a1,a2,b1);

 VLine (Win->RPort,b1+1,b2-1,a2);

 HLine (Win->RPort,a1,a2,b2);

 VLine (Win->RPort,b1+1,b2-1,a1);

 Rectangle (Win,a1,b1,a2,b2);

 CurrentTime (&EndSec,&Dummy);

 return (EndSec-StartSec);
}

BOOL Preview (struct Screen *Scr,struct Window *Win,WORD a1,WORD b1,WORD a2,WORD b2)
{
struct Window *PreviewWin;

struct IntuiMessage *Message;

BOOL Error = FALSE , Exit = FALSE;

UWORD MyCode;

ULONG MyClass , ElapsedTime;

 PreviewWin = OpenWindowTags (0,WA_Left,a1,
                                WA_Top,b1,
                                WA_Width,a2-a1,
                                WA_Height,b2-b1,
                                WA_Title,"Preview window",
                                WA_ScreenTitle,"Calculating...",
                                WA_CustomScreen,Scr,
                                WA_IDCMP,IDCMP_RAWKEY|IDCMP_CLOSEWINDOW,
                                WA_Flags,WFLG_ACTIVATE|WFLG_CLOSEGADGET|WFLG_DRAGBAR|WFLG_NOCAREREFRESH|WFLG_SMART_REFRESH|WFLG_RMBTRAP|WFLG_GIMMEZEROZERO,
                                TAG_DONE,0);
 if (PreviewWin)
 {
    SetPointer (PreviewWin,ZZZPointer,ZZZPH,ZZZPW,ZZZPXO,ZZZPYO);

    ElapsedTime = DrawFractal (PreviewWin,0,0,(WORD) (PreviewWin->GZZWidth - 1),(WORD) (PreviewWin->GZZHeight - 1));

    SetPointer (PreviewWin,ZoomPointer,ZPH,ZPW,ZPXO,ZPYO);

    ShowTime (Win,ElapsedTime);

    do { WaitPort (PreviewWin->UserPort);

         Message = (struct IntuiMessage *) GT_GetIMsg (PreviewWin->UserPort);

         MyClass = Message->Class;

         MyCode = Message->Code;

         GT_ReplyIMsg ((struct IntuiMessage *) Message);

         switch (MyClass)
         {
            case IDCMP_CLOSEWINDOW : Exit = TRUE;

                                     break;

            case IDCMP_RAWKEY      : if (MyCode == RAW_ESC) Exit = TRUE;

                                     break;
         }

       } while (Exit == FALSE);

    ClearPointer (PreviewWin);

    CloseWindow (PreviewWin);
 }

 else
 {
    Fail (PreviewWindowError);

    Error = TRUE;
 }

 return Error;
}

BOOL DrawFrame (struct Window *Win,WORD ZX,WORD ZY,WORD ZW,WORD ZH)
{
struct RastPort *RP = Win->RPort;

 if (ZX || ZY)
 {
    COORDINATE [0] = COORDINATE [6] = max ((ZX-ZW),0);

    COORDINATE [1] = COORDINATE [3] = max ((ZY-ZH),0);

    COORDINATE [2] = COORDINATE [4] = min ((ZX+ZW),(Win->Width - 1));

    COORDINATE [5] = COORDINATE [7] = min ((ZY+ZH),(Win->Height - 1));

    SetDrMd (RP,COMPLEMENT);

    Move (RP,COORDINATE [6],COORDINATE [7] - 1);

    PolyDraw (RP,PUNTI,COORDINATE);

    SetDrMd (RP,JAM1);

    return TRUE;
 }

 return FALSE;
}

BOOL FileRequest (struct Window *Win,STRPTR String)
{
struct FileRequester *MyFileReq;

static UBYTE File [30] = "Not_Yet_Implemented.Iff" , Dir [60] = "RAM:";

BOOL Save = FALSE;

 if (! (MyFileReq = AllocAslRequest (ASL_FileRequest,0))) return FALSE;

 if (Stricmp (String,"Save Iff")) Save = TRUE;

 if (! AslRequestTags (MyFileReq,ASLFR_Window,Win,ASLFR_SleepWindow,TRUE,ASLFR_TextAttr,&MyFontStruct,ASLFR_TitleText,String,

                                 ASLFR_InitialFile,File,ASLFR_InitialDrawer,Dir,ASLFR_DoSaveMode,Save,ASLFR_RejectIcons,TRUE,TAG_DONE,0)) return FALSE;

 sprintf (Dir,"%s",MyFileReq->rf_Dir);

 sprintf (File,"%s",MyFileReq->rf_File);

 FreeAslRequest (MyFileReq);

 if (Dir [strlen (Dir) - 1] == ':') sprintf (PATH,"%c%s%s%c",'"',Dir,File,'"');

 else sprintf (PATH,"%c%s%c%s%c",'"',Dir,'/',File,'"');

 return TRUE;
}

BOOL SMRequest (struct Screen *Scr,struct Window *Win)
{
struct ScreenModeRequester *SMReq;

BOOL NewScreen = FALSE;

WORD HScrX = Scr->Width >> 1 , HScrY = Scr->Height >> 1 , WinWidth = 310 , WinHeight = 180;

 if (SMReq = AllocAslRequest (ASL_ScreenModeRequest,0))
 {
    if (AslRequestTags (SMReq,ASLSM_Window,Win,
                              ASLSM_SleepWindow,TRUE,
                              ASLSM_TitleText,"ScreenMode requester",
                              ASLSM_InitialLeftEdge,HScrX - (WinWidth >> 1),
                              ASLSM_InitialTopEdge,HScrY - (WinHeight >> 1),
                              ASLSM_InitialWidth,WinWidth,
                              ASLSM_InitialHeight,WinHeight,
                              ASLSM_InitialDisplayID,GetVPModeID (ViewPortAddress (Win)),
                              ASLSM_InitialDisplayWidth,Win->Width,
                              ASLSM_InitialDisplayHeight,Win->Height,
                              ASLSM_InitialDisplayDepth,Scr->RastPort.BitMap->Depth,
                              ASLSM_InitialOverscanType,OVERSCAN,
                              ASLSM_InitialAutoScroll,A_SCROLL,
                              ASLSM_DoWidth,TRUE,
                              ASLSM_DoHeight,TRUE,
                              ASLSM_DoDepth,TRUE,
                              ASLSM_DoOverscanType,TRUE,
                              ASLSM_DoAutoScroll,TRUE,
                              ASLSM_PropertyFlags,0,
                              ASLSM_PropertyMask,DIPF_IS_DUALPF|DIPF_IS_PF2PRI|DIPF_IS_HAM,
                              ASLSM_MinWidth,320,
                              ASLSM_MinHeight,200,
                              TAG_DONE,0))
    {
       DISPLAY = SMReq->sm_DisplayID;

       WIDTH = (WORD) SMReq->sm_DisplayWidth;

       HEIGHT = (WORD) SMReq->sm_DisplayHeight;

       DEPTH = SMReq->sm_DisplayDepth;

       OVERSCAN = SMReq->sm_OverscanType;

       A_SCROLL = SMReq->sm_AutoScroll;

       FreeAslRequest (SMReq);

       NewScreen = TRUE;
    }
 }

 return NewScreen;
}

VOID SetMenuStart (struct Window *Win)
{

  OnMenu  (Win,FULLMENUNUM (0,0,NOSUB));

  OnMenu  (Win,FULLMENUNUM (0,2,NOSUB));

  OnMenu  (Win,FULLMENUNUM (0,3,NOSUB));

  OnMenu  (Win,FULLMENUNUM (0,5,NOSUB));

  OnMenu  (Win,FULLMENUNUM (0,7,NOSUB));

  OnMenu  (Win,FULLMENUNUM (1,0,NOSUB));

  OnMenu  (Win,FULLMENUNUM (1,1,NOSUB));

  OnMenu  (Win,FULLMENUNUM (1,2,NOSUB));

  OnMenu  (Win,FULLMENUNUM (2,0,NOSUB));

  OnMenu  (Win,FULLMENUNUM (2,2,NOSUB));

  OnMenu  (Win,FULLMENUNUM (2,4,NOSUB));

  OnMenu  (Win,FULLMENUNUM (2,6,NOSUB));

  OffMenu (Win,FULLMENUNUM (2,7,NOSUB));

  OnMenu  (Win,FULLMENUNUM (3,0,NOSUB));
}

VOID SetMenuStop (struct Window *Win)
{

  OffMenu  (Win,FULLMENUNUM (0,0,NOSUB));

  OffMenu  (Win,FULLMENUNUM (0,2,NOSUB));

  OffMenu  (Win,FULLMENUNUM (0,3,NOSUB));

  OffMenu  (Win,FULLMENUNUM (0,5,NOSUB));

  OffMenu  (Win,FULLMENUNUM (0,7,NOSUB));

  OffMenu  (Win,FULLMENUNUM (1,0,NOSUB));

  OffMenu  (Win,FULLMENUNUM (1,1,NOSUB));

  OffMenu  (Win,FULLMENUNUM (1,2,NOSUB));

  OffMenu  (Win,FULLMENUNUM (2,0,NOSUB));

  OffMenu  (Win,FULLMENUNUM (2,2,NOSUB));

  OffMenu  (Win,FULLMENUNUM (2,4,NOSUB));

  OffMenu  (Win,FULLMENUNUM (2,6,NOSUB));

  OnMenu   (Win,FULLMENUNUM (2,7,NOSUB));

  OffMenu  (Win,FULLMENUNUM (3,0,NOSUB));
}

ULONG ProcessMenu (struct Window *Win,UWORD Code)
{
struct MenuItem *Item;

ULONG Choice = 0L;

 while (Code != MENUNULL)
 {
  Item = ItemAddress (MAINMENU,Code);

  switch (MENUNUM (Code))
  {
        case 0:    switch (ITEMNUM (Code))
                   {
                        case 0: Choice |= ABOUT_MSG;

                                break;

                        case 2: Choice |= LOAD_MSG;

                                break;

                        case 3: Choice |= SAVE_MSG;

                                break;

                        case 5: Choice |= DUMP_MSG;

                                break;

                        case 7: Choice |= EXIT_MSG;
                   }
                   break;

        case 1:    switch (ITEMNUM (Code))
                   {
                        case 0: Choice |= TITLE_MSG;

                                break;

                        case 1: Choice |= COORDS_MSG;

                                break;

                        case 2: switch (SUBNUM (Code))
                                {
                                   case 0: ITERAZIONI = 15;

                                           break;

                                   case 1: ITERAZIONI = 31;

                                           break;

                                   case 2: ITERAZIONI = 63;

                                           break;

                                   case 3: ITERAZIONI = 127;

                                           break;

                                   case 4: ITERAZIONI = 255;

                                           break;

                                   case 5: ITERAZIONI = 511;

                                           break;

                                   case 6: ITERAZIONI = 1023;

                                           break;

                                   case 8: Choice |= ITER_MSG;

                                           break;
                                }
                                break;

                        case 3: switch (SUBNUM (Code))
                                {
                                   case 0: PRIORITY = -5;

                                           break;

                                   case 1: PRIORITY = -3;

                                           break;

                                   case 2: PRIORITY =  0;

                                           break;

                                   case 3: PRIORITY = +3;

                                           break;

                                   case 4: PRIORITY = +5;
                                }

                                SetTaskPri (FindTask (0),PRIORITY);

                                break;

                        case 4: switch (SUBNUM (Code))
                                {
                                   case 0: switch (CheckCPU (SysBase->AttnFlags))
                                           {
                                                case 68020: FUNCTION = Integer_20;

                                                            break;

                                                case 68030: FUNCTION = Integer_30;

                                                            break;

                                                case 68040: FUNCTION = Integer_40;

                                                            break;

                                                   default: FUNCTION = Integer_00;
                                           }
                                           break;

                                   case 1: switch (CheckCPU (SysBase->AttnFlags))
                                           {
                                                case 68020: FUNCTION = Real_20;

                                                            break;

                                                case 68030: FUNCTION = Real_30;

                                                            break;

                                                case 68040: FUNCTION = Real_40;

                                                            break;

                                                   default: FUNCTION = Real_00;
                                           }
                                           break;
                                }
                                break;
                   }
                   break;

        case 2: switch (ITEMNUM (Code))
                {
                   case 0: Choice |= PREVIEW_MSG;

                           break;

                   case 2: Choice |= REDRAW_MSG;

                           break;

                   case 4: Choice |= UNDO_MSG;

                           break;

                   case 6: Choice |= DRAW_MSG;

                           break;

                   case 7: Choice |= STOP_MSG;

                           break;
                }
                break;

        case 3: Choice |= NEWDISPLAY_MSG;

                break;
  }

 Code = Item->NextSelect;
 }

 return Choice;
}

VOID ProcessMouse (struct Window *Win,WORD CurMouseX,WORD CurMouseY)
{
static WORD MX1 = 0 , MY1 = 0 , W = 0 , H = 0 , MX2 = 0 , MY2 = 0;

UWORD MyCode;

ULONG MyClass;

struct IntuiMessage *Message;

   ModifyIDCMP (Win,IDCMP_MOUSEBUTTONS | IDCMP_MOUSEMOVE);

   SetMouseQueue (Win,10);

   if (NEWPICTURE) NEWPICTURE = FALSE;

   else DrawFrame (Win,MX1,MY1,W,H);

   MX1 = CurMouseX;

   MY1 = CurMouseY;

   W = H = INITIALZOOMDIM;

   DrawFrame (Win,MX1,MY1,W,H);

   FOREVER
   {
     WaitPort (Win->UserPort);

     Message = (struct IntuiMessage *) GT_GetIMsg (Win->UserPort);

     MyClass = Message->Class;

     MyCode = Message->Code;

     MX2 = Message->MouseX;

     MY2 = Message->MouseY;

     GT_ReplyIMsg ((struct IntuiMessage *) Message);

     if (MyClass == MOUSEMOVE)
     {
        DrawFrame (Win,MX1,MY1,W,H);

        W = abs (MX1 - MX2);

        H = abs (MY1 - MY2);

        if (W > H) (W = ScalerDiv (H,Win->Width,Win->Height));

        else (H = ScalerDiv (W,Win->Height,Win->Width));

        DrawFrame (Win,MX1,MY1,W,H);
     }

     else if (MyClass == MOUSEBUTTONS && MyCode != SELECTDOWN) break;
   }

   SetMouseQueue (Win,5);

   ModifyIDCMP (Win,IDCMP_STANDARD);
}

ULONG HandleEvents (struct Screen *Scr,struct Window *Win)
{
WORD MouseX , MouseY;

UWORD MyCode;

ULONG MyClass , ElapsedTime , Choice = 0L;

struct IntuiMessage *Message;

 SetPointer (Win,ZoomPointer,ZPH,ZPW,ZPXO,ZPYO);

 do {
      WaitPort (Win->UserPort);

      Message = (struct IntuiMessage *) GT_GetIMsg (Win->UserPort);

      MyClass = Message->Class;

      MyCode = Message->Code;

      MouseX = Message->MouseX;

      MouseY = Message->MouseY;

      GT_ReplyIMsg ((struct IntuiMessage *) Message);

      switch (MyClass)
      {
        case    IDCMP_MOUSEMOVE: sprintf (BAR_MESSAGE,"Real:%1.10lf Img:%1.10lfi",X1 + (abs (X2-X1) * (DOUBLE) MouseX / (DOUBLE) (Win->Width - 1)),Y2 - (abs (Y2-Y1) * (DOUBLE) MouseY / (DOUBLE) (Win->Height - 1)));

                                 SetWindowTitles (Win,(UBYTE *) ~0,BAR_MESSAGE);

                                 break;

        case IDCMP_MOUSEBUTTONS: if (MyCode == SELECTDOWN) ProcessMouse (Win,MouseX,MouseY);

                                 break;

        case     IDCMP_MENUPICK: Choice = ProcessMenu (Win,MyCode);

                                 if (Choice & TITLE_MSG)
                                 {
                                    TITLE = ! TITLE;

                                    ShowTitle (Scr,TITLE);
                                 }

                                 if (Choice & COORDS_MSG)
                                 {
                                    ModifyIDCMP (Win,0L);

                                    ClearMenuStrip (Win);

                                    ShowCoords (Scr,Win);

                                    ResetMenuStrip (Win,MAINMENU);

                                    ModifyIDCMP (Win,IDCMP_STANDARD);
                                 }

                                 if (Choice & ITER_MSG)
                                 {
                                    ModifyIDCMP (Win,0L);

                                    ClearMenuStrip (Win);

                                    ITERAZIONI = IntegerGad (Scr,Win,ITERAZIONI + 1) - 1;

                                    ResetMenuStrip (Win,MAINMENU);

                                    ModifyIDCMP (Win,IDCMP_STANDARD);
                                 }

                                 if (Choice & ABOUT_MSG)
                                 {
                                    ModifyIDCMP (Win,0L);

                                    ClearMenuStrip (Win);

                                    About (Win);

                                    ResetMenuStrip (Win,MAINMENU);

                                    ModifyIDCMP (Win,IDCMP_STANDARD);
                                 }

                                 if (Choice & STOP_MSG)
                                 {
                                    SetMenuStart (Win);

                                    SetPointer (Win,ZoomPointer,ZPH,ZPW,ZPXO,ZPYO);

                                    break;
                                 }

                                 if (Choice & SAVE_MSG)
                                 {
                                    ModifyIDCMP (Win,0L);

                                    ClearMenuStrip (Win);

                                    if (FileRequest (Win,"Save Iff"))
                                    {
                                       SetPointer (Win,ZZZPointer,ZZZPH,ZZZPW,ZZZPXO,ZZZPYO);

//                                       if (MyIlbm.ParseInfo.iff = AllocIFF ())
//                                       {
//                                          screensave (&MyIlbm,Scr,0,0,PATH);

//                                          FreeIFF (MyIlbm.ParseInfo.iff);
//                                       }

                                       SetPointer (Win,ZoomPointer,ZPH,ZPW,ZPXO,ZPYO);

                                    }

                                    ResetMenuStrip (Win,MAINMENU);

                                    ModifyIDCMP (Win,IDCMP_STANDARD);

                                    break;
                                 }

                                 if (Choice & LOAD_MSG)
                                 {
                                    ModifyIDCMP (Win,0L);

                                    ClearMenuStrip (Win);

                                    if (FileRequest (Win,"Load Iff"));

                                    ResetMenuStrip (Win,MAINMENU);

                                    ModifyIDCMP (Win,IDCMP_STANDARD);

                                    break;
                                 }

                                 if (Choice & DUMP_MSG)
                                 {
                                    ModifyIDCMP (Win,0L);

                                    ClearMenuStrip (Win);

                                    SetPointer (Win,ZZZPointer,ZZZPH,ZZZPW,ZZZPXO,ZZZPYO);

                                    ScreenDump (Scr,0,0,Win->Width,Win->Height,0,0);

                                    SetPointer (Win,ZoomPointer,ZPH,ZPW,ZPXO,ZPYO);

                                    ResetMenuStrip (Win,MAINMENU);

                                    ModifyIDCMP (Win,IDCMP_STANDARD);

                                    break;
                                 }

                                 if (Choice & PREVIEW_MSG)
                                 {
                                    if (NewCoords (Win,COORDINATE[0],COORDINATE[1],COORDINATE[4]-COORDINATE[6],COORDINATE[5]-COORDINATE[3]))
                                    {
                                        ModifyIDCMP (Win,0L);

                                        ClearMenuStrip (Win);

                                        Preview (Scr,Win,Win->Width >> 2,Win->Height >> 2,Win->Width - (Win->Width >> 2),Win->Height - (Win->Height >> 2));

                                        ResetMenuStrip (Win,MAINMENU);

                                        ModifyIDCMP (Win,IDCMP_STANDARD);

                                        Undo ();
                                    }

                                    break;
                                 }

                                 if (Choice & REDRAW_MSG)
                                 {
                                    SetRast (Win->RPort,NERO);

                                    SetMenuStop (Win);

                                    SetPointer (Win,ZZZPointer,ZZZPH,ZZZPW,ZZZPXO,ZZZPYO);

                                    ElapsedTime = DrawFractal (Win,Win->LeftEdge,Win->TopEdge,Win->Width-1,Win->Height-1);

                                    SetPointer (Win,ZoomPointer,ZPH,ZPW,ZPXO,ZPYO);

                                    SetMenuStart (Win);

                                    ShowTime (Win,ElapsedTime);

                                    NEWPICTURE = TRUE;

                                    break;
                                 }

                                 if (Choice & UNDO_MSG)
                                 {
                                    Undo ();

                                    SetRast (Win->RPort,NERO);

                                    SetPointer (Win,ZZZPointer,ZZZPH,ZZZPW,ZZZPXO,ZZZPYO);

                                    SetMenuStop (Win);

                                    ElapsedTime = DrawFractal (Win,Win->LeftEdge,Win->TopEdge,Win->Width-1,Win->Height-1);

                                    SetPointer (Win,ZoomPointer,ZPH,ZPW,ZPXO,ZPYO);

                                    SetMenuStart (Win);

                                    ShowTime (Win,ElapsedTime);

                                    NEWPICTURE = TRUE;

                                    break;
                                 }

                                 if (Choice & DRAW_MSG)
                                 {
                                    if (NewCoords (Win,COORDINATE[0],COORDINATE[1],COORDINATE[4]-COORDINATE[6],COORDINATE[5]-COORDINATE[3]))
                                    {
                                        SetRast (Win->RPort,NERO);

                                        SetMenuStop (Win);

                                        SetPointer (Win,ZZZPointer,ZZZPH,ZZZPW,ZZZPXO,ZZZPYO);

                                        ElapsedTime = DrawFractal (Win,Win->LeftEdge,Win->TopEdge,Win->Width-1,Win->Height-1);

                                        SetPointer (Win,ZoomPointer,ZPH,ZPW,ZPXO,ZPYO);

                                        SetMenuStart (Win);

                                        ShowTime (Win,ElapsedTime);

                                        NEWPICTURE = TRUE;
                                    }

                                    break;
                                 }

                                 break;

        case       IDCMP_RAWKEY: if (MyCode == RAW_ESC) Choice = EXIT_MSG;

                                 break;
      }

    } while (! ((Choice & EXIT_MSG) || (Choice & NEWDISPLAY_MSG)));

 return Choice;
}

UWORD ScreenDump (struct Screen *Scr,WORD ScrX,WORD ScrY,WORD ScrW,WORD ScrH,LONG DestCols,UWORD IOSpecial)
{
struct IODRPReq *IODrp;
struct MsgPort  *PrinterPort;
struct ViewPort *Vp;

UWORD Error = PDERR_BADDIMENSION;

if (! Scr) return Error;

if ((! DestCols) && (! IOSpecial))

 if ((! ScrX) && (! ScrY) && (ScrW == Scr->Width) && (ScrH == Scr->Height)) IOSpecial = SPECIAL_FULLCOLS | SPECIAL_ASPECT;

 else IOSpecial = SPECIAL_FRACCOLS | SPECIAL_ASPECT , DestCols = ((ScrW << 16) / Scr->Width) << 16;

if (PrinterPort = CreatePort (0,0))
{
   if (IODrp = (struct IODRPReq *) CreateExtIO (PrinterPort,sizeof (struct IODRPReq)))
   {
      if (! (Error = OpenDevice ("printer.device",0,(struct IORequest *) IODrp,0)))
      {
         Vp = &(Scr->ViewPort);
         IODrp->io_Command = PRD_DUMPRPORT;
         IODrp->io_RastPort = &(Scr->RastPort);
         IODrp->io_ColorMap = Vp->ColorMap;
         IODrp->io_Modes = (ULONG) Vp->Modes;
         IODrp->io_SrcX = ScrX;
         IODrp->io_SrcY = ScrY;
         IODrp->io_SrcWidth = ScrW;
         IODrp->io_SrcHeight = ScrH;
         IODrp->io_DestCols = DestCols;
         IODrp->io_Special = IOSpecial;

         Error = DoIO ((struct IORequest *)IODrp);

         CloseDevice ((struct IORequest *)IODrp);
      }
      DeleteExtIO ((struct IORequest *)IODrp);
   }
   DeletePort (PrinterPort);
}
return Error;
}

VOID Fail (UBYTE *ErrorString)
{
  DisplayAlert (RECOVERY_ALERT,ErrorString,50);
}

VOID main (VOID)
{
struct DosLibrary *DOSBase = (struct DosLibrary *) OpenLibrary ("dos.library",LIBVER);

struct IntuitionBase *IntuitionBase = (struct IntuitionBase *) OpenLibrary ("intuition.library",LIBVER);

struct GfxBase *GfxBase = (struct GfxBase *) OpenLibrary ("graphics.library",LIBVER);

struct Library *DiskfontBase = OpenLibrary ("diskfont.library",LIBVER);

struct Library *GadToolsBase = OpenLibrary ("gadtools.library",LIBVER);

struct Library *AslBase = OpenLibrary ("asl.library",1L+LIBVER);

struct Library *IFFParseBase = OpenLibrary ("iffparse.library",LIBVER);

struct Library *UtilityBase = OpenLibrary ("utility.library",LIBVER);

struct Library *MathIeeeDoubBasBase = OpenLibrary ("mathieeedoubbas.library",LIBVER);

DisplayInfoHandle DisplayHandle;

struct DimensionInfo DimensionInfo;

ULONG ElapsedTime;

if (DOSBase && IntuitionBase && GfxBase && DiskfontBase && GadToolsBase && AslBase && IFFParseBase && UtilityBase && MathIeeeDoubBasBase)
{
   if (DisplayHandle = FindDisplayInfo (DISPLAY))
   {
      if (GetDisplayInfoData (DisplayHandle,(UBYTE *) &DimensionInfo,sizeof (struct DimensionInfo),DTAG_DIMS,DISPLAY))
      {
         if (MAINMENU = CreateMenus (ProgMenu,TAG_DONE,0))
         {
            if (CheckFPU (SysBase->AttnFlags))
            {
               switch (CheckCPU (SysBase->AttnFlags))
               {
                      case 68040: FUNCTION = Real_40;

                                  break;

                      case 68030: FUNCTION = Real_30;

                                  break;

                      case 68020: FUNCTION = Real_20;

                                  break;

                      default   : FUNCTION = Real_00;
               }

               ItemAddress (MAINMENU,FULLMENUNUM (1,4,0))->Flags ^= CHECKED;

               ItemAddress (MAINMENU,FULLMENUNUM (1,4,1))->Flags |= CHECKED;
            }

            else   switch (CheckCPU (SysBase->AttnFlags))
                   {
                          case 68040: FUNCTION = Integer_40;

                                      break;

                          case 68030: FUNCTION = Integer_30;

                                      break;

                          case 68020: FUNCTION = Integer_20;

                                      break;

                          default   : FUNCTION = Integer_00;
                   }

            if (DimensionInfo.MaxDepth < DEPTH)
            {
               DEPTH = 6;

               DISPLAY = EXTRAHALFBRITE_KEY;

               ITERAZIONI = 63L;

               ItemAddress (MAINMENU,FULLMENUNUM (1,2,4))->Flags ^= CHECKED;

               ItemAddress (MAINMENU,FULLMENUNUM (1,2,2))->Flags |= CHECKED;
            }

            if (MakeDisplay (DEFAULT_MONITOR_ID | DISPLAY,WIDTH,HEIGHT,DEPTH,OVERSCAN,A_SCROLL))
            {
               SetPointer (MAINWIN,ZZZPointer,ZZZPH,ZZZPW,ZZZPXO,ZZZPYO);

               ElapsedTime = DrawFractal (MAINWIN,MAINWIN->LeftEdge,MAINWIN->TopEdge,MAINWIN->Width - 1,MAINWIN->Height - 1);

               SetPointer (MAINWIN,ZoomPointer,ZPH,ZPW,ZPXO,ZPYO);

               SetMenuStart (MAINWIN);

               ShowTime (MAINWIN,ElapsedTime);

               ModifyIDCMP (MAINWIN,0L);

               ClearMenuStrip (MAINWIN);

               About (MAINWIN);

               do
               {
                 ResetMenuStrip (MAINWIN,MAINMENU);

                 ModifyIDCMP (MAINWIN,IDCMP_STANDARD);

                 while (HandleEvents (MAINSCR,MAINWIN) & NEWDISPLAY_MSG)
                 {
                       if (SMRequest (MAINSCR,MAINWIN))
                       {
                          if (MakeDisplay (DISPLAY,WIDTH,HEIGHT,DEPTH,OVERSCAN,A_SCROLL))
                          {
                              SetMenuStop (MAINWIN);

                              SetPointer (MAINWIN,ZZZPointer,ZZZPH,ZZZPW,ZZZPXO,ZZZPYO);

                              ElapsedTime = DrawFractal (MAINWIN,MAINWIN->LeftEdge,MAINWIN->TopEdge,MAINWIN->Width - 1,MAINWIN->Height - 1);

                              SetPointer (MAINWIN,ZoomPointer,ZPH,ZPW,ZPXO,ZPYO);

                              SetMenuStart (MAINWIN);

                              ShowTime (MAINWIN,ElapsedTime);

                              NEWPICTURE = TRUE;
                          }

                          else break;
                       }
                 }

               ModifyIDCMP (MAINWIN,0L);

               ClearMenuStrip (MAINWIN);

               } while (! Quit (MAINWIN));

               if (MAINWIN)
               {
                  ClearPointer (MAINWIN);

                  CloseWindow  (MAINWIN);
               }

               if (MYFONT)     CloseFont (MYFONT);

               if (VINFO)      FreeVisualInfo (VINFO);

               if (MAINSCR)    CloseScreen (MAINSCR);
            }

            FreeMenus (MAINMENU);
         }

         else Fail (MenuError);

      }

      else Fail (DimensionInfoError);
   }

   else Fail (DisplayInfoError);
}

else Fail (MinKickVer);

if (UtilityBase) CloseLibrary (UtilityBase);

if (IFFParseBase) CloseLibrary (IFFParseBase);

if (AslBase) CloseLibrary (AslBase);

if (GadToolsBase) CloseLibrary (GadToolsBase);

if (DiskfontBase) CloseLibrary (DiskfontBase);

if (MathIeeeDoubBasBase) CloseLibrary (MathIeeeDoubBasBase);

if (GfxBase) CloseLibrary ((struct Library *) GfxBase);

if (IntuitionBase) CloseLibrary ((struct Library *) IntuitionBase);

if (DOSBase) CloseLibrary ((struct Library *) DOSBase);

exit (0);
}
