void amiga_init (char *dir)
{
if ((DefaultPubScreen = LockPubScreen (0)) == 0)
exit (1);
screen_ratio (DefaultPubScreen);
char prog_name[256];
static char font_name[MAXFONTPATH];
char *font_desc, *name_ptr;
static WORD pens[] =
{-1};
static struct TextAttr font =
{NULL, 0, FS_NORMAL, 0};
int window = 0;
if (Icon == NULL)
{
if (GetProgramName (prog_name, 256))
Icon = GetDiskObject (prog_name);
}
if (Icon)
{
if (FindToolType (Icon->do_ToolTypes, "WINDOW"))
window = 1;
if (font_desc = FindToolType (Icon->do_ToolTypes, "FONT"))
{
strcpy (font_name, font_desc);
if (name_ptr = strrchr (font_name, '/'))
{
font.ta_Name = font_name;
font.ta_YSize = atoi (name_ptr + 1);
strcpy (name_ptr, ".font");
}
}
if (font.ta_Name)
Font = OpenDiskFont (&font);
}
if (Font == NULL)
{
font.ta_Name = "topaz.font";
font.ta_YSize = 8;
Font = OpenFont (&font);
}
if (window == 0)
{
if ((Screen = OpenScreenTags (0,
SA_Pens, pens,
SA_DisplayID, GetVPModeID (&DefaultPubScreen->ViewPort),
SA_Overscan, OSCAN_TEXT,
SA_Depth, 2,
SA_Type, CUSTOMSCREEN | AUTOSCROLL,
SA_Font, &font,
SA_Title, TitleBar, TAG_DONE)) == 0)
exit (1);
}
if ((Window = OpenWindowTags (0,
WA_Left, 0,
WA_Top, Screen ? 2 : DefaultPubScreen->BarHeight + 1,
WA_Width, Screen ? Screen->Width : ScreenWidth,
WA_Height, Screen ? Screen->Height - 2 : ScreenHeight - DefaultPubScreen->BarHeight - 1,
WA_SmartRefresh, 1,
WA_NewLookMenus, 1,
WA_AutoAdjust, 1,
WA_Borderless, Screen ? 1 : 0,
WA_Backdrop, Screen ? 1 : 0,
WA_Activate, 1,
WA_CloseGadget, Screen ? 0 : 1,
WA_DragBar, Screen ? 0 : 1,
WA_DepthGadget, Screen ? 0 : 1,
WA_SizeGadget, Screen ? 0 : 1,
WA_SizeBBottom, Screen ? 0 : 1,
WA_Title, TitleBar,
WA_ScreenTitle, TitleBar,
WA_IDCMP, IDCMP_RAWKEY | IDCMP_VANILLAKEY | IDCMP_MENUPICK | IDCMP_CLOSEWINDOW | IDCMP_CHANGEWINDOW,
Screen ? WA_CustomScreen : WA_PubScreen, Screen ? Screen : DefaultPubScreen,
TAG_DONE)) == 0)
exit (1);
ThisProcess = (struct Process *)FindTask(0);
OldWindowPtr = ThisProcess->pr_WindowPtr;
ThisProcess->pr_WindowPtr = Window;
if ((Visual = GetVisualInfo (Window->WScreen, TAG_DONE)) == 0)
exit (1);
if ((Menus = CreateMenus (NewMenus, GTMN_NewLookMenus, TRUE, TAG_DONE)) == 0)
exit (1);
LayoutMenus (Menus, Visual, GTMN_NewLookMenus, TRUE, TAG_DONE);
SetMenuStrip (Window, Menus);
if ((GameReq = alloc_freq (dir)) == 0)
exit (1);
if ((SaveReq = alloc_freq (dir)) == 0)
exit (1);
if ((ScriptReq = alloc_freq (dir)) == 0)
exit (1);
RastPort = Window->RPort;
SetDrMd (RastPort, JAM2);
SetAPen (RastPort, 1);
SetBPen (RastPort, 0);
SetFont (RastPort, Font);
DisplayHeight = ((Window->Height - Window->BorderTop - Window->BorderBottom) / RastPort->TxHeight) - 1;
PreviousHeight = DisplayHeight;
reset_cursor ();
}
// Show box for rubber-banding
void backdrop_rubber_band(BackdropInfo *info,BOOL sel)
{
UBYTE mode;
struct RastPort *rp;
// Do selections
if (sel) backdrop_select_area(info,2);
// Get rastport
rp=info->window->RPort;
// Save draw mode
mode=rp->DrawMode;
// Set complement and dash pattern
SetDrMd(rp,COMPLEMENT);
SetDrPt(rp,0xf0f0);
// Draw rectangle
Move(rp,info->select.MinX,info->select.MinY);
Draw(rp,info->select.MaxX,info->select.MinY);
Draw(rp,info->select.MaxX,info->select.MaxY);
Draw(rp,info->select.MinX,info->select.MaxY);
Draw(rp,info->select.MinX,info->select.MinY+((info->select.MinY<info->select.MaxY)?1:-1));
// Restore old mode and pattern
SetDrMd(rp,mode);
SetDrPt(rp,0xffff);
}
// Highlight button
void buttons_highlight_button(Buttons *buttons,short state,short do_corners)
{
short ret=0;
// Redraw imagery
if (do_corners!=-1 && (state==1 || !(buttons->flags&BUTTONF_NO_ALTIMAGE)))
{
if (!(ret=buttons_draw_button(
buttons,
buttons->button_sel_button,
buttons->button_sel_col,
buttons->button_sel_row,
buttons->button_sel_which,
state,0)) && state && 0) buttons->flags|=BUTTONF_NO_ALTIMAGE;
}
else buttons->flags&=~BUTTONF_NO_ALTIMAGE;
// Redraw border
if (!(buttons_draw_border(
buttons,
buttons->button_sel_button,
buttons->button_sel_col,
buttons->button_sel_row,
state,do_corners,0)) && !ret && state)
{
short x,y;
// We must be borderless with no alternate imagery
// Calculate column/row to highlight
x=buttons->button_sel_col-buttons->button_left;
y=buttons->button_sel_row-buttons->button_top;
// See if button is visible
if (x>=0 && x<buttons->button_cols &&
y>=0 && y<buttons->button_rows)
{
// Get position
x=buttons->internal.Left+x*buttons->button_width;
y=buttons->internal.Top+y*buttons->button_height;
// Set Complement mode
SetDrMd(buttons->window->RPort,COMPLEMENT);
// Highlight button
RectFill(
buttons->window->RPort,
x,y,
x+buttons->button_width-1,y+buttons->button_height-1);
// Set back to JAM1
SetDrMd(buttons->window->RPort,JAM1);
}
}
}
void cursor (int under)
{
int size;
os_flush ();
size = (under == 0) ? RastPort->TxWidth : char_len (under);
SetDrMd (RastPort, COMPLEMENT);
rect (RastPort->cp_x, RastPort->cp_y,
RastPort->cp_x + size - 1, RastPort->cp_y + RastPort->TxHeight - 1, 0);
SetDrMd (RastPort, JAM2);
}
/// DrawArea
Local
VOID DrawArea( FRAME *frame, Point *coords, WORD nPoints )
{
struct Selection *selection = &frame->selection;
DISPLAY *d = frame->disp;
struct RastPort *rPort = d->win->RPort;
struct IBox *abox;
WORD x,y, winwidth, winheight, xoffset, yoffset;
int i;
if( selection->nVertices > 2 ) {
GetAttr( AREA_AreaBox, d->RenderArea, (ULONG *) &abox );
winwidth = abox->Width;
winheight = abox->Height;
xoffset = abox->Left;
yoffset = abox->Top;
SetDrMd(rPort, COMPLEMENT);
SetDrPt(rPort, (UWORD) frame->disp->selpt); // Uses just lower 16 bits
x = MULS16((selection->vertices[0].x - frame->zoombox.Left),winwidth) / frame->zoombox.Width + xoffset;
y = MULS16((selection->vertices[0].y - frame->zoombox.Top),winheight) / frame->zoombox.Height + yoffset;
Move( rPort, x, y );
for( i = 1; i < selection->nVertices; i++ ) {
x = MULS16((selection->vertices[i].x - frame->zoombox.Left),winwidth) / frame->zoombox.Width + xoffset;
y = MULS16((selection->vertices[i].y - frame->zoombox.Top),winheight) / frame->zoombox.Height + yoffset;
Draw( rPort, x, y );
}
}
}
void
ShowClipValues(struct Window *nw)
{
char buf[50];
struct Gadget *gd;
SetAPen(nw->RPort, 5);
SetBPen(nw->RPort, amii_otherBPen);
SetDrMd(nw->RPort, JAM2);
sprintf(buf, "%d ", mxsize);
gd = &ClipXSIZE;
Move(nw->RPort, gd->LeftEdge + (nw->Width + gd->Width) + 8,
gd->TopEdge + nw->RPort->TxBaseline);
Text(nw->RPort, buf, strlen(buf));
sprintf(buf, "%d ", mysize);
gd = &ClipYSIZE;
Move(nw->RPort, gd->LeftEdge + (nw->Width + gd->Width) + 8,
gd->TopEdge + nw->RPort->TxBaseline);
Text(nw->RPort, buf, strlen(buf));
sprintf(buf, "%d ", xclipbord);
gd = &ClipXCLIP;
Move(nw->RPort, gd->LeftEdge + (nw->Width + gd->Width) + 8,
gd->TopEdge + nw->RPort->TxBaseline);
Text(nw->RPort, buf, strlen(buf));
sprintf(buf, "%d ", yclipbord);
gd = &ClipYCLIP;
Move(nw->RPort, gd->LeftEdge + (nw->Width + gd->Width) + 8,
gd->TopEdge + nw->RPort->TxBaseline);
Text(nw->RPort, buf, strlen(buf));
}
void piShowGrid(piObject *o)
{
ULONG x,y,xs,ys,xo,yo,wo,ho;
struct Node_Window *nw;
piObject *wobj;
if(GUI.gui_GridShow)
{
piGetAttr(o,GA_Left,&xo);
piGetAttr(o,GA_Top,&yo);
piGetAttr(o,GA_Width,&wo);
piGetAttr(o,GA_Height,&ho);
piGetAttr(o,OBJ_Window,(ULONG *)&wobj);
piGetAttr(wobj,OBJ_Node,(ULONG *)&nw);
xs=xo/GUI.gui_Grid[0];
ys=yo/GUI.gui_Grid[1];
SetDrMd(nw->nw_Window->RPort,JAM1);
SetAPen(nw->nw_Window->RPort,DrawInfo->dri_Pens[SHADOWPEN]);
for(x=xs*GUI.gui_Grid[0];x<xo+wo+1;x+=GUI.gui_Grid[0])
{
for(y=ys*GUI.gui_Grid[1];y<yo+ho+1;y+=GUI.gui_Grid[1])
{
WritePixel(nw->nw_Window->RPort,nw->nw_Window->BorderLeft+x,nw->nw_Window->BorderTop+y);
}
}
}
}
ULONG ERASE_Gadget(piClass *cl,piObject *o,Msg msg)
{
UWORD x,y,w,h;
piObject *wo;
struct Node_Window *nw;
struct Node_Gadget *ng;
piGetAttr(o,OBJ_Node,(ULONG *)&ng);
piGetAttr(o,OBJ_Window,(ULONG *)&wo);
if(wo)
{
piGetAttr(wo,OBJ_Node,(ULONG *)&nw);
if(nw) if(nw->nw_Window)
{
// if(!ng->ng_RelX)
x=piCX(o);// else x=nw->nw_Width-ng->ng_X;
// if(!ng->ng_RelY)
y=piCY(o);// else y=nw->nw_Height-ng->ng_Y;
// if(!ng->ng_RelWidth)
w=piCW(o);// else w=nw->nw_Width-nw->nw_Window->BorderRight+ng->ng_Width-x;
// if(!ng->ng_RelHeight)
h=piCH(o);// else h=nw->nw_Height-nw->nw_Window->BorderBottom+ng->ng_Height-y;
SetAPen(nw->nw_Window->RPort,DrawInfo->dri_Pens[BACKGROUNDPEN]);
SetDrMd(nw->nw_Window->RPort,JAM1);
RectFill(nw->nw_Window->RPort,x,y,x+w,y+h);
piShowGrid(o);
}
}
return TRUE;
}
ULONG ERASE_Frame(piClass *cl,piObject *o,Msg msg)
{
UWORD x,y,w,h;
piObject *wo;
struct Node_Window *nw;
piGetAttr(o,OBJ_Window,(ULONG *)&wo);
if(wo)
{
piGetAttr(wo,OBJ_Node,(ULONG *)&nw);
if(nw) if(nw->nw_Window)
{
x=piCX(o);
y=piCY(o);
w=piCW(o);
h=piCH(o);
SetAPen(nw->nw_Window->RPort,DrawInfo->dri_Pens[BACKGROUNDPEN]);
SetDrMd(nw->nw_Window->RPort,JAM1);
RectFill(nw->nw_Window->RPort,x,y,x+w,y+h);
piShowGrid(o);
}
}
return TRUE;
}
static void RenderText(char *text, int x, int y) {
struct RastPort *rastPort = GetCurrentRastPort();
SetDrMd(rastPort, JAM1);
Move(rastPort, x, y);
Text(rastPort, text, strlen(text));
}
ULONG TAPEDECK_RENDER_Gadget(piClass *cl,piObject *o,Msg msg)
{
UWORD x,y,w,h;
struct Node_Gadget *ng;
struct Node_Window *nw;
struct Gadget *g,*ga;
BOOL fill=FALSE;
piGetAttr(o,OBJ_Node,(ULONG *)&ng);
piGetAttr(ng->ng_Window,OBJ_Node,(ULONG *)&nw);
x=piCX(o);
y=piCY(o);
w=piCW(o);
h=piCH(o);
SetAPen(nw->nw_Window->RPort,DrawInfo->dri_Pens[BACKGROUNDPEN]);
SetDrMd(nw->nw_Window->RPort,JAM1);
RectFill(nw->nw_Window->RPort,x,y,x+w,y+h);
g=CreateContext(&g);
if(ga=(struct Gadget *)piDoMethod(o,OM_CREATE,g))
{
AddGList(nw->nw_Window,ga,-1,-1,NULL);
RefreshGList(g,nw->nw_Window,NULL,-1);
RemoveGList(nw->nw_Window,ga,-1);
}
piDoMethod(o,OM_DELETE);
g->NextGadget=NULL;
FreeGadgets(g);
if(ng->ng_Selected && GUI.gui_Mode==MODE_GADGET)
{
SetAPen(nw->nw_Window->RPort,1);
SetDrMd(nw->nw_Window->RPort,COMPLEMENT);
if(CurrentGadget==o) fill=TRUE;
DrawRect(nw->nw_Window->RPort,x,y,fill);
DrawRect(nw->nw_Window->RPort,x+w-5,y,fill);
DrawRect(nw->nw_Window->RPort,x+w-5,y+h-5,fill);
DrawRect(nw->nw_Window->RPort,x,y+h-5,fill);
DrawRect(nw->nw_Window->RPort,x+(w/2)-2,y,fill);
DrawRect(nw->nw_Window->RPort,x+(w/2)-2,y+h-5,fill);
DrawRect(nw->nw_Window->RPort,x,y+(h/2)-2,fill);
DrawRect(nw->nw_Window->RPort,x+w-5,y+(h/2)-2,fill);
}
return TRUE;
}
static void WhitePrint(struct RastPort *RPort, char *String, UWORD height, struct GfxBase * GfxBase)
{
SetAPen(RPort, 1);
SetBPen(RPort, 2);
SetDrMd(RPort, JAM2);
Move(RPort,20,height);
Text(RPort, String, strlen(String));
}
void cardRender( Card theCard, struct RastPort *Rast, long xPos, long yPos )
{
SetDrMd( Rast, JAM2 );
if( theCard )
{
if( cardFaceUp( theCard ))
{
SetAPen( Rast, 2 );
RectFill( Rast, xPos, yPos, xPos+CARD_WIDTH-1,
yPos+CARD_HEIGHT-1 );
SetBPen( Rast, 2 );
switch( cardSuit( theCard ))
{
case HEARTS:
case DIAMONDS:
SetAPen( Rast, 6 );
break;
default:
SetAPen( Rast, 1 );
break;
}
SuitImages[cardSuit( theCard )].PlaneOnOff = 0x2;
DrawImage( Rast, &SuitImages[cardSuit( theCard )],
xPos + Rast->TxWidth + 3, yPos + 3 );
DrawImage( Rast, &SuitImages[cardSuit( theCard )],
xPos + CARD_WIDTH - Rast->TxWidth - 10,
yPos + CARD_HEIGHT - Rast->TxHeight - 2 );
gfxMove( Rast, xPos + 2, yPos + Rast->TxBaseline + 3 );
Text( Rast, RankToStr[cardRank( theCard )], 1 );
gfxMove( Rast, xPos + CARD_WIDTH - Rast->TxWidth - 3,
yPos + CARD_HEIGHT - Rast->TxHeight + Rast->TxBaseline - 2 );
Text( Rast, RankToStr[cardRank( theCard )], 1 );
}
else
{
SetAPen( Rast, 7 );
RectFill( Rast, xPos, yPos, xPos+CARD_WIDTH-1,
yPos+CARD_HEIGHT-1 );
}
}
else
{
SetAPen( Rast, 0 );
RectFill( Rast, xPos, yPos, xPos+CARD_WIDTH-1, yPos+CARD_HEIGHT-1 );
}
SetAPen( Rast, 1 );
gfxMove( Rast, xPos, yPos );
Draw( Rast, xPos+CARD_WIDTH-1, yPos );
Draw( Rast, xPos+CARD_WIDTH-1, yPos+CARD_HEIGHT-1 );
Draw( Rast, xPos, yPos+CARD_HEIGHT-1 );
Draw( Rast, xPos, yPos );
SetAPen( Rast, 5 );
WritePixel( Rast, xPos, yPos );
WritePixel( Rast, xPos+CARD_WIDTH-1, yPos );
WritePixel( Rast, xPos, yPos+CARD_HEIGHT-1 );
WritePixel( Rast, xPos+CARD_WIDTH-1, yPos+CARD_HEIGHT-1 );
}
void print_drive_status(void)
{
char empty[80];
int len;
UWORD offy = scr->WBorTop + scr->RastPort.TxHeight + 1;
for (len = 0; len < 80; len++)
empty[len] = ' ';
empty[79] = '\0';
SetAPen(window->RPort, 1);
SetDrMd(window->RPort, JAM2);
Move(window->RPort, 59, offy + 11 + 10);
if (config.disk_in_df0) {
len = strlen(config.df0_name);
if (len > MAX_DRV_NAME)
len = MAX_DRV_NAME;
Text(window->RPort, (UBYTE *) config.df0_name, len);
} else {
Text(window->RPort, (UBYTE *) empty, MAX_DRV_NAME);
}
Move(window->RPort, 59, offy + 28 + 10);
if (config.disk_in_df1) {
len = strlen(config.df1_name);
if (len > MAX_DRV_NAME)
len = MAX_DRV_NAME;
Text(window->RPort, (UBYTE *) config.df1_name, len);
} else {
Text(window->RPort, (UBYTE *) empty, MAX_DRV_NAME);
}
Move(window->RPort, 59, offy + 45 + 10);
if (config.disk_in_df2) {
len = strlen(config.df2_name);
if (len > MAX_DRV_NAME)
len = MAX_DRV_NAME;
Text(window->RPort, (UBYTE *) config.df2_name, len);
} else {
Text(window->RPort, (UBYTE *) empty, MAX_DRV_NAME);
}
Move(window->RPort, 59, offy + 62 + 10);
if (config.disk_in_df3) {
len = strlen(config.df3_name);
if (len > MAX_DRV_NAME)
len = MAX_DRV_NAME;
Text(window->RPort, (UBYTE *) config.df3_name, len);
} else {
Text(window->RPort, (UBYTE *) empty, MAX_DRV_NAME);
}
}
void
nsSplashScreenAmigaOS::Update(PRInt32 progress)
{
if (!mIsOpen)
return;
mProgress = progress;
// Current image has progress bar 183,149 - 410,153
uint32 pbWidth = (410 - 183) * progress / 100;
mIGraphics->SetAPen(mWindow->RPort, 3);
mIGraphics->SetDrMd(mWindow->RPort, JAM1);
mIGraphics->RectFill(mWindow->RPort, 183, 149, pbWidth + 183, 153);
}
static
void refresh_rectangle( grArosSurface* surface,
int x,
int y,
int w,
int h )
{
SetAPen(surface->win->RPort, 1);
SetDrMd(surface->win->RPort, JAM2);
if (!surface->grays)
{
BltTemplate(surface->root.bitmap.buffer,
0,
w / 8,
surface->win->RPort,
surface->win->BorderLeft,
surface->win->BorderTop,
surface->bpr * 8,
surface->root.bitmap.rows);
} else {
#if 0
WritePixelArray8(surface->win->RPort,
surface->win->BorderLeft,
surface->win->BorderTop,
surface->win->BorderLeft + surface->root.bitmap.width - 1,
surface->win->BorderTop + surface->root.bitmap.rows - 1,
surface->root.bitmap.buffer,
0);
#endif
WriteLUTPixelArray(surface->root.bitmap.buffer,
0,
0,
surface->root.bitmap.width,
surface->win->RPort,
surface->cgfxcoltab,
surface->win->BorderLeft,
surface->win->BorderTop,
surface->root.bitmap.width,
surface->root.bitmap.rows,
CTABFMT_XRGB8);
}
}
IPTR MenuBarLabelClass__IM_DRAW(Class *cl, struct Image *im, struct impDraw *msg)
{
struct MenuBarLabelData *data = INST_DATA(cl, im);
if (data->dri)
{
struct RastPort *rp = msg->imp_RPort;
WORD x1, y1, x2, y2;
if (!rp) return (IPTR)0;
SetDrMd(rp, JAM1);
x1 = im->LeftEdge + msg->imp_Offset.X;
y1 = im->TopEdge + msg->imp_Offset.Y;
x2 = x1 + im->Width - 1;
y2 = y1 + im->Height - 1;
if (MENUS_AMIGALOOK)
{
SetAPen(rp, data->dri->dri_Pens[BARDETAILPEN]);
RectFill(rp, x1, y1, x2, y2);
}
else
{
/* Will only work if imageheight = 2 */
SetAPen(rp, data->dri->dri_Pens[SHADOWPEN]);
RectFill(rp, x1, y1, x2 - 1, y1);
WritePixel(rp, x1, y2);
SetAPen(rp, data->dri->dri_Pens[SHINEPEN]);
RectFill(rp, x1 + 1, y2, x2, y2);
WritePixel(rp, x2, y1);
}
} /* if (data->dri) */
return (IPTR)0;
}
LONG PrintLine(LONG x, struct line_node *line, LONG line_nr, BOOL doublebuffer, struct InstData *data)
{
STRPTR text = line->line.Contents;
LONG length;
struct RastPort *rp = &data->doublerp;
ENTER();
length = LineCharsWidth(text+x, data);
if(doublebuffer == FALSE)
rp = &data->copyrp;
if((line_nr > 0) && (data->update) && !(data->flags & FLG_Quiet) && data->rport != NULL && data->shown == TRUE)
{
LONG c_length = length;
LONG startx = 0, stopx = 0;
LONG starty = 0, xoffset = ((data->height-rp->TxBaseline+1)>>1)+1;
LONG flow = 0;
UWORD *styles = line->line.Styles;
UWORD *colors = line->line.Colors;
struct marking block;
BOOL cursor = FALSE;
if(line->line.Color && x == 0 && line->line.Length == 1)
line->line.Color = FALSE;
if(doublebuffer == FALSE)
{
starty = data->ypos+(data->height * (line_nr-1));
xoffset = data->xpos;
}
flow = FlowSpace(line->line.Flow, text+x, data);
Move(rp, xoffset+flow, starty+rp->TxBaseline);
if(Enabled(data))
{
struct line_node *blkline;
NiceBlock(&data->blockinfo, &block);
blkline = block.startline->next;
if(block.startline == block.stopline)
{
if(block.startline == line)
{
startx = block.startx;
stopx = block.stopx;
}
}
else
{
if(block.startline == line)
{
startx = block.startx;
stopx = line->line.Length;
}
else
{
if(block.stopline == line)
{
stopx = block.stopx;
}
else
{
while((blkline != block.stopline) && (!stopx))
{
if(blkline == line)
{
stopx = line->line.Length;
}
blkline = blkline->next;
}
}
}
}
}
{
UWORD blockstart = 0;
UWORD blockwidth = 0;
struct RastPort *old = muiRenderInfo(data->object)->mri_RastPort;
if(startx < x+c_length && stopx > x)
{
if(startx > x)
blockstart = TextLength(&data->tmprp, text+x, startx-x);
else
startx = x;
blockwidth = ((stopx >= c_length+x) ? data->innerwidth-(blockstart+flow) : TextLength(&data->tmprp, text+startx, stopx-startx));
}
else if(!(data->flags & (FLG_ReadOnly | FLG_Ghosted)) &&
line == data->actualline && data->CPos_X >= x &&
data->CPos_X < x+c_length && !Enabled(data) &&
(data->flags & FLG_Active || data->inactiveCursor == TRUE))
{
cursor = TRUE;
blockstart = TextLength(&data->tmprp, text+x, data->CPos_X-x);
// calculate the cursor width
// if it is set to 6 then we should find out how the width of the current char is
if(data->CursorWidth == 6)
blockwidth = TextLength(&data->tmprp, (*(text+data->CPos_X) < ' ') ? (char *)" " : (char *)(text+data->CPos_X), 1);
else
blockwidth = data->CursorWidth;
}
SetDrMd(rp, JAM1);
muiRenderInfo(data->object)->mri_RastPort = rp;
// clear the background first
DoMethod(data->object, MUIM_DrawBackground, xoffset, starty,
flow+blockstart, data->height,
(data->flags & FLG_InVGrp) ? 0 : data->xpos,
(data->flags & FLG_InVGrp) ? data->height*(data->visual_y+line_nr-2) : data->realypos+data->height * (data->visual_y+line_nr-2),
0);
if(blockwidth)
{
ULONG color;
// in case the gadget is in inactive state we use a different background
// color for our selected area
if((data->flags & FLG_Active) == 0 && (data->flags & FLG_Activated) == 0 &&
(data->flags & FLG_ActiveOnClick) != 0)
{
color = data->inactivecolor;
}
else
color = data->markedcolor;
// if selectmode == 2 then a whole line should be drawn as being marked, so
// we have to start at xoffset instead of xoffset+flow+blockstart.
// Please note that the second part of the following "empiric" evaluation should
// prevent that centered or right aligned lines are not correctly marked right
// from the beginning of the line. However, it seems to be not cover 100% of all different
// cases so that the evaluation if a line should be completely marked should be probably
// moved elsewhere in future.
if(data->selectmode == 2 ||
(flow && data->selectmode != 1 && startx-x == 0 && cursor == FALSE &&
((data->blockinfo.startline != data->blockinfo.stopline) || x > 0)))
{
SetAPen(rp, color);
RectFill(rp, xoffset, starty, xoffset+flow+blockwidth-1, starty+data->height-1);
}
else
{
SetAPen(rp, cursor ? data->cursorcolor : color);
RectFill(rp, xoffset+flow+blockstart, starty, xoffset+flow+blockstart+blockwidth-1, starty+data->height-1);
// if the gadget is in inactive state we just draw a skeleton cursor instead
if(cursor == TRUE &&
(data->flags & FLG_Active) == 0 && (data->flags & FLG_Activated) == 0)
{
DoMethod(data->object, MUIM_DrawBackground, xoffset+flow+blockstart+1, starty+1,
blockwidth-2, data->height-2,
(data->flags & FLG_InVGrp) ? 0 : data->xpos,
(data->flags & FLG_InVGrp) ? data->height*(data->visual_y+line_nr-2) : data->realypos+data->height * (data->visual_y+line_nr-2),
0);
}
}
}
{
LONG x_start = xoffset+blockstart+blockwidth,
y_start = starty,
x_width = data->innerwidth-(blockstart+blockwidth),
y_width = data->height,
x_ptrn = blockstart+blockwidth,
y_ptrn = data->height*(data->visual_y+line_nr-2);
if(blockwidth)
{
x_start += flow;
x_width -= flow;
x_ptrn += flow;
}
if(!(data->flags & FLG_InVGrp))
{
x_ptrn += data->xpos;
y_ptrn += data->realypos;
}
DoMethod(data->object, MUIM_DrawBackground, x_start, y_start, x_width, y_width, x_ptrn, y_ptrn);
}
muiRenderInfo(data->object)->mri_RastPort = old;
}
if(doublebuffer == FALSE)
AddClipping(data);
SetAPen(rp, (line->line.Color ? data->highlightcolor : data->textcolor));
while(c_length)
{
LONG p_length = c_length;
SetSoftStyle(rp, convert(GetStyle(x, line)), AskSoftStyle(rp));
if(styles)
{
while(*styles-1 <= x)
{
styles += 2;
}
if(*styles-x-1 < p_length)
{
p_length = *styles-x-1;
}
}
if(colors)
{
while(*colors-1 <= x)
{
SetAPen(rp, ConvertPen(*(colors+1), line->line.Color, data));
colors += 2;
}
if(*colors-x-1 < p_length)
{
p_length = *colors-x-1;
}
}
/* if(stopx)
{
if((startx > x) && (startx-x < p_length))
{
p_length = startx-x;
SetAPen(rp, 3);
}
else
{
if((stopx > x) && (stopx-x < p_length))
{
p_length = stopx-x;
SetAPen(rp, 4);
}
else
SetAPen(rp, (line->color ? data->highlightcolor : data->textcolor));
}
}
*/
if(text[x+p_length-1] < ' ')
Text(rp, text+x, p_length-1);
else
Text(rp, text+x, p_length);
x += p_length;
c_length -= p_length;
}
SetSoftStyle(rp, FS_NORMAL, AskSoftStyle(rp));
if(line->line.Separator)
{
WORD LeftX, LeftWidth,
RightX, RightWidth,
Y, Height;
LeftX = xoffset;
LeftWidth = flow-3;
RightX = rp->cp_x+3;
RightWidth = xoffset+data->innerwidth - RightX;
Y = starty;
Height = (line->line.Separator & LNSF_Thick) ? 2 : 1;
if(line->line.Separator & LNSF_Middle)
Y += (data->height/2)-Height;
else
{
if(line->line.Separator & LNSF_Bottom)
Y += data->height-(2*Height);
}
if(line->line.Separator & LNSF_StrikeThru || line->line.Length == 1)
{
LeftWidth = data->innerwidth;
}
else
{
DrawSeparator(rp, RightX, Y, RightWidth, Height, data);
}
DrawSeparator(rp, LeftX, Y, LeftWidth, Height, data);
}
if(data->flags & FLG_Ghosted)
{
UWORD *oldPattern = (UWORD *)rp->AreaPtrn;
UBYTE oldSize = rp->AreaPtSz;
UWORD newPattern[] = {0x1111, 0x4444};
if(doublebuffer == TRUE)
{
ULONG ptrn1 = 0x11111111;
ULONG ptrn2 = 0x44444444;
ptrn1 = ptrn1>>((data->xpos-xoffset)%16);
ptrn2 = ptrn2>>((data->xpos-xoffset)%16);
if((data->height*(data->visual_y+line_nr-2))%2 == 0)
{
newPattern[0] = ptrn2;
newPattern[1] = ptrn1;
}
else
{
newPattern[0] = ptrn1;
newPattern[1] = ptrn2;
}
}
static BOOL LayOutReq (struct AHIAudioModeRequesterExt *req, struct TextAttr *TextAttr)
{
struct Gadget *gad;
struct NewGadget ng;
struct TextAttr *gadtextattr;
struct TextFont *font;
LONG fontwidth,buttonheight,buttonwidth,pixels;
struct IntuiText intuitext = {1,0,JAM1,0,0,NULL,NULL,NULL};
LONG sliderlevels,sliderlevel;
LONG selected;
selected=GetSelected(req);
GetSliderAttrs(req,&sliderlevels,&sliderlevel);
// Calculate gadget area
req->gx=req->Window->BorderLeft+4;
req->gy=req->Window->BorderTop+2;
req->gw=req->Window->Width-req->gx-(req->Window->BorderRight+4);
req->gh=req->Window->Height-req->gy-(req->Window->BorderBottom+2);
if(req->Gadgets)
{
RemoveGList(req->Window,req->Gadgets,-1);
FreeGadgets(req->Gadgets);
SetAPen(req->Window->RPort,0);
SetDrMd(req->Window->RPort,JAM1);
EraseRect(req->Window->RPort, req->Window->BorderLeft, req->Window->BorderTop,
req->Window->Width-req->Window->BorderRight-1,req->Window->Height-req->Window->BorderBottom-1);
RefreshWindowFrame(req->Window);
}
req->Gadgets=NULL;
if((gad=CreateContext(&req->Gadgets)))
{
if(TextAttr)
gadtextattr=TextAttr;
else
gadtextattr=req->Window->WScreen->Font;
if((font=OpenFont(gadtextattr)))
{
fontwidth=font->tf_XSize;
CloseFont(font);
}
else
return FALSE;
buttonheight=gadtextattr->ta_YSize+6;
intuitext.ITextFont=gadtextattr;
intuitext.IText=req->PositiveText;
buttonwidth=IntuiTextLength(&intuitext);
intuitext.IText=req->NegativeText;
pixels=IntuiTextLength(&intuitext);
buttonwidth=max(pixels,buttonwidth);
buttonwidth+=4+fontwidth;
// Create gadgets and check if they fit
// Do the two buttons fit?
if(2*buttonwidth > req->gw)
return FALSE;
ng.ng_TextAttr=gadtextattr;
ng.ng_VisualInfo=req->vi;
ng.ng_UserData=req;
// OK button
ng.ng_LeftEdge=req->gx;
ng.ng_TopEdge=req->gy+req->gh-buttonheight;
ng.ng_Width=buttonwidth;
ng.ng_Height=buttonheight;
ng.ng_GadgetText=req->PositiveText;
ng.ng_GadgetID=OKBUTTON;
ng.ng_Flags=PLACETEXT_IN;
gad=CreateGadget(BUTTON_KIND,gad,&ng,TAG_END);
// Cancel button
ng.ng_LeftEdge=req->gx+req->gw-ng.ng_Width;
ng.ng_GadgetText=req->NegativeText;
ng.ng_GadgetID=CANCELBUTTON;
gad=CreateGadget(BUTTON_KIND,gad,&ng,TAG_END);
// Frequency
if(req->Flags & freqgad)
{
intuitext.IText = GetString(msgReqFrequency, req->Catalog);
pixels=IntuiTextLength(&intuitext)+INTERWIDTH;
if(pixels+MINSLIDERWIDTH+INTERWIDTH+FREQLEN2*fontwidth > req->gw)
return FALSE;
ng.ng_Width=req->gw-pixels-INTERWIDTH-FREQLEN2*fontwidth;
ng.ng_LeftEdge=req->gx+pixels;
ng.ng_TopEdge-=2+buttonheight;
ng.ng_GadgetText = GetString(msgReqFrequency, req->Catalog);
ng.ng_GadgetID=FREQSLIDER;
ng.ng_Flags=PLACETEXT_LEFT;
gad=CreateGadget(SLIDER_KIND,gad,&ng,
GTSL_Min,0,
GTSL_Max,sliderlevels-1,
GTSL_Level,sliderlevel,
GTSL_LevelFormat, (ULONG) FREQTEXT2,
GTSL_MaxLevelLen,FREQLEN2,
GTSL_LevelPlace,PLACETEXT_RIGHT,
GTSL_DispFunc, (ULONG) m68k_IndexToFrequency,
GA_RelVerify,TRUE,
GA_Disabled,!sliderlevels || (req->tempAudioID == AHI_DEFAULT_ID),
TAG_DONE);
req->slidergadget=gad; // Save for HadleReq()...
}
// ListView
if((ng.ng_Height=ng.ng_TopEdge-2-req->gy) < buttonheight)
return FALSE;
ng.ng_LeftEdge=req->gx;
ng.ng_TopEdge=req->gy;
ng.ng_Width=req->gw;
ng.ng_GadgetText=NULL,
ng.ng_GadgetID=LISTVIEW;
ng.ng_Flags=PLACETEXT_ABOVE;
gad=CreateGadget(LISTVIEW_KIND,gad,&ng,
GTLV_ScrollWidth,(fontwidth>8 ? fontwidth*2 : 18),
GTLV_Labels, (ULONG) req->list,
GTLV_ShowSelected,NULL,
((selected == ~0) || (GadToolsBase->lib_Version >= 39) ? TAG_IGNORE : GTLV_Top),selected,
(selected == ~0 ? TAG_IGNORE : GTLV_MakeVisible),selected,
GTLV_Selected,selected,
TAG_DONE);
req->listviewgadget=gad; // Save for HadleReq()...
if(!gad)
return FALSE;
}
else
return FALSE;
AddGList(req->Window,req->Gadgets,~0,-1,NULL);
RefreshGList(req->Gadgets,req->Window,NULL,-1);
GT_RefreshWindow(req->Window,NULL);
return TRUE;
}
// Render listview
void listview_render(
Class *cl,
struct Gadget *gadget,
ListViewData *data,
struct gpRender *render)
{
struct RastPort *rp;
UWORD *pens;
// Get rastport to use
rp=(render->MethodID==GM_RENDER)?render->gpr_RPort:ObtainGIRPort(render->gpr_GInfo);
// Get pen array
pens=render->gpr_GInfo->gi_DrInfo->dri_Pens;
// Set font
SetFont(rp,data->list_font);
// Look at render type
switch (render->gpr_Redraw)
{
// Draw the whole gadget?
case GREDRAW_REDRAW:
{
struct TagItem tags[4];
short a;
// Valid title?
if (data->title[0])
{
short y,x,len;
// Get title length
len=strlen(data->title);
// Get x and y position for title
if (data->layout_flags&PLACETEXT_LEFT)
{
x=gadget->LeftEdge-TextLength(rp,data->title,len)-8;
y=gadget->TopEdge+2+rp->TxBaseline;
}
else
{
x=gadget->LeftEdge;
y=(gadget->TopEdge-1-rp->TxHeight)+rp->TxBaseline;
}
// Draw title
SetAPen(rp,pens[TEXTPEN]);
SetDrMd(rp,JAM1);
Move(rp,x,y);
Text(rp,data->title,len);
// Underscore?
if (data->title_uscore>-1)
{
int pos,len;
// Get position and length of underscore
pos=TextLength(rp,data->title,data->title_uscore);
len=TextLength(rp,data->title+data->title_uscore,1);
// Draw it
Move(rp,x+pos,y+1);
Draw(rp,x+pos+len-1,y+1);
}
// Reset draw mode
SetDrMd(rp,JAM2);
}
// Draw border around the list
listview_border(
cl,
rp,
pens,
&data->list_dims,
(data->flags&LVF_READ_ONLY)?IDS_SELECTED:IDS_NORMAL,
(data->flags&LVF_THIN_BORDER)?THIN:THICK);
// Draw scroller border
if (data->scroller)
{
listview_border(
cl,
rp,
pens,
&data->scroller_dims,
IDS_NORMAL,
(data->flags&LVF_THIN_BORDER)?THIN:THICK);
// Draw blank area inside scroller border
SetAPen(rp,pens[BACKGROUNDPEN]);
if (0 && data->flags&LVF_DISABLE_CHANGE)
{
RectFill(rp,
data->scroller_dims.Left+((data->flags&LVF_THIN_BORDER)?1:2),
data->scroller_dims.Top+1,
data->scroller_dims.Left+data->scroller_dims.Width-((data->flags&LVF_THIN_BORDER)?2:3),
data->scroller_dims.Top+data->scroller_dims.Height-2);
data->flags&=~LVF_DISABLE_CHANGE;
}
else
{
if (data->flags&LVF_THIN_BORDER)
{
Move(rp,
data->scroller_dims.Left+1,
data->scroller_dims.Top+1);
Draw(rp,
data->scroller_dims.Left+1,
data->scroller_dims.Top+data->scroller_dims.Height-2);
Move(rp,
data->scroller_dims.Left+data->scroller_dims.Width-2,
data->scroller_dims.Top+1);
Draw(rp,
data->scroller_dims.Left+data->scroller_dims.Width-2,
data->scroller_dims.Top+data->scroller_dims.Height-2);
}
Move(rp,
data->scroller_dims.Left+2,
data->scroller_dims.Top+1);
Draw(rp,
data->scroller_dims.Left+data->scroller_dims.Width-3,
data->scroller_dims.Top+1);
Draw(rp,
data->scroller_dims.Left+data->scroller_dims.Width-3,
data->scroller_dims.Top+data->scroller_dims.Height-2);
Draw(rp,
data->scroller_dims.Left+2,
data->scroller_dims.Top+data->scroller_dims.Height-2);
Draw(rp,
data->scroller_dims.Left+2,
data->scroller_dims.Top+1);
Move(rp,
data->scroller_dims.Left+3,
data->scroller_dims.Top+1);
Draw(rp,
data->scroller_dims.Left+3,
data->scroller_dims.Top+data->scroller_dims.Height-2);
Move(rp,
data->scroller_dims.Left+data->scroller_dims.Width-4,
data->scroller_dims.Top+1);
Draw(rp,
data->scroller_dims.Left+data->scroller_dims.Width-4,
data->scroller_dims.Top+data->scroller_dims.Height-2);
}
}
// Draw list
listview_draw_items(cl,gadget,rp,render->gpr_GInfo->gi_DrInfo,data,-1);
// Fill out scroller tags
if (data->scroller)
{
tags[0].ti_Tag=PGA_Total;
tags[0].ti_Data=data->count;
tags[1].ti_Tag=PGA_Visible;
tags[1].ti_Data=data->lines;
tags[2].ti_Tag=PGA_Top;
tags[2].ti_Data=data->top;
tags[3].ti_Tag=TAG_END;
// Update scroller
DoMethod(
(Object *)data->scroller,
OM_SET,
tags,
render->gpr_GInfo);
// Refresh arrows
for (a=0;a<2;a++)
DoMethod(
(Object *)data->arrows[a],
GM_RENDER,
render->gpr_GInfo,
rp,
GREDRAW_REDRAW);
// Refresh scroller
DoMethod(
(Object *)data->scroller,
GM_RENDER,
render->gpr_GInfo,
rp,
GREDRAW_REDRAW);
}
// Disabled?
if (gadget->Flags&GFLG_DISABLED)
{
unsigned short ghost[2];
// Set ghosting pattern
ghost[0]=0x8888;
ghost[1]=0x2222;
SetAfPt(rp,ghost,1);
SetAPen(rp,pens[SHADOWPEN]);
SetDrMd(rp,JAM1);
// Fill with ghosting pattern
RectFill(rp,
data->dims.Left,
data->dims.Top,
data->dims.Left+data->dims.Width-1,
data->dims.Top+data->dims.Height-1);
// Clear ghosting pattern
SetAfPt(rp,0,0);
}
// Otherwise, clear any gap between text area and gadget
else
{
SetAPen(rp,pens[BACKGROUNDPEN]);
if (data->text_dims.Top>data->dims.Top+1)
{
RectFill(rp,
data->text_dims.Left,
data->dims.Top+1,
data->text_dims.Left+data->text_dims.Width-1,
data->text_dims.Top-1);
}
if (data->text_dims.Top+data->text_dims.Height-1<
data->dims.Top+data->dims.Height-2)
{
RectFill(rp,
data->text_dims.Left,
data->text_dims.Top+data->text_dims.Height,
data->text_dims.Left+data->text_dims.Width-1,
data->dims.Top+data->dims.Height-2);
}
}
}
break;
// Just refresh items
case GREDRAW_UPDATE:
{
// Draw list
listview_draw_items(cl,gadget,rp,render->gpr_GInfo->gi_DrInfo,data,data->last_sel);
// Refresh scroller?
if (data->last_sel==-1 && data->scroller)
{
struct TagItem tags[2];
// Fill out scroller tags
tags[0].ti_Tag=PGA_Top;
tags[0].ti_Data=data->top;
tags[1].ti_Tag=TAG_END;
// Update scroller
DoMethod(
(Object *)data->scroller,
OM_SET,
tags,
render->gpr_GInfo);
}
}
break;
}
// Do we need to free the rastport?
if (render->MethodID!=GM_RENDER) ReleaseGIRPort(rp);
}
// Show font example
void font_show_font(font_data *data,BOOL refresh)
{
struct Rectangle rect;
struct Region *region;
struct RastPort rp;
// Get display rectangle
GetObjectRect(data->list,GAD_FONT_DISPLAY,&rect);
// Move rectangle in
rect.MinX+=3;
rect.MinY+=3;
rect.MaxX-=3;
rect.MaxY-=3;
// Copy rastport
rp=*data->window->RPort;
// Refresh?
if (refresh)
{
LockLayerInfo(&data->window->WScreen->LayerInfo);
BeginRefresh(data->window);
}
// Clear background
SetAPen(&rp,DRAWINFO(data->window)->dri_Pens[SHINEPEN]);
RectFill(&rp,rect.MinX-1,rect.MinY-1,rect.MaxX+1,rect.MaxY+1);
// Refreshing?
if (refresh) EndRefresh(data->window,FALSE);
// Create region
if ((region=NewRegion()))
{
// Set rectangle
OrRectRegion(region,&rect);
// Install region
InstallClipRegion(data->window->WLayer,region);
}
// Refreshing?
if (refresh) BeginRefresh(data->window);
// Got a font?
if (data->font)
{
ULONG flags;
short y;
struct TextExtent extent;
char *ptr,*end;
// Set pen and font
SetAPen(&rp,DRAWINFO(data->window)->dri_Pens[TEXTPEN]);
SetDrMd(&rp,JAM1);
SetFont(&rp,data->font);
// Get style flags
flags=0;
if (GetGadgetValue(data->list,GAD_FONT_BOLD)) flags|=FSF_BOLD;
if (GetGadgetValue(data->list,GAD_FONT_ITALIC)) flags|=FSF_ITALIC;
if (GetGadgetValue(data->list,GAD_FONT_ULINE)) flags|=FSF_UNDERLINED;
// Set styles
SetSoftStyle(&rp,flags,FSF_BOLD|FSF_ITALIC|FSF_UNDERLINED);
// Valid font to draw?
if (data->font_text[0])
{
// Get end of the string
end=data->font_text+strlen(data->font_text);
// Initial coordinates
y=rect.MinY;
// Initialise position
if (!(ptr=strchr(data->font_text,'A')))
ptr=data->font_text;
Move(&rp,rect.MinX,y+rp.TxBaseline);
// Draw until we reach the bottom
while (y<rect.MaxY)
{
// New line
if (rp.cp_x>rect.MaxX)
{
// Bump position
y+=rp.TxHeight+1;
Move(&rp,rect.MinX,y+rp.TxBaseline);
}
// Otherwise
else
{
short len,maxlen;
// Get text that will fit
len=
TextFit(
&rp,
ptr,
(maxlen=strlen(ptr)),
&extent,
0,1,
rect.MaxX-rp.cp_x+1,
rp.TxHeight);
// Check against length, add extra character if ok
if (len<maxlen) ++len;
// Draw text
Text(&rp,ptr,len);
// Bump text position
ptr+=len;
// End of the string?
if (ptr>=end) ptr=data->font_text;
}
}
}
}
// Finished refreshing?
if (refresh) EndRefresh(data->window,TRUE);
// Remove region
if (region)
{
InstallClipRegion(data->window->WLayer,0);
DisposeRegion(region);
}
// Unlock layers if we refreshed
if (refresh) UnlockLayerInfo(&data->window->WScreen->LayerInfo);
}
static void Action(void)
{
struct RastPort *rp;
struct Region *reg;
struct RegionRectangle *rr;
WORD x, y, i, count = 0;
puts("Activate the window whose visible region you want to see.\n");
puts("You have 3 seconds of time!\n\n");
Delay(3*50);
win = IntuitionBase->ActiveWindow;
scr = win->WScreen;
if (!win) Cleanup("No active window!");
if (!(rp = CloneRastPort(&win->WScreen->RastPort)))
{
Cleanup("Can´t clone screen rastport!");
}
SetDrMd(rp,JAM1);
lay = win->WLayer;
reg = lay->VisibleRegion;
rr = reg->RegionRectangle;
while(rr)
{
WORD x1 = reg->bounds.MinX + rr->bounds.MinX;
WORD y1 = reg->bounds.MinY + rr->bounds.MinY;
WORD x2 = reg->bounds.MinX + rr->bounds.MaxX;
WORD y2 = reg->bounds.MinY + rr->bounds.MaxY;
printf("#%04d (%4d,%4d) - (%4d, %4d) Size: %4d x %4d\n",
++count,
x1,
y1,
x2,
y2,
x2 - x1 + 1,
y2 - y1 + 1);
for(i = 0; i < (Args[ARG_FAST] ? 1 : 8);i++)
{
SetAPen(rp,1 + (i & 1));
RectFill(rp,x1,y1,x2,y1);
RectFill(rp,x2,y1,x2,y2);
RectFill(rp,x1,y2,x2,y2);
RectFill(rp,x1,y1,x1,y2);
if (!Args[ARG_FAST]) Delay(10);
}
if (Args[ARG_NUMBERS])
{
sprintf(s,"%d",count);
i = TextLength(rp,s,strlen(s));
x = (x1 + x2 - i) / 2;
y = (y1 + y2 - rp->TxHeight) / 2;
if (x < 0)
{
x = 0;
} else if (x >= scr->Width - i)
{
x = scr->Width - i - 1;
}
if (y < 0)
{
y = 0;
} else if (y >= scr->Height - rp->TxHeight)
{
y = scr->Height - rp->TxHeight - 1;
}
i = strlen(s);
SetAPen(rp,1);
Move(rp,x + 1, y + 1 + rp->TxBaseline);
Text(rp,s,i);
SetAPen(rp,2);
Move(rp,x, y + rp->TxBaseline);
Text(rp,s,i);
}
rr = rr->Next;
}
FreeRastPort(rp);
}
// Draw an item in the listview
void listview_draw_item(
Class *cl,
struct Gadget *gadget,
struct RastPort *rp,
struct DrawInfo *drawinfo,
ListViewData *data,
struct Node *node,
unsigned short line,
struct IBox *user_box)
{
short selected=0,tab_flag=0,high;
unsigned short x,y,len=0,textlen,pos=0,tabpos=0,width,last_x=0;
short fpen;
struct TextExtent extent;
struct IBox *box;
char *name;
// User-supplied box?
if (user_box)
{
box=user_box;
high=1;
}
else
{
box=&data->text_dims;
high=(BOOL)(data->sel==data->top+line);
}
// Get y position
y=((unsigned short)box->Top)+line*data->text_height;
// Invalid item?
if (!node || !node->ln_Succ)
{
// Fill item
SetAPen(rp,drawinfo->dri_Pens[(high)?FILLPEN:BACKGROUNDPEN]);
RectFill(rp,
box->Left,
y,
box->Left+box->Width-1,
y+data->text_height-1);
return;
}
// Does this item need a highlight select?
if (high)
{
if ((!(data->flags&LVF_CANCEL) && gadget->Flags&GFLG_SELECTED) ||
(data->flags&LVF_SHOW_SELECTED && !(data->flags&LVF_SELECTED_CHECK)))
selected=1;
}
// Highlight selection?
if (high && !(gadget->Flags&GFLG_SELECTED) && data->flags&LVF_SELECTED_HIGH)
{
fpen=drawinfo->dri_Pens[HIGHLIGHTTEXTPEN];
}
// Highlight multi-select?
else
if (!(data->flags&LVF_NO_HIGHLIGHT) &&
data->flags&LVF_MULTI_SELECT &&
data->flags&LVF_SELECTED_HIGH &&
node->lve_Flags&LVEF_SELECTED)
{
fpen=drawinfo->dri_Pens[HIGHLIGHTTEXTPEN];
}
// Custom pen supplied?
else
if (node->lve_Flags&LVEF_USE_PEN)
{
// If selected, check pen is different to background
if (selected && node->lve_Pen==drawinfo->dri_Pens[FILLPEN])
fpen=drawinfo->dri_Pens[FILLTEXTPEN];
// Ok to use custom pen
else fpen=node->lve_Pen;
}
// Normal entry
else
{
fpen=drawinfo->dri_Pens[(selected)?FILLTEXTPEN:TEXTPEN];
}
SetAPen(rp,fpen);
SetBPen(rp,drawinfo->dri_Pens[(selected)?FILLPEN:BACKGROUNDPEN]);
SetDrMd(rp,JAM2);
// Valid name?
if (node->ln_Name)
{
// Get name pointer
name=node->ln_Name;
// Only show filenames?
if (data->flags&LVF_SHOW_FILENAMES)
{
// Get filename pointer
name=lv_FilePart(name);
}
// Get text length
textlen=strlen(name);
// Right-justify?
if (data->flags&LVF_RIGHT_JUSTIFY)
{
char *dots=0;
short dotlen=0;
// Get length that will fit (from end backwards)
len=TextFit(
rp,
name+textlen-1,textlen,
&extent,
0,-1,
data->text_width,
data->text_height);
// Won't all fit?
if (len<textlen)
{
// Get length of dots
dots="...";
dotlen=TextLength(rp,dots,3);
// Get new length of string that will fit
len=TextFit(
rp,
name+textlen-1,textlen,
&extent,
0,-1,
data->text_width-dotlen,
data->text_height);
}
// Draw text
Move(rp,box->Left+data->text_offset,y+rp->TxBaseline);
if (dots) Text(rp,dots,3);
Text(rp,name+textlen-len,len);
// Save x position
last_x=data->text_offset+dotlen+extent.te_Width;
}
// Normal
else
{
BOOL sep=0;
// Get x position
x=data->text_offset;
// Show separators?
if (data->flags&LVF_SHOW_SEPARATORS && strcmp(name,"---")==0)
sep=1;
// Go through string
while (pos<textlen)
{
// Separator?
if (sep)
{
// Get full size
width=data->text_width-x;
}
// Need to parse
else
{
// Look for tab
for (tabpos=0;name[pos+tabpos];tabpos++)
if (name[pos+tabpos]=='\t' ||
name[pos+tabpos]=='\a' ||
name[pos+tabpos]=='\v') break;
// Get text size
if (tabpos>0)
{
len=TextFit(
rp,
name+pos,tabpos,
&extent,
0,1,
data->text_width-x,
data->text_height);
width=extent.te_Width;
}
else
{
len=0;
width=0;
}
// Tab across if needed
if (tab_flag==1) x=data->text_width-width;
else
if (tab_flag==2) x=(data->text_width-width)>>1;
}
// Fill background if needed
if (last_x && last_x<x)
{
SetAPen(rp,drawinfo->dri_Pens[(selected)?FILLPEN:BACKGROUNDPEN]);
RectFill(rp,
box->Left+last_x,
y,
box->Left+x-1,
y+data->text_height-1);
SetAPen(rp,fpen);
}
// Draw separator?
if (sep)
{
short yp,xp;
// Clear area under line
SetAPen(rp,drawinfo->dri_Pens[(selected)?FILLPEN:BACKGROUNDPEN]);
RectFill(rp,
box->Left+x,
y,
(xp=box->Left+x+width-1),
y+data->text_height-1);
SetAPen(rp,fpen);
// Get y position
yp=y+(data->text_height>>1);
// Draw line
SetDrPt(rp,0xbbbb);
Move(rp,box->Left+x,yp);
Draw(rp,xp,yp);
SetDrPt(rp,0xeeee);
Move(rp,box->Left+x,yp+1);
Draw(rp,xp,yp+1);
SetDrPt(rp,0xffff);
}
// Draw text
else
if (len>0)
{
Move(rp,box->Left+x,y+rp->TxBaseline);
Text(rp,name+pos,len);
}
// Save x position
last_x=x+width;
// Break if just did separator
if (sep) break;
// Bump buffer pointer
pos+=tabpos+1;
// Set tab flag
if (pos>0)
{
if (name[pos-1]=='\t') tab_flag=1;
else
if (name[pos-1]=='\v') tab_flag=2;
else
if (name[pos-1]=='\a')
{
unsigned short tab;
// Move text position across
tab=(unsigned short)name[pos];
x+=tab*rp->TxWidth;
// Bump position
++pos;
}
// Tab flag not set, bump position
else x+=width;
}
}
}
void
EditClipping(void)
{
int i;
long mflags;
static int sizes[] = { 8, 16, 20, 24, 28, 32, 36 };
char buf[40];
int done = 0, okay = 0;
long code, qual, class;
register struct Gadget *gd, *dgad;
register struct Window *nw;
register struct IntuiMessage *imsg;
register struct PropInfo *pip;
register struct Screen *scrn;
long aidx;
int lmxsize = mxsize, lmysize = mysize;
int lxclipbord = xclipbord, lyclipbord = yclipbord;
int msx, msy;
int drag = 0;
static int once = 0;
scrn = HackScreen;
if (!once) {
SetBorder(&ClipOkay);
SetBorder(&ClipCancel);
once = 1;
}
ClipNewWindowStructure1.Screen = scrn;
#ifdef INTUI_NEW_LOOK
if (IntuitionBase->LibNode.lib_Version >= 37) {
((struct PropInfo *) ClipXSIZE.SpecialInfo)->Flags |= PROPNEWLOOK;
((struct PropInfo *) ClipYSIZE.SpecialInfo)->Flags |= PROPNEWLOOK;
((struct PropInfo *) ClipXCLIP.SpecialInfo)->Flags |= PROPNEWLOOK;
((struct PropInfo *) ClipYCLIP.SpecialInfo)->Flags |= PROPNEWLOOK;
}
#endif
if (WINVERS_AMIV || WINVERS_AMII) {
#ifdef INTUI_NEW_LOOK
ClipNewWindowStructure1.Extension = wintags;
ClipNewWindowStructure1.Flags |= WFLG_NW_EXTENDED;
#ifdef __GNUC__
fillhook.h_Entry = (void *) &LayerFillHook;
#else
fillhook.h_Entry = (ULONG (*) ()) LayerFillHook;
#endif
fillhook.h_Data = (void *) -2;
fillhook.h_SubEntry = 0;
#endif
}
nw = OpenWindow((void *) &ClipNewWindowStructure1);
if (nw == NULL) {
DisplayBeep(NULL);
return;
}
ShowClipValues(nw);
mflags = AUTOKNOB | FREEHORIZ;
#ifdef INTUI_NEW_LOOK
if (IntuitionBase->LibNode.lib_Version >= 37) {
mflags |= PROPNEWLOOK;
}
#endif
for (i = 0; i < 7; ++i) {
if (mxsize <= sizes[i])
break;
}
NewModifyProp(&ClipXSIZE, nw, NULL, mflags, (i * MAXPOT) / 6, 0,
MAXPOT / 6, 0, 1);
for (i = 0; i < 7; ++i) {
if (mysize <= sizes[i])
break;
}
NewModifyProp(&ClipYSIZE, nw, NULL, mflags, (i * MAXPOT) / 6, 0,
MAXPOT / 6, 0, 1);
NewModifyProp(&ClipXCLIP, nw, NULL, mflags,
((xclipbord - 2) * MAXPOT) / 6, 0, MAXPOT / 6, 0, 1);
NewModifyProp(&ClipYCLIP, nw, NULL, mflags,
((yclipbord - 2) * MAXPOT) / 6, 0, MAXPOT / 6, 0, 1);
while (!done) {
WaitPort(nw->UserPort);
while (imsg = (struct IntuiMessage *) GetMsg(nw->UserPort)) {
gd = (struct Gadget *) imsg->IAddress;
code = imsg->Code;
class = imsg->Class;
qual = imsg->Qualifier;
msx = imsg->MouseX;
msy = imsg->MouseY;
ReplyMsg((struct Message *) imsg);
switch (class) {
case VANILLAKEY:
if (code == '\33')
okay = 0, done = 1;
else if (code == 'v' && qual == AMIGALEFT)
okay = done = 1;
else if (code == 'b' && qual == AMIGALEFT)
okay = 0, done = 1;
else if (code == 'o' || code == 'O')
okay = done = 1;
else if (code == 'c' || code == 'C')
okay = 0, done = 1;
break;
case CLOSEWINDOW:
done = 1;
break;
case GADGETUP:
drag = 0;
if (gd->GadgetID == XSIZE || gd->GadgetID == YSIZE
|| gd->GadgetID == XCLIP || gd->GadgetID == YCLIP) {
pip = (struct PropInfo *) gd->SpecialInfo;
aidx = pip->HorizPot / (MAXPOT / 6);
if (gd->GadgetID == XSIZE) {
mxsize = sizes[aidx];
} else if (gd->GadgetID == YSIZE) {
mysize = sizes[aidx];
} else if (gd->GadgetID == XCLIP) {
xclipbord = aidx + 2;
} else if (gd->GadgetID == YCLIP) {
yclipbord = aidx + 2;
}
ShowClipValues(nw);
#ifdef OPT_DISPMAP
dispmap_sanity();
#endif
} else if (gd->GadgetID == GADOKAY) {
done = 1;
okay = 1;
} else if (gd->GadgetID == GADCANCEL) {
done = 1;
okay = 0;
}
ReportMouse(0, nw);
reclip = 2;
doredraw();
flush_glyph_buffer(amii_wins[WIN_MAP]->win);
reclip = 0;
break;
case GADGETDOWN:
drag = 1;
dgad = gd;
ReportMouse(1, nw);
break;
case MOUSEMOVE:
if (!drag)
break;
pip = (struct PropInfo *) dgad->SpecialInfo;
aidx = pip->HorizPot / (MAXPOT / 6);
Move(nw->RPort,
dgad->LeftEdge + (nw->Width + dgad->Width) + 8,
dgad->TopEdge + nw->RPort->TxBaseline);
if (dgad->GadgetID == XSIZE) {
mxsize = sizes[aidx];
sprintf(buf, "%d ", lmxsize);
} else if (dgad->GadgetID == YSIZE) {
mysize = sizes[aidx];
sprintf(buf, "%d ", mysize);
} else if (dgad->GadgetID == XCLIP) {
xclipbord = aidx + 2;
sprintf(buf, "%d ", xclipbord);
} else if (dgad->GadgetID == YCLIP) {
yclipbord = aidx + 2;
sprintf(buf, "%d ", yclipbord);
}
SetAPen(nw->RPort, 5);
SetBPen(nw->RPort, amii_otherBPen);
SetDrMd(nw->RPort, JAM2);
Text(nw->RPort, buf, strlen(buf));
#ifdef OPT_DISPMAP
dispmap_sanity();
#endif
break;
}
}
}
CloseWindow(nw);
/* Restore oldvalues if cancelled. */
if (!okay) {
mxsize = lmxsize;
mysize = lmysize;
xclipbord = lxclipbord;
yclipbord = lyclipbord;
}
}
void shutdownwnd_open(void)
{
if ((scr = LockPubScreen(NULL)))
{
char *filename;
/* get a white pen for the color of our text */
pen = ObtainBestPenA(scr->ViewPort.ColorMap,0xffffffff,0xffffffff,0xffffffff,NULL);
if ((filename = mycombinepath(gui_get_images_directory(),"shutdown")))
{
if ((obj = LoadAndMapPicture("PROGDIR:Images/shutdown",scr)))
{
struct BitMapHeader *bmhd = NULL;
struct BitMap *bitmap = NULL;
GetDTAttrs(obj,PDTA_BitMapHeader,&bmhd,TAG_DONE);
GetDTAttrs(obj,PDTA_DestBitMap,&bitmap,TAG_DONE);
if (!bitmap) GetDTAttrs(obj,PDTA_BitMap,&bitmap,TAG_DONE);
if (bmhd && bitmap)
{
int width = bmhd->bmh_Width;
int height = bmhd->bmh_Height;
int wndleft,wndtop;
wndleft = (scr->Width - width)/2;
wndtop = (scr->Height - height)/2;
if ((shutdown_wnd = OpenWindowTags(NULL,
WA_SmartRefresh, TRUE,
WA_NoCareRefresh, TRUE,
WA_Borderless, TRUE,
WA_Width, width,
WA_Height, height,
WA_PubScreen, scr,
WA_Left, wndleft,
WA_Top, wndtop,
WA_BackFill, LAYERS_NOBACKFILL,
TAG_DONE)))
{
BltBitMapRastPort(bitmap,0,0,
shutdown_wnd->RPort, 0, 0, width, height,
0xc0);
if (!user.config.dont_show_shutdown_text)
{
struct TextExtent te;
const char *txt = _("Shutting down...");
SetDrMd(shutdown_wnd->RPort,JAM1);
SetAPen(shutdown_wnd->RPort,pen);
TextExtent(shutdown_wnd->RPort,txt,strlen(txt),&te);
if ((te.te_Width < width) && (te.te_Height < height))
{
/* only draw the text if there is enought space for it */
Move(shutdown_wnd->RPort,(width - te.te_Width)/2, height - te.te_Height - 4 + shutdown_wnd->RPort->TxBaseline);
Text(shutdown_wnd->RPort,txt,strlen(txt));
}
}
}
}
}
free(filename);
}
}
}
AROS_UFH3(IPTR, SizeListviewRenderFunc,
AROS_UFHA(struct Hook *, hook, A0),
AROS_UFHA(struct Node *, node, A2),
AROS_UFHA(struct ASLLVDrawMsg *, msg, A1)
)
{
AROS_USERFUNC_INIT
IPTR retval;
if (msg->lvdm_MethodID == LV_DRAW)
{
struct DrawInfo *dri = msg->lvdm_DrawInfo;
struct RastPort *rp = msg->lvdm_RastPort;
WORD min_x = msg->lvdm_Bounds.MinX;
WORD min_y = msg->lvdm_Bounds.MinY;
WORD max_x = msg->lvdm_Bounds.MaxX;
WORD max_y = msg->lvdm_Bounds.MaxY;
UWORD erasepen = BACKGROUNDPEN;
UWORD textpen = TEXTPEN;
SetDrMd(rp, JAM1);
switch (msg->lvdm_State)
{
case ASLLVR_SELECTED:
erasepen = FILLPEN;
textpen = FILLTEXTPEN;
/* Fall through */
case ASLLVR_NORMAL:
{
struct TextExtent te;
WORD numfit;
UBYTE s[10];
SetAPen(rp, dri->dri_Pens[erasepen]);
RectFill(rp, min_x, min_y, max_x, max_y);
if (node)
{
sprintf(s, "%ld", (LONG)node->ln_Name);
numfit = TextFit(rp,
s,
strlen(s),
&te,
NULL,
1,
max_x - min_x + 1 - BORDERLVITEMSPACINGX * 2,
max_y - min_y + 1);
SetAPen(rp, dri->dri_Pens[textpen]);
/* Render text */
Move(rp, min_x + BORDERLVITEMSPACINGX,
min_y + BORDERLVITEMSPACINGY + rp->Font->tf_Baseline);
Text(rp, s, numfit);
}
} break;
}
retval = ASLLVCB_OK;
}
else
{
retval = ASLLVCB_UNKNOWN;
}
return retval;
AROS_USERFUNC_EXIT
}
/**************************************************************************
Render one item
**************************************************************************/
static void RenderRegisterTabItem(struct IClass *cl, Object *obj, WORD item)
{
struct Register_DATA *data = INST_DATA(cl, obj);
struct RegisterTabItem *ri = &data->items[item];
struct TextExtent extent;
WORD fitlen; /* text len fitting in alloted space */
WORD fitpix; /* text pixels fitting in alloted space */
WORD x, y;
WORD top_item_bar_y;
WORD bottom_item_bar_y;
WORD left_item_bar_x;
WORD right_item_bar_x;
WORD item_bar_width;
WORD text_y;
WORD item_bg_height;
WORD fitwidth;
if ((item < 0) || (item >= data->numitems)) return;
y = data->top + ri->y1;
if (data->active == item)
{
top_item_bar_y = _top(obj) + ri->y1;
bottom_item_bar_y = _top(obj) + ri->y2 - 2;
left_item_bar_x = _left(obj) + ri->x1 - 1;
right_item_bar_x = _left(obj) + ri->x2 + 1;
item_bg_height = data->tab_height;
text_y = y + data->ty;
item_bar_width = right_item_bar_x - left_item_bar_x + 1;
/* fill tab with register background */
DoMethod(obj,MUIM_DrawBackground, left_item_bar_x, top_item_bar_y + 4,
item_bar_width, item_bg_height - 4,
left_item_bar_x, top_item_bar_y + 4, 0);
DoMethod(obj,MUIM_DrawBackground, left_item_bar_x + 2, top_item_bar_y + 2,
item_bar_width - (2 * 2), 2,
left_item_bar_x + 2, top_item_bar_y + 2, 0);
DoMethod(obj,MUIM_DrawBackground, left_item_bar_x + 4, top_item_bar_y + 1,
item_bar_width - (2 * 4), 1,
left_item_bar_x + 4, top_item_bar_y + 1, 0);
}
else
{
top_item_bar_y = _top(obj) + ri->y1 + 2;
bottom_item_bar_y = _top(obj) + ri->y2 - 1;
left_item_bar_x = _left(obj) + ri->x1;
right_item_bar_x = _left(obj) + ri->x2;
item_bg_height = data->tab_height - 3;
text_y = y + data->ty + 1;
item_bar_width = right_item_bar_x - left_item_bar_x + 1;
SetAPen(_rp(obj), _pens(obj)[MPEN_BACKGROUND]);
RectFill(_rp(obj), left_item_bar_x, top_item_bar_y + 4,
right_item_bar_x, bottom_item_bar_y);
RectFill(_rp(obj), left_item_bar_x + 2, top_item_bar_y + 2,
right_item_bar_x - 2, top_item_bar_y + 3);
RectFill(_rp(obj), left_item_bar_x + 4, top_item_bar_y + 1,
right_item_bar_x - 4, top_item_bar_y + 1);
}
/* top horiz bar */
SetAPen(_rp(obj), _pens(obj)[MPEN_SHINE]);
RectFill(_rp(obj), left_item_bar_x + 4, top_item_bar_y, right_item_bar_x - 4, top_item_bar_y);
/* left vert bar */
RectFill(_rp(obj), left_item_bar_x, top_item_bar_y + 4, left_item_bar_x, bottom_item_bar_y);
WritePixel(_rp(obj), left_item_bar_x + 1, top_item_bar_y + 3);
WritePixel(_rp(obj), left_item_bar_x + 1, top_item_bar_y + 2);
WritePixel(_rp(obj), left_item_bar_x + 2, top_item_bar_y + 1);
WritePixel(_rp(obj), left_item_bar_x + 3, top_item_bar_y + 1);
SetAPen(_rp(obj), _pens(obj)[MPEN_HALFSHINE]);
WritePixel(_rp(obj), left_item_bar_x + 3, top_item_bar_y);
WritePixel(_rp(obj), left_item_bar_x + 4, top_item_bar_y + 1);
WritePixel(_rp(obj), left_item_bar_x + 2, top_item_bar_y + 2);
WritePixel(_rp(obj), left_item_bar_x + 3, top_item_bar_y + 2);
WritePixel(_rp(obj), left_item_bar_x + 2, top_item_bar_y + 3);
WritePixel(_rp(obj), left_item_bar_x, top_item_bar_y + 3);
WritePixel(_rp(obj), left_item_bar_x + 1, top_item_bar_y + 4);
if (data->active == item)
{
/* bottom horiz bar */
SetAPen(_rp(obj), _pens(obj)[MPEN_SHINE]);
WritePixel(_rp(obj), left_item_bar_x - 1, bottom_item_bar_y + 1);
SetAPen(_rp(obj), _pens(obj)[MPEN_SHADOW]);
WritePixel(_rp(obj), right_item_bar_x + 1, bottom_item_bar_y + 1);
DoMethod(obj,MUIM_DrawBackground, left_item_bar_x - 1, bottom_item_bar_y + 2,
item_bar_width + (2 * 1), 1,
left_item_bar_x - 1, bottom_item_bar_y + 2, 0);
}
/* right vert bar */
SetAPen(_rp(obj), _pens(obj)[MPEN_SHADOW]);
WritePixel(_rp(obj), right_item_bar_x - 1, top_item_bar_y + 2);
RectFill(_rp(obj), right_item_bar_x, top_item_bar_y + 4, right_item_bar_x, bottom_item_bar_y);
SetAPen(_rp(obj), _pens(obj)[MPEN_HALFSHADOW]);
WritePixel(_rp(obj), right_item_bar_x - 2, top_item_bar_y + 1);
WritePixel(_rp(obj), right_item_bar_x - 1, top_item_bar_y + 3);
WritePixel(_rp(obj), right_item_bar_x, top_item_bar_y + 3);
SetAPen(_rp(obj), _pens(obj)[MPEN_BACKGROUND]);
WritePixel(_rp(obj), right_item_bar_x - 3, top_item_bar_y + 1);
/* text */
fitwidth = item_bar_width - TEXTSPACING;
fitlen = TextFit(_rp(obj), ri->text, ri->textlen, &extent, NULL, 1, fitwidth, data->tab_height);
fitpix = extent.te_Width;
/* D(bug("extent for %s (len=%d) in %d pix = %d chars, %d pix [%x,%x,%x]\n", */
/* ri->text, ri->textlen, fitwidth, fitlen, fitpix, _rp(obj), _rp(obj)->Font, _font(obj))); */
x = left_item_bar_x + (item_bar_width - fitpix) / 2;
SetDrMd(_rp(obj), JAM1);
SetAPen(_rp(obj), _pens(obj)[MPEN_TEXT]);
Move(_rp(obj), x, text_y);
Text(_rp(obj), ri->text, fitlen);
}
ULONG RENDER_Frame(piClass *cl,piObject *o,Msg msg)
{
UWORD x,y,w,h;
struct Node_Frame *nf;
struct Node_Window *nw;
BOOL fill=FALSE;
piGetAttr(o,OBJ_Node,(ULONG *)&nf);
piGetAttr(nf->nf_Window,OBJ_Node,(ULONG *)&nw);
x=piCX(o);
y=piCY(o);
w=piCW(o);
h=piCH(o);
SetAPen(nw->nw_Window->RPort,DrawInfo->dri_Pens[BACKGROUNDPEN]);
SetDrMd(nw->nw_Window->RPort,JAM1);
RectFill(nw->nw_Window->RPort,x,y,x+w,y+h);
switch(nf->nf_FrameType)
{
case FTYPE_BUTTON:
DrawBevelBox(nw->nw_Window->RPort,x,y,w+1,h+1,
GTBB_FrameType, BBFT_BUTTON,
(nf->nf_Flags&MYFR_Recessed) ? GTBB_Recessed : TAG_IGNORE, TRUE,
GT_VisualInfo,VisualInfo,
TAG_DONE);
break;
case FTYPE_ICONDROPBOX:
DrawBevelBox(nw->nw_Window->RPort,x,y,w+1,h+1,
GTBB_FrameType, BBFT_ICONDROPBOX,
(nf->nf_Flags&MYFR_Recessed) ? GTBB_Recessed : TAG_IGNORE, TRUE,
GT_VisualInfo,VisualInfo,
TAG_DONE);
break;
case FTYPE_RIDGE:
DrawBevelBox(nw->nw_Window->RPort,x,y,w+1,h+1,
GTBB_FrameType, BBFT_RIDGE,
(nf->nf_Flags&MYFR_Recessed) ? GTBB_Recessed : TAG_IGNORE, TRUE,
GT_VisualInfo,VisualInfo,
TAG_DONE);
break;
case FTYPE_HORIZONTALLINE:
DrawBevelBox(nw->nw_Window->RPort,x,y,w+1,2,
GTBB_FrameType, BBFT_BUTTON,
(nf->nf_Flags&MYFR_Recessed) ? GTBB_Recessed : TAG_IGNORE, TRUE,
GT_VisualInfo,VisualInfo,
TAG_DONE);
nf->nf_Height=2;
break;
case FTYPE_VERTICALLINE:
DrawBevelBox(nw->nw_Window->RPort,x,y,2,h+1,
GTBB_FrameType, BBFT_BUTTON,
(nf->nf_Flags&MYFR_Recessed) ? GTBB_Recessed : TAG_IGNORE, TRUE,
GT_VisualInfo,VisualInfo,
TAG_DONE);
nf->nf_Width=2;
break;
}
if(nf->nf_Selected && GUI.gui_Mode==MODE_FRAME)
{
SetAPen(nw->nw_Window->RPort,1);
SetDrMd(nw->nw_Window->RPort,COMPLEMENT);
DrawRect(nw->nw_Window->RPort,x,y,fill);
DrawRect(nw->nw_Window->RPort,x+w-5,y,fill);
DrawRect(nw->nw_Window->RPort,x+w-5,y+h-5,fill);
DrawRect(nw->nw_Window->RPort,x,y+h-5,fill);
DrawRect(nw->nw_Window->RPort,x+(w/2)-2,y,fill);
DrawRect(nw->nw_Window->RPort,x+(w/2)-2,y+h-5,fill);
DrawRect(nw->nw_Window->RPort,x,y+(h/2)-2,fill);
DrawRect(nw->nw_Window->RPort,x+w-5,y+(h/2)-2,fill);
/*
RectFill(nw->nw_Window->RPort,x, y, x+6, y+3);
RectFill(nw->nw_Window->RPort,x+w-6, y, x+w, y+3);
RectFill(nw->nw_Window->RPort,x+w-6, y+h-3, x+w, y+h);
RectFill(nw->nw_Window->RPort,x, y+h-3, x+6, y+h);
RectFill(nw->nw_Window->RPort,x+(w/2)-3,y, x+(w/2)+3,y+3);
RectFill(nw->nw_Window->RPort,x+(w/2)-3,y+h-3, x+(w/2)+3,y+h);
RectFill(nw->nw_Window->RPort,x, y+(h/2)-2,x+6, y+(h/2)+2);
RectFill(nw->nw_Window->RPort,x+w-6, y+(h/2)-2,x+w, y+(h/2)+2);
*/
}
return TRUE;
}
static void Action(void)
{
struct RastPort *rp;
struct Region *dr;
struct RegionRectangle *rr;
WORD x, y, x1, y1, x2, y2, i, count = 0;
PutStr("Activate the window whose damagelist you want to see.\n");
PutStr("You have 3 seconds of time!\n\n");
Delay(3*50);
win = IntuitionBase->ActiveWindow;
if (!win) Cleanup("No active window!");
scr = win->WScreen;
lay = win->WLayer;
dr = lay->DamageList;
if (!dr) Cleanup("Layer does not have a damagelist!");
rr = dr->RegionRectangle;
if (!rr) Cleanup("Damagelist is empty!");
if (!(rp = CloneRastPort(&win->WScreen->RastPort)))
{
Cleanup("Can´t clone screen rastport!");
}
SetDrMd(rp,JAM1);
while(rr)
{
x1 = lay->bounds.MinX + dr->bounds.MinX + rr->bounds.MinX;
y1 = lay->bounds.MinY + dr->bounds.MinY + rr->bounds.MinY;
x2 = lay->bounds.MinX + dr->bounds.MinX + rr->bounds.MaxX;
y2 = lay->bounds.MinY + dr->bounds.MinY + rr->bounds.MaxY;
Printf("#%04d (%4d,%4d) - (%4d, %4d) Size: %4d x %4d\n",
++count,
x1,
y1,
x2,
y2,
x2 - x1 + 1,
y2 - y1 + 1);
for(i = 0; i < (Args[ARG_FAST] ? 1 : 8);i++)
{
SetAPen(rp,1 + (i & 1));
if (Args[ARG_RECTFILL])
{
RectFill(rp,x1,y1,x2,y2);
} else {
RectFill(rp,x1,y1,x2,y1);
RectFill(rp,x2,y1,x2,y2);
RectFill(rp,x1,y2,x2,y2);
RectFill(rp,x1,y1,x1,y2);
}
if (!Args[ARG_FAST]) Delay(10);
}
if (Args[ARG_NUMBERS])
{
__sprintf(s,"%d",count);
i = TextLength(rp,s,strlen(s));
x = (x1 + x2 - i) / 2;
y = (y1 + y2 - rp->TxHeight) / 2;
if (x < 0)
{
x = 0;
} else if (x >= scr->Width - i)
{
x = scr->Width - i - 1;
}
if (y < 0)
{
y = 0;
} else if (y >= scr->Height - rp->TxHeight)
{
y = scr->Height - rp->TxHeight - 1;
}
i = strlen(s);
SetAPen(rp,1);
Move(rp,x + 1, y + 1 + rp->TxBaseline);
Text(rp,s,i);
SetAPen(rp,2);
Move(rp,x, y + rp->TxBaseline);
Text(rp,s,i);
}
rr = rr->Next;
}
FreeRastPort(rp);
}
/**************************************************************************
Render tab bar
**************************************************************************/
static void RenderRegisterTab(struct IClass *cl, Object *obj, ULONG flags)
{
struct Register_DATA *data = INST_DATA(cl, obj);
WORD tabx;
/*
* Erase / prepare for drawing
*/
if (flags & MADF_DRAWOBJECT)
{
DoMethod(obj, MUIM_DrawParentBackground, data->left, data->top,
data->framewidth, data->tab_height - 1, data->left, data->top, 0);
}
else
{
/* draw parent bg over oldactive */
IPTR method;
WORD old_left, old_top, old_width, old_height;
struct RegisterTabItem *ri = &data->items[data->oldactive];
if (data->oldactive >= data->columns) method = MUIM_DrawBackground;
else method = MUIM_DrawParentBackground;
old_left = _left(obj) + ri->x1 - 2;
old_top = _top(obj) + ri->y1;
old_width = ri->x2 - ri->x1 + 5;
old_height = data->tab_height - 1;
DoMethod(obj, method, old_left, old_top,
old_width, old_height, old_left, old_top, 0);
SetDrMd(_rp(obj), JAM1);
SetAPen(_rp(obj), _pens(obj)[MPEN_SHINE]);
RectFill(_rp(obj), old_left, old_top + old_height, old_left + old_width, old_top + old_height);
}
SetDrMd(_rp(obj), JAM1);
SetAPen(_rp(obj), _pens(obj)[MPEN_SHINE]);
SetFont(_rp(obj), _font(obj));
SetSoftStyle(_rp(obj), FS_NORMAL, AskSoftStyle(_rp(obj)));
/*
* Draw new graphics
*/
/* register frame */
if (flags & MADF_DRAWOBJECT || (data->active / data->columns != data->oldactive / data->columns))
{
int i,y,tabs_on_bottom = 0;
SetAPen(_rp(obj), _pens(obj)[MPEN_SHINE]);
RectFill(_rp(obj), data->left,
data->top + data->tab_height - 1,
data->left,
data->top + data->tab_height + data->frameheight - 1);
y = data->top + data->tab_height - 1;
for (i=0; i<data->rows; i++)
{
if (!tabs_on_bottom && (i > data->active/data->columns))
{
y = _bottom(obj) - muiAreaData(obj)->mad_InnerBottom + data->tab_height;
tabs_on_bottom = 1;
}
RectFill(_rp(obj), data->left + 1, y, data->left + data->framewidth - 2, y);
y += data->tab_height;
}
SetAPen(_rp(obj), _pens(obj)[MPEN_SHADOW]);
RectFill(_rp(obj), data->left + data->framewidth - 1,
data->top + data->tab_height - 1,
data->left + data->framewidth - 1,
data->top + data->tab_height + data->frameheight - 1);
RectFill(_rp(obj), data->left + 1,
data->top + data->tab_height + data->frameheight - 1,
data->left + data->framewidth - 2,
data->top + data->tab_height + data->frameheight - 1);
for(i = 0, tabx = 0; i < data->numitems; i++)
{
RenderRegisterTabItem(cl, obj, i);
}
}
else
{
/* If active register has been changed and is on same row we simply draw both registers only */
RenderRegisterTabItem(cl, obj, data->active);
RenderRegisterTabItem(cl, obj, data->oldactive);
}
}
