home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
Club Amiga de Montreal - CAM
/
CAM_CD_1.iso
/
files
/
350.lha
/
DiskSpeed_v3.0
/
DiskSpeedWindow.c
< prev
next >
Wrap
C/C++ Source or Header
|
1990-02-25
|
20KB
|
727 lines
/*
* DiskSpeed v3.0
* by
* Michael Sinz
*
* Copyright (c) 1989 by MKSoft Development
*
* MKSoft Development
* 163 Appledore Drive
* Downingtown, PA 19335
*
* Yes, this is yet another disk speed testing program, but with a few
* differences. It was designed to give the most accurate results of the
* true disk performance in the system. For this reason many of
* DiskSpeed's results may look either lower or higher than current disk
* performance tests.
*
* This program was thrown together in a few hours because I needed more
* accurate and consistent results for disk performance as seen from the
* application's standpoint. This program has now served its purpose and
* I am now giving it to the rest of the Amiga world to play with as long
* as all of the files remain together in unmodified form. (That is, the
* files DiskSpeed, DiskSpeed.info, DiskSpeed.c, DiskSpeedWindow.c,
* DiskSpeedWindow.h, MakeBoxes.c, MakeBoxes.h, StandardGadgets.c,
* StandardGadgets.h, RenderInfo.c, RenderInfo.h, DiskSpeed.doc, and
* MakeFile)
*
* Version 2.0 of this program added a few features and cleaned up the
* user interface. I hope you like this...
*
* Version 3.0 of this program added the performance stress and cleaned up
* some parts of the older code. (Fix to RenderInfo.c)
*
******************************************************************************
* *
* Reading legal mush can turn your brain into guacamole! *
* *
* So here is some of that legal mush: *
* *
* Permission is hereby granted to distribute this program's source *
* executable, and documentation for non-commercial purposes, so long as the *
* copyright notices are not removed from the sources, executable or *
* documentation. This program may not be distributed for a profit without *
* the express written consent of the author Michael Sinz. *
* *
* This program is not in the public domain. *
* *
* Fred Fish is expressly granted permission to distribute this program's *
* source and executable as part of the "Fred Fish freely redistributable *
* Amiga software library." *
* *
* Permission is expressly granted for this program and it's source to be *
* distributed as part of the Amicus Amiga software disks, and the *
* First Amiga User Group's Hot Mix disks. *
* *
******************************************************************************
*
* This is the window opening and definition code...
*/
#include <exec/types.h>
#include <exec/memory.h>
#include <devices/timer.h>
#include <intuition/intuition.h>
#include <graphics/gfxmacros.h>
#include <graphics/copper.h>
#include <hardware/custom.h>
#include <proto/all.h>
#include <string.h>
#include "RenderInfo.h"
#include "StandardGadgets.h"
#include "MakeBoxes.h"
#include "DiskSpeedWindow.h"
extern struct Custom __far custom;
#define WINDOWTEXT_SIZE 60
static char DiskSpeedTitle[14]="DiskSpeed 3.0";
static char WindowText[WINDOWTEXT_SIZE]="DiskSpeed 3.0 - Copyright (c) 1989,90 by MKSoft Development";
static char CPUstressTask[26]="DiskSpeed CPU Stress Task";
static char Dashes[10]="---------";
static char fontnam[11]="topaz.font";
static struct TextAttr TOPAZ80={fontnam,TOPAZ_EIGHTY,0,0};
#define TEXT_BUFFER_SIZE 1000L
#define NUM_COP_INS 12000
#define WINDOW_WIDTH 531
#define WINDOW_HEIGHT 177
#define REQ_X_SIZE 518
#define REQ_Y_SIZE 152
#define BOX_OUT 0
#define BOX_IN 1
struct BoxType
{
SHORT x1,y1;
SHORT x2,y2;
SHORT type;
};
struct Text_Info
{
SHORT x,y;
char *text;
};
struct Gadget_Info
{
SHORT x,y;
SHORT size;
SHORT flags;
USHORT ID;
char *text;
};
struct Result_Info
{
SHORT x,y;
};
static struct BoxType BoxTypes[NUM_BOXES]=
{
{0,0, WINDOW_WIDTH-1,WINDOW_HEIGHT-1, BOX_OUT},
{70,20, 249,31, BOX_IN},
{70,37, 524,48, BOX_IN},
{16,55, 516,102, BOX_IN},
{16,106, 265,154, BOX_IN},
{274,106, 373,154, BOX_IN},
{143,68, 226,98, BOX_IN},
{236,68, 319,98, BOX_IN},
{329,68, 412,98, BOX_IN},
{422,68, 505,98, BOX_IN},
{171,110, 254,150, BOX_IN},
{282,127, 365,137, BOX_IN}
};
static struct Text_Info TextInfo[NUM_TEXT]=
{
{8,22, "Device:"},
{8,39, "Comment"},
{265,22, "Test Intensity:"},
{24,59, "Buffer Size"},
{24,70, "Bytes/s Create"},
{24,80, "Bytes/s Write"},
{24,90, "Bytes/s Read"},
{197,59, "512"},
{282,59, "4096"},
{367,59, "32768"},
{452,59, "262144"},
{24,112, "Files/s Create"},
{24,122, "Files/s Open/Close"},
{24,132, "Files/s Scan"},
{24,142, "Files/s Delete"},
{288,118, "Seek/Read"},
{8,162, "Performance Stress:"},
{185,162, "DMA Contention"},
{368,162, "CPU Contention"}
};
static struct Gadget_Info GadgetInfo[NUM_GADGETS]=
{
{387,19, 41, GADGIMMEDIATE|TOGGLESELECT, GADGET_HIGH, "High"},
{435,19, 41, GADGIMMEDIATE|TOGGLESELECT, GADGET_MED, "Med"},
{483,19, 41, GADGIMMEDIATE|TOGGLESELECT, GADGET_LOW, "Low"},
{391,107, 116, RELVERIFY, GADGET_START, "Start Test"},
{391,124, 116, RELVERIFY, GADGET_SAVE, "Save Results"},
{391,141, 116, RELVERIFY, GADGET_PRINT, "Print Results"},
{300,159, 41, TOGGLESELECT, GADGET_DMA, "DMA"},
{483,159, 41, TOGGLESELECT, GADGET_CPU, "CPU"}
};
static struct Result_Info ResultInfo[NUM_RESULTS]=
{
{149,70}, {149,80}, {149,90},
{242,70}, {242,80}, {242,90},
{335,70}, {335,80}, {335,90},
{428,70}, {428,80}, {428,90},
{177,112}, {177,122}, {177,132}, {177,142},
{288,129}
};
/*
* This define is for the Write_Results routine...
*/
#define MYCAT(z,y,x) for (y=x;*y;*z++=*y++)
#define MYCATNEWLINE(x) *x++='\n'
#define MYCATTAB(x) *x++='\t'
#define MYCATSPACE(x) *x++=' '
/*
* This routine builds a string of the results and then writes it to
* the file passed...
*/
VOID Write_Results(struct MyWindow *MyWindow,BPTR TheFile)
{
register char *t;
register char *h;
register char *Buffer;
register struct Gadget *gad;
register short flag=FALSE;
if (t=Buffer=AllocMem(TEXT_BUFFER_SIZE,MEMF_PUBLIC|MEMF_CLEAR))
{
/* Title and device name */
MYCATNEWLINE(t);
MYCAT(t,h,WindowText);
MYCATNEWLINE(t);
MYCATNEWLINE(t);
MYCAT(t,h,TextInfo[0].text);
MYCATTAB(t);
MYCAT(t,h,MyWindow->DeviceName);
MYCATNEWLINE(t);
MYCATNEWLINE(t);
if (MyWindow->Comment[0])
{
MYCAT(t,h,TextInfo[1].text);
MYCATTAB(t);
MYCAT(t,h,MyWindow->Comment);
MYCATNEWLINE(t);
MYCATNEWLINE(t);
}
/* Tell of the test intensity... */
MYCAT(t,h,TextInfo[2].text);
MYCATSPACE(t);
switch(MyWindow->TestFlag)
{
case GADGET_HIGH: MYCAT(t,h,GadgetInfo[0].text);
break;
case GADGET_MED: MYCAT(t,h,GadgetInfo[1].text);
MYCATSPACE(t);
break;
case GADGET_LOW: MYCAT(t,h,GadgetInfo[2].text);
MYCATSPACE(t);
break;
}
/* Show the DMA and CPU settings... */
MYCATSPACE(t);
MYCATSPACE(t);
MYCAT(t,h,TextInfo[16].text);
gad=MyWindow->Window->FirstGadget;
while (gad)
{
if (gad->Flags & SELECTED)
{
if (GADGET_DMA==gad->GadgetID)
{
MYCATSPACE(t);
if (flag)
{
*t++='&';
MYCATSPACE(t);
}
MYCAT(t,h,TextInfo[17].text);
flag=TRUE;
}
else if (GADGET_CPU==gad->GadgetID)
{
MYCATSPACE(t);
if (flag)
{
*t++='&';
MYCATSPACE(t);
}
MYCAT(t,h,TextInfo[18].text);
flag=TRUE;
}
}
gad=gad->NextGadget;
}
if (!flag) MYCAT(t,h," None");
MYCATNEWLINE(t);
MYCATNEWLINE(t);
/* File Create */
MYCAT(t,h,MyWindow->MyResults[RESULTS_CREATE].text);
MYCATSPACE(t);
MYCAT(t,h,TextInfo[11].text);
MYCATNEWLINE(t);
/* File Open/Close */
MYCAT(t,h,MyWindow->MyResults[RESULTS_OPEN_CLOSE].text);
MYCATSPACE(t);
MYCAT(t,h,TextInfo[12].text);
MYCATNEWLINE(t);
/* File Scan */
MYCAT(t,h,MyWindow->MyResults[RESULTS_DIR_SCAN].text);
MYCATSPACE(t);
MYCAT(t,h,TextInfo[13].text);
MYCATNEWLINE(t);
/* File Delete */
MYCAT(t,h,MyWindow->MyResults[RESULTS_DELETE].text);
MYCATSPACE(t);
MYCAT(t,h,TextInfo[14].text);
MYCATNEWLINE(t);
MYCATNEWLINE(t);
/* Seek and Read */
MYCAT(t,h,MyWindow->MyResults[RESULTS_SEEK_READ].text);
MYCATSPACE(t);
MYCAT(t,h,TextInfo[15].text);
MYCATNEWLINE(t);
MYCATNEWLINE(t);
/* Titles... */
MYCAT(t,h,TextInfo[3].text);
MYCATTAB(t);
MYCAT(t,h,TextInfo[7].text);
MYCATTAB(t);
MYCATTAB(t);
MYCAT(t,h,TextInfo[8].text);
MYCATTAB(t);
MYCATTAB(t);
MYCAT(t,h,TextInfo[9].text);
MYCATTAB(t);
MYCATTAB(t);
MYCAT(t,h,TextInfo[10].text);
MYCATNEWLINE(t);
/* Dash it all... :-) */
MYCAT(t,h,Dashes);
MYCATTAB(t);
MYCAT(t,h,Dashes);
MYCATTAB(t);
MYCAT(t,h,Dashes);
MYCATTAB(t);
MYCAT(t,h,Dashes);
MYCATTAB(t);
MYCAT(t,h,Dashes);
MYCATNEWLINE(t);
/* Create Speed */
MYCAT(t,h,TextInfo[4].text);
MYCATTAB(t);
MYCAT(t,h,MyWindow->MyResults[RESULTS_512_CREATE].text);
MYCATTAB(t);
MYCAT(t,h,MyWindow->MyResults[RESULTS_4096_CREATE].text);
MYCATTAB(t);
MYCAT(t,h,MyWindow->MyResults[RESULTS_32768_CREATE].text);
MYCATTAB(t);
MYCAT(t,h,MyWindow->MyResults[RESULTS_262144_CREATE].text);
MYCATNEWLINE(t);
/* Write Speed */
MYCAT(t,h,TextInfo[5].text);
MYCATTAB(t);
MYCAT(t,h,MyWindow->MyResults[RESULTS_512_WRITE].text);
MYCATTAB(t);
MYCAT(t,h,MyWindow->MyResults[RESULTS_4096_WRITE].text);
MYCATTAB(t);
MYCAT(t,h,MyWindow->MyResults[RESULTS_32768_WRITE].text);
MYCATTAB(t);
MYCAT(t,h,MyWindow->MyResults[RESULTS_262144_WRITE].text);
MYCATNEWLINE(t);
/* Read Speed */
MYCAT(t,h,TextInfo[6].text);
MYCATTAB(t);
MYCAT(t,h,MyWindow->MyResults[RESULTS_512_READ].text);
MYCATTAB(t);
MYCAT(t,h,MyWindow->MyResults[RESULTS_4096_READ].text);
MYCATTAB(t);
MYCAT(t,h,MyWindow->MyResults[RESULTS_32768_READ].text);
MYCATTAB(t);
MYCAT(t,h,MyWindow->MyResults[RESULTS_262144_READ].text);
MYCATNEWLINE(t);
MYCATNEWLINE(t);
MYCATNEWLINE(t);
/* Now, all we have to do is write the sucker... */
Write(TheFile,Buffer,t-Buffer);
FreeMem(Buffer,TEXT_BUFFER_SIZE);
}
}
VOID __saveds CPU_Stress_Code(VOID)
{
char test1[WINDOWTEXT_SIZE];
char test2[WINDOWTEXT_SIZE];
for(;;)
{
strcpy(test1,WindowText);
strcpy(test2,test1);
}
}
VOID CreateCopper(struct MyWindow *MyWin)
{
register SHORT loop;
register SHORT colour;
register struct ViewPort *vp;
register struct UCopList *ucop;
register ULONG mask;
vp=ViewPortAddress(MyWin->Window);
colour=GetRGB4(vp->ColorMap,0);
if (ucop=AllocMem(sizeof(struct UCopList),MEMF_PUBLIC|MEMF_CLEAR))
{
MyWin->DMAstress=ucop;
CINIT(ucop,NUM_COP_INS+2);
CWAIT(ucop,12,0);
mask=0x04044004;
for (loop=0;loop<NUM_COP_INS;loop++)
{
colour^=(0xFFF & mask);
mask=(mask << 4) | (mask >> 28);
CMOVE(ucop,custom.color[0],colour);
}
CEND(ucop);
Forbid();
vp->UCopIns=ucop;
Permit();
RethinkDisplay();
}
}
VOID Stress_On(struct MyWindow *MyWin)
{
register struct Gadget *gad;
gad=MyWin->Window->FirstGadget;
while (gad)
{
if (gad->Flags & SELECTED)
{
if (GADGET_DMA==gad->GadgetID)
{
CreateCopper(MyWin);
}
else if (GADGET_CPU==gad->GadgetID)
{
MyWin->CPUstress=CreateTask(CPUstressTask,0L,CPU_Stress_Code,1000L);
}
}
gad=gad->NextGadget;
}
}
VOID Stress_Off(struct MyWindow *MyWin)
{
if (MyWin->CPUstress)
{
RemTask(MyWin->CPUstress);
MyWin->CPUstress=NULL;
}
if (MyWin->DMAstress)
{
FreeVPortCopLists(ViewPortAddress(MyWin->Window));
RemakeDisplay();
MyWin->DMAstress=NULL;
}
}
VOID CloseMyWindow(struct MyWindow *MyWin)
{
if (MyWin)
{
if (MyWin->Window)
{
if (MyWin->DragGadget) RemDragGadget(MyWin->DragGadget);
if (MyWin->FrontBackGadget) RemFrontBackGadget(MyWin->FrontBackGadget);
if (MyWin->CloseGadget) RemCloseGadget(MyWin->CloseGadget);
CloseWindow(MyWin->Window);
}
FreeMem(MyWin,sizeof(struct MyWindow));
}
}
struct MyWindow *OpenMyWindow(struct RenderInfo *ri)
{
register SHORT loop;
register struct MyWindow *MyWin;
register struct Border *MyBorder;
register struct IntuiText *itext;
register struct Gadget *gad;
struct NewWindow nw;
if (MyWin=AllocMem(sizeof(struct MyWindow),MEMF_PUBLIC|MEMF_CLEAR))
{
/* First, set up the requester structures... */
MyWin->Req.LeftEdge=7;
MyWin->Req.TopEdge=19;
MyWin->Req.Width=REQ_X_SIZE;
MyWin->Req.Height=REQ_Y_SIZE;
MyWin->Req.BackFill=ri->BackPen;
MyWin->Req.ReqGadget=&(MyWin->ReqGadget);
MyWin->ReqGadget.Width=REQ_X_SIZE;
MyWin->ReqGadget.Height=REQ_Y_SIZE;
MyWin->ReqGadget.Flags=GADGHIMAGE;
MyWin->ReqGadget.Activation=RELVERIFY;
MyWin->ReqGadget.GadgetType=BOOLGADGET|REQGADGET;
MyWin->ReqGadget.GadgetRender=(APTR)&(MyWin->ReqBorders[0]);
MyWin->ReqGadget.SelectRender=(APTR)&(MyWin->ReqBorders[2]);
MyWin->ReqGadget.GadgetText=&(MyWin->ReqIText);
MyWin->ReqGadget.GadgetID=GADGET_REQ;
MyWin->ReqBorders[0].NextBorder=&(MyWin->ReqBorders[1]);
MyWin->ReqBorders[2].NextBorder=&(MyWin->ReqBorders[3]);
MyWin->ReqBorders[0].XY=MyWin->ReqBorders[2].XY=MyWin->ReqVector1;
MyWin->ReqBorders[1].XY=MyWin->ReqBorders[3].XY=MyWin->ReqVector2;
for (loop=0;loop<4;loop++)
{
MyWin->ReqBorders[loop].Count=8;
MyWin->ReqBorders[loop].DrawMode=JAM1;
}
MyWin->ReqBorders[0].FrontPen=MyWin->ReqBorders[3].FrontPen=ri->Highlight;
MyWin->ReqBorders[1].FrontPen=MyWin->ReqBorders[2].FrontPen=ri->Shadow;
FillTopLeftDouble_Border(&(MyWin->ReqBorders[0]),REQ_X_SIZE,REQ_Y_SIZE);
FillBottomRightDouble_Border(&(MyWin->ReqBorders[1]),REQ_X_SIZE,REQ_Y_SIZE);
MyWin->ReqIText.FrontPen=ri->TextPen;
MyWin->ReqIText.DrawMode=JAM1;
MyWin->ReqIText.TopEdge=(REQ_Y_SIZE>>1)-8;
MyWin->ReqIText.ITextFont=&TOPAZ80;
/* Now for the window gadgets... */
gad=&(MyWin->Detail);
gad->Flags=GADGHNONE;
gad->GadgetType=BOOLGADGET;
nw.LeftEdge=20;
nw.TopEdge=11;
nw.Width=WINDOW_WIDTH;
nw.Height=WINDOW_HEIGHT;
nw.DetailPen=-1;
nw.BlockPen=-1;
nw.IDCMPFlags=GADGETDOWN|GADGETUP|CLOSEWINDOW|ACTIVEWINDOW;
nw.Flags=SIMPLE_REFRESH|BORDERLESS|ACTIVATE|NOCAREREFRESH|RMBTRAP;
nw.FirstGadget=gad;
nw.CheckMark=NULL;
nw.Title=NULL;
nw.Type=WBENCHSCREEN;
MyBorder=NULL;
for (loop=0;loop<(NUM_BOXES*2);loop++)
{
MyWin->Details[loop].Border.NextBorder=MyBorder;
MyBorder=&(MyWin->Details[loop].Border);
MyBorder->XY=MyWin->Details[loop].Vectors;
MyBorder->FrontPen=ri->Highlight;
MyBorder->DrawMode=JAM1;
MyBorder->Count=5;
}
gad->GadgetRender=(APTR)MyBorder;
for (loop=0;loop<NUM_BOXES;loop++)
{
MyWin->Details[loop*2].Border.LeftEdge=BoxTypes[loop].x1;
MyWin->Details[loop*2].Border.TopEdge=BoxTypes[loop].y1;
FillTopLeft_Border(&(MyWin->Details[loop*2].Border),
BoxTypes[loop].x2-BoxTypes[loop].x1+1,
BoxTypes[loop].y2-BoxTypes[loop].y1+1);
if (BOX_IN==BoxTypes[loop].type) MyWin->Details[loop*2].Border.FrontPen=ri->Shadow;
MyWin->Details[loop*2+1].Border.LeftEdge=BoxTypes[loop].x1;
MyWin->Details[loop*2+1].Border.TopEdge=BoxTypes[loop].y1;
FillBottomRight_Border(&(MyWin->Details[loop*2+1].Border),
BoxTypes[loop].x2-BoxTypes[loop].x1+1,
BoxTypes[loop].y2-BoxTypes[loop].y1+1);
if (BOX_OUT==BoxTypes[loop].type) MyWin->Details[loop*2+1].Border.FrontPen=ri->Shadow;
}
itext=NULL;
for (loop=NUM_RESULTS-1;loop>=0;loop--)
{
MyWin->MyResults[loop].IntuiText.NextText=itext;
itext=&(MyWin->MyResults[loop].IntuiText);
itext->FrontPen=ri->TextPen;
itext->BackPen=ri->BackPen;
itext->DrawMode=JAM2;
itext->LeftEdge=ResultInfo[loop].x;
itext->TopEdge=ResultInfo[loop].y;
itext->ITextFont=&TOPAZ80;
itext->IText=MyWin->MyResults[loop].text;
}
for (loop=0;loop<NUM_TEXT;loop++)
{
MyWin->TextDetails[loop].NextText=itext;
itext=&(MyWin->TextDetails[loop]);
itext->FrontPen=ri->TextPen;
itext->DrawMode=JAM1;
itext->LeftEdge=TextInfo[loop].x;
itext->TopEdge=TextInfo[loop].y;
itext->ITextFont=&TOPAZ80;
itext->IText=TextInfo[loop].text;
}
gad->GadgetText=itext;
for (loop=0;loop<NUM_GADGETS;loop++)
{
gad->NextGadget=&(MyWin->MyGadgets[loop].Gadget);
gad=gad->NextGadget;
gad->LeftEdge=GadgetInfo[loop].x;
gad->TopEdge=GadgetInfo[loop].y;
gad->Width=GadgetInfo[loop].size;
gad->Height=14;
gad->Flags=GADGHIMAGE;
gad->Activation=GadgetInfo[loop].flags;
gad->GadgetType=BOOLGADGET;
gad->GadgetRender=(APTR)&(MyWin->MyGadgets[loop].Borders[0]);
gad->SelectRender=(APTR)&(MyWin->MyGadgets[loop].Borders[2]);
gad->GadgetText=&(MyWin->MyGadgets[loop].IntuiText);
gad->GadgetID=GadgetInfo[loop].ID;
if (GadgetInfo[loop].ID==GADGET_MED)
{
gad->Flags|=SELECTED;
MyWin->TestFlag=GadgetInfo[loop].ID;
}
MyWin->MyGadgets[loop].Borders[0].NextBorder=&(MyWin->MyGadgets[loop].Borders[1]);
MyWin->MyGadgets[loop].Borders[2].NextBorder=&(MyWin->MyGadgets[loop].Borders[3]);
MyWin->MyGadgets[loop].Borders[0].DrawMode=JAM1;
MyWin->MyGadgets[loop].Borders[1].DrawMode=JAM1;
MyWin->MyGadgets[loop].Borders[2].DrawMode=JAM1;
MyWin->MyGadgets[loop].Borders[3].DrawMode=JAM1;
MyWin->MyGadgets[loop].Borders[0].FrontPen=ri->Highlight;
MyWin->MyGadgets[loop].Borders[1].FrontPen=ri->Shadow;
MyWin->MyGadgets[loop].Borders[2].FrontPen=ri->Shadow;
MyWin->MyGadgets[loop].Borders[3].FrontPen=ri->Highlight;
MyWin->MyGadgets[loop].Borders[0].XY=MyWin->MyGadgets[loop].Vectors1;
MyWin->MyGadgets[loop].Borders[1].XY=MyWin->MyGadgets[loop].Vectors2;
MyWin->MyGadgets[loop].Borders[2].XY=MyWin->MyGadgets[loop].Vectors1;
MyWin->MyGadgets[loop].Borders[3].XY=MyWin->MyGadgets[loop].Vectors2;
MyWin->MyGadgets[loop].Borders[0].Count=8;
MyWin->MyGadgets[loop].Borders[1].Count=8;
MyWin->MyGadgets[loop].Borders[2].Count=8;
MyWin->MyGadgets[loop].Borders[3].Count=8;
FillTopLeftDouble_Border(&(MyWin->MyGadgets[loop].Borders[0]),GadgetInfo[loop].size,14);
FillBottomRightDouble_Border(&(MyWin->MyGadgets[loop].Borders[1]),GadgetInfo[loop].size,14);
MyWin->MyGadgets[loop].IntuiText.TopEdge=3;
MyWin->MyGadgets[loop].IntuiText.FrontPen=ri->TextPen;
MyWin->MyGadgets[loop].IntuiText.DrawMode=JAM1;
MyWin->MyGadgets[loop].IntuiText.ITextFont=&TOPAZ80;
MyWin->MyGadgets[loop].IntuiText.IText=GadgetInfo[loop].text;
MyWin->MyGadgets[loop].IntuiText.LeftEdge=
(GadgetInfo[loop].size-IntuiTextLength(&(MyWin->MyGadgets[loop].IntuiText))) >> 1;
}
gad->NextGadget=&(MyWin->DeviceGadget);
gad=gad->NextGadget;
gad->LeftEdge=72;
gad->TopEdge=22;
gad->Width=176;
gad->Height=9;
gad->Activation=RELVERIFY;
gad->GadgetType=STRGADGET;
gad->SpecialInfo=(APTR)&(MyWin->DeviceGadgetInfo);
gad->GadgetID=GADGET_STRING;
gad->UserData=(APTR)&(MyWin->CommentGadget);
MyWin->DeviceGadgetInfo.Buffer=MyWin->DeviceName;
MyWin->DeviceGadgetInfo.MaxChars=32;
gad->NextGadget=&(MyWin->CommentGadget);
gad=gad->NextGadget;
gad->LeftEdge=72;
gad->TopEdge=39;
gad->Width=451;
gad->Height=9;
gad->Activation=RELVERIFY;
gad->GadgetType=STRGADGET;
gad->SpecialInfo=(APTR)&(MyWin->CommentGadgetInfo);
gad->GadgetID=GADGET_STRING;
gad->UserData=(APTR)&(MyWin->DeviceGadget);
MyWin->CommentGadgetInfo.Buffer=MyWin->Comment;
MyWin->CommentGadgetInfo.MaxChars=80;
gad->NextGadget=&(MyWin->Background);
gad=gad->NextGadget;
gad->Flags=GADGHNONE|GADGIMAGE;
gad->GadgetType=BOOLGADGET;
gad->GadgetRender=(APTR)&(MyWin->Image_Background);
MyWin->Image_Background.Width=WINDOW_WIDTH;
MyWin->Image_Background.Height=WINDOW_HEIGHT;
MyWin->Image_Background.PlaneOnOff=ri->BackPen;
loop=FALSE;
if (MyWin->Window=OpenWindow(&nw))
if (MyWin->CloseGadget=AddCloseGadget(MyWin->Window,ri,7,3))
if (MyWin->FrontBackGadget=AddFrontBackGadget(MyWin->Window,ri,473,3))
if (MyWin->DragGadget=AddDragGadget(MyWin->Window,ri,DiskSpeedTitle,33,3,438))
{
loop=TRUE;
}
if (!loop)
{
CloseMyWindow(MyWin);
MyWin=NULL;
}
else SetWindowTitles(MyWin->Window,(UBYTE *)-1L,WindowText);
}
return(MyWin);
}