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 ();
}
int statusbar_create(video_canvas_t *canvas)
{
int i;
canvas->os->font = OpenDiskFont((struct TextAttr *)&led_font_attr);
if (canvas->os->font) {
SetFont(canvas->os->window->RPort, canvas->os->font);
}
/* else we use system default font */
for (i=0; i<b_num; i++) {
#ifndef AMIGAOS4
canvas->os->pens[i] = ObtainBestPen(canvas->os->window->WScreen->ViewPort.ColorMap, palette[i].red * 0x01010101, palette[i].green * 0x01010101, palette[i].blue * 0x01010101, TAG_DONE);
#else
canvas->os->pens[i] = ObtainBestPen(canvas->os->window->WScreen->ViewPort.ColorMap, palette[i].red * 0x01010101, palette[i].green * 0x01010101, palette[i].blue * 0x01010101);
#endif
}
#define MAXSTR "00: 00.0"
canvas->os->disk_width = TextLength(canvas->os->window->RPort, MAXSTR, strlen(MAXSTR)) + 14 + 7;
#undef MAXSTR
#define MAXSTR "000"
canvas->os->tape_width = TextLength(canvas->os->window->RPort, MAXSTR, strlen(MAXSTR)) + 28 + 7 ;
#undef MAXSTR
canvas->os->has_statusbar = 1;
statusbar_refresh(REFRESH_ALL);
return 0;
}
/*** Ask for a new font, fixed or not ***/
struct TextFont *change_fonts(struct TextAttr *buf, void *Wnd, BOOL fixed)
{
struct FontRequester *fr;
struct TextFont *newfont = NULL;
if((fr = (void *) AllocAslRequestTags(ASL_FontRequest,
ASLFO_FixedWidthOnly, fixed,
ASLFO_SleepWindow, TRUE,
ASLFO_InitialName, (ULONG)buf->ta_Name,
ASLFO_InitialSize, buf->ta_YSize,
ASLFO_Window, (ULONG)Wnd,
TAG_DONE)))
{
if( AslRequest(fr, NULL) )
{
/* User may hit cancel! */
newfont = (void *) OpenDiskFont( &fr->fo_Attr );
if( newfont )
{
CopyMem(&fr->fo_Attr, buf, sizeof(*buf));
/* The ta_Name field will be freed with FreeAslRequest call ! */
buf->ta_Name = newfont->tf_Message.mn_Node.ln_Name;
}
else
ThrowError(Wnd, ErrMsg(ERR_LOADFONT));
}
FreeAslRequest(fr);
/* Window will be reinitiated later... */
}
return newfont;
}
int OpenBlankerWindow( void )
{
struct NewGadget ng;
struct Gadget *g;
UWORD lc, tc;
UWORD wleft = BlankerLeft, wtop = BlankerTop, ww, wh;
ComputeFont( BlankerWidth, BlankerHeight );
ww = ComputeX( BlankerWidth );
wh = ComputeY( BlankerHeight );
if (( wleft + ww + OffX + Scr->WBorRight ) > Scr->Width ) wleft = Scr->Width - ww;
if (( wtop + wh + OffY + Scr->WBorBottom ) > Scr->Height ) wtop = Scr->Height - wh;
if ( ! ( BlankerFont = OpenDiskFont( Font )))
return( 5L );
if ( ! ( g = CreateContext( &BlankerGList )))
return( 1L );
for( lc = 0, tc = 0; lc < Blanker_CNT; lc++ ) {
CopyMem((char * )&BlankerNGad[ lc ], (char * )&ng, (long)sizeof( struct NewGadget ));
ng.ng_VisualInfo = VisualInfo;
ng.ng_TextAttr = Font;
ng.ng_LeftEdge = OffX + ComputeX( ng.ng_LeftEdge );
ng.ng_TopEdge = OffY + ComputeY( ng.ng_TopEdge );
ng.ng_Width = ComputeX( ng.ng_Width );
ng.ng_Height = ComputeY( ng.ng_Height);
BlankerGadgets[ lc ] = g = CreateGadgetA((ULONG)BlankerGTypes[ lc ], g, &ng, ( struct TagItem * )&BlankerGTags[ tc ] );
while( BlankerGTags[ tc ] ) tc += 2;
tc++;
if ( NOT g )
return( 2L );
}
if ( ! ( BlankerWnd = OpenWindowTags( NULL,
WA_Left, wleft,
WA_Top, wtop,
WA_Width, ww + OffX + Scr->WBorRight,
WA_Height, wh + OffY + Scr->WBorBottom,
WA_IDCMP, BUTTONIDCMP|LISTVIEWIDCMP|IDCMP_MENUPICK|IDCMP_CLOSEWINDOW|IDCMP_VANILLAKEY|IDCMP_REFRESHWINDOW,
WA_Flags, WFLG_DRAGBAR|WFLG_DEPTHGADGET|WFLG_CLOSEGADGET|WFLG_SIZEBBOTTOM|WFLG_SMART_REFRESH|WFLG_ACTIVATE|WFLG_RMBTRAP,
WA_Gadgets, BlankerGList,
WA_Title, BlankerWdt,
WA_ScreenTitle, "Garshneblanker",
WA_PubScreen, Scr,
TAG_DONE )))
return( 4L );
GT_RefreshWindow( BlankerWnd, NULL );
return( 0L );
}
/*** Try to load an already loaded font ***/
struct TextFont *get_old_font( STRPTR fmt )
{
static UBYTE FontName[50];
STRPTR p;
for(p=fmt; *p && *p!='/'; p++);
if(*p == '/')
{
struct TextAttr font;
CopyMem(fmt,FontName,p-fmt); strcpy(FontName+(p-fmt),".font");
font.ta_Name = FontName;
font.ta_YSize = atoi(p+1);
font.ta_Style = FS_NORMAL;
font.ta_Flags = FPF_DISKFONT;
return (struct TextFont *)OpenDiskFont(&font);
}
return NULL;
}
// Get font
void font_get_font(font_data *data)
{
// Make window busy
SetWindowBusy(data->window);
// Existing font?
if (data->font)
{
// Free font
CloseFont(data->font);
data->font=NULL;
}
// Has the font name changed?
if (stricmp(data->font_name,data->last_font_name))
{
struct FontContentsHeader *fch;
BPTR lock;
// Empty labels
font_build_labels(data,0);
// Is the name a full path?
if (strchr(data->font_name,'/') || strchr(data->font_name,':'))
{
// Lock font
if ((lock=Lock(data->font_name,ACCESS_READ)))
{
BPTR parent;
// Get lock on parent
parent=ParentDir(lock);
// Unlock lock on file
UnLock(lock);
lock=parent;
}
}
// Lock fonts: directory
else lock=Lock("fonts:",ACCESS_READ);
// Got lock?
if (lock)
{
// Get font contents
if ((fch=NewFontContents(lock,FilePart(data->font_name))))
{
// Build labels
font_build_labels(data,fch);
// Free contents
DisposeFontContents(fch);
}
// Unlock drawer
UnLock(lock);
}
}
// Fill out TextAttr
data->attr.ta_Name=data->font_name;
data->attr.ta_YSize=data->font_size;
data->attr.ta_Style=0;
data->attr.ta_Flags=0;
// Open font
data->font=OpenDiskFont(&data->attr);
// Show font name and size
SetGadgetValue(data->list,GAD_FONT_FONT,(ULONG)FilePart(data->font_name));
SetGadgetValue(data->list,GAD_FONT_SIZE,data->font_size);
// Got font?
if (data->font)
{
short ch,pos,hi;
// First character
ch=data->font->tf_LoChar;
if (ch<33) ch=33;
// Hi character
hi=data->font->tf_HiChar;
if (hi>126 && ch<127) hi=127;
// Build display text
for (pos=0;ch<hi;ch++,pos++)
data->font_text[pos]=ch;
data->font_text[pos]=0;
// Got labels?
if (data->size_labels)
{
// Find label corresponding to this size
for (pos=0;data->size_labels[pos];pos++)
{
if (atoi(data->size_labels[pos])==data->font_size)
{
// Set cycle gadget
SetGadgetValue(data->list,GAD_FONT_CYCLE,pos);
break;
}
}
}
}
// Empty labels
else font_build_labels(data,0);
// Copy name
strcpy(data->last_font_name,data->font_name);
// Clear 'first' flag
data->first=FALSE;
// Clear window busy
ClearWindowBusy(data->window);
}
main(int argc, char *argv[])
{
unsigned char str[256];
int i;
int j;
struct RastPort rp;
unsigned char *pp;
struct BitMap bm = {
256, /* bytes per row */
8, /* rows */
0, /* flags */
1, /* depth */
0, /* pad */
0 /* planes */
};
struct TextAttr ta;
struct TextFont *tf;
struct FontRequester *fr;
struct TagItem frtags[] = {
ASL_Hail, (ULONG)"NetBSD font choices",
ASL_Width, 640,
ASL_Height, 400,
ASL_LeftEdge, 10,
ASL_TopEdge, 10,
ASL_OKText, (ULONG)"Dump",
ASL_CancelText, (ULONG)"Cancel",
ASL_FontName, (ULONG)"topaz.font",
ASL_FontHeight, 8L,
ASL_FontStyles, FS_NORMAL,
ASL_FuncFlags, FONF_STYLES | FONF_FIXEDWIDTH,
TAG_DONE
};
/* Let the user pick a font to dump */
if (fr = (struct FontRequester *)
AllocAslRequest(ASL_FontRequest, frtags)) {
if (!AslRequest(fr, NULL)) {
FreeAslRequest(fr);
fprintf(stderr, "User requested exit\n");
exit (0);
}
ta.ta_Name = (STRPTR)malloc(strlen(fr->fo_Attr.ta_Name));
strcpy(ta.ta_Name, fr->fo_Attr.ta_Name);
ta.ta_YSize = fr->fo_Attr.ta_YSize;
ta.ta_Style = fr->fo_Attr.ta_Style;
ta.ta_Flags = fr->fo_Attr.ta_Flags;
FreeAslRequest(fr);
} else {
fprintf(stderr, "Can't allocate Font Requestor\n");
exit (1);
}
/* Open the selected font */
tf = (struct TextFont *)OpenDiskFont (&ta);
if (! tf) {
fprintf (stderr, "Can't open font: %s\n", ta.ta_Name);
exit (1);
}
#ifdef DEBUG
fprintf(stderr, "Information on selected font:\n");
fprintf(stderr, "Name=%s\n", ta.ta_Name);
fprintf(stderr, "Height=%d tf_Style=%x tf_Flags=%x Width=%d Baseline=%d\n",
tf->tf_YSize, tf->tf_Style, tf->tf_Flags, tf->tf_XSize, tf->tf_Baseline);
#endif
/* Check for NetBSD restrictions */
if (tf->tf_Flags & FPF_PROPORTIONAL) {
fprintf(stderr, "NetBSD does not support proportional fonts\n");
exit (1);
}
if (tf->tf_XSize > NetBSDwidth) {
fprintf(stderr, "NetBSD does not support fonts wider than %d pixels\n", NetBSDwidth);
exit (1);
}
/* Allocate area to render font in */
InitBitMap(&bm, 1, 256 * NetBSDwidth, tf->tf_YSize);
InitRastPort (&rp);
rp.BitMap = &bm;
bm.Planes[0] = pp = AllocRaster (256 * NetBSDwidth, tf->tf_YSize);
if (!pp) {
fprintf (stderr, "Can't allocate raster!\n");
exit (1);
}
/* Initialize string to be rendered */
for (i = 32; i < 256; i++) {
str[i - 32] = i;
}
/* Render string with selected font */
SetFont (&rp, tf);
SetSoftStyle(&rp, ta.ta_Style ^ tf->tf_Style,
FSF_BOLD | FSF_UNDERLINED | FSF_ITALIC);
Move (&rp, 0, tf->tf_Baseline);
ClearEOL(&rp);
if (tf->tf_XSize != NetBSDwidth) {
/* right-justify char in cell */
Move (&rp, NetBSDwidth - tf->tf_XSize, tf->tf_Baseline);
/* Narrow font, put each character in space of normal font */
for (i = 0; i < (256 - 32); i++) {
Text (&rp, &str[i], 1);
Move (&rp, rp.cp_x + (NetBSDwidth - tf->tf_XSize), rp.cp_y);
}
} else {
Text (&rp, str, 256 - 32);
}
/* Dump them.. */
printf ("/* Generated automatically by fontdumper.c. *DONT* distribute\n");
printf (" this file, it may contain information Copyright by Commodore!\n");
printf ("\n");
printf (" Font: %s/%d\n", ta.ta_Name, tf->tf_YSize);
printf (" */\n\n");
printf ("unsigned char kernel_font_width = %d;\n", tf->tf_XSize);
printf ("unsigned char kernel_font_height = %d;\n", tf->tf_YSize);
printf ("unsigned char kernel_font_baseline = %d;\n", tf->tf_Baseline);
printf ("short kernel_font_boldsmear = %d;\n", tf->tf_BoldSmear);
printf ("unsigned char kernel_font_lo = 32;\n");
printf ("unsigned char kernel_font_hi = 255;\n\n");
printf ("unsigned char kernel_cursor[] = {\n");
for (j = 0; j < (tf->tf_YSize -1); j++) {
printf ("0xff, ");
}
printf ("0xff };\n\n");
printf ("unsigned char kernel_font[] = {\n");
for (i = 0; i < 256 - 32; i++) {
printf ("/* %c */", i + 32);
for (j = 0; j < tf->tf_YSize; j++) {
printf (" 0x%02x,", pp[i+j*256]);
}
printf ("\n");
}
printf ("};\n");
CloseFont (tf);
FreeRaster (pp, 256 * NetBSDwidth, tf->tf_YSize);
return (0);
}
/*
* Open a requester with a fixed font.
*
* Only reqtools.library seems to have the ability to use custom fonts.
* This crashes, if I don't open requtools.library manually. Is this no auto-open library !?
*
* Is there really so much code necessary, just to open a fixed width requester !?
*
* This is no WinAPI call.
*/
int MessageBox_fixed(HWND hWnd, TCHAR *lpText, TCHAR *lpCaption, UINT uType/*, UINT size*/) {
rtReqInfo *req;
ULONG ret;
BOOL i_opened_it=false;
struct TextFont *font;
struct Window *window;
struct TextAttr myta = {
"fixed.font",
8,
0,
NULL
};
struct TagItem tags[]={
{RT_TextAttr, (IPTR) &myta},
{RT_Window, NULL},
{RTEZ_ReqTitle , (IPTR) lpCaption},
{RT_ReqPos, REQPOS_CENTERSCR},
{RT_WaitPointer, TRUE},
{RT_LockWindow, TRUE},
{TAG_DONE}
};
DebOut("Caption: %s\n", lpCaption);
DebOut("Text: %s\n", lpText);
font=OpenDiskFont(&myta);
if(!font) {
DebOut("unable to open fixed.font\n");
tags[0].ti_Tag=TAG_IGNORE;
}
window=(struct Window *)XGET(win, MUIA_Window_Window);
if(window) {
DebOut("window: %lx\n", window);
tags[1].ti_Data=(IPTR) window;
}
else {
DebOut("ERROR: no window !?\n");
tags[1].ti_Tag=TAG_IGNORE;
}
/* do I really have to open it !? */
if(!ReqToolsBase) {
i_opened_it=TRUE;
ReqToolsBase = (struct ReqToolsBase *)OpenLibrary("reqtools.library", 0);
}
if(!ReqToolsBase) {
fprintf(stderr, "ERROR: Unable to open reqtools.library!\n");
DebOut("ERROR: Unable to open reqtools.library!\n");
return FALSE;
}
ret=rtEZRequestA(lpText, "Ok", NULL, NULL, tags);
if(i_opened_it) {
CloseLibrary((struct Library *)ReqToolsBase);
ReqToolsBase=NULL;
}
if(font) {
CloseFont(font);
}
return TRUE;
}
/*** Try to load a preference file ***/
UBYTE load_prefs(PREFS *prefs, STRPTR filename)
{
APTR file;
UBYTE err = RETURN_OK;
/* Locate preference file */
if( (file = open_prefs(filename, MODE_USE)) )
{
/* Search for PREF/JANO chunk in this file */
if( !StopChunk(file, ID_PREF, ID_JANO) )
{
if( !ParseIFF(file, IFFPARSE_SCAN) )
{
struct ContextNode * cn = CurrentChunk(file);
STRPTR buffer = NULL;
UWORD ByteRead = 0;
if( cn->cn_Type == ID_PREF && cn->cn_ID == ID_JANO &&
(buffer = (STRPTR) AllocVec(cn->cn_Size, MEMF_PUBLIC)) &&
ReadChunkBytes(file, buffer, cn->cn_Size) == cn->cn_Size )
{
/* He have read the file, converts it into PREFS struct */
memset(prefs, 0, sizeof(*prefs));
prefs->wordssep = WordsSep;
prefs->attrtxt.ta_Name = FontName;
prefs->attrscr.ta_Name = FontName+30;
while(ByteRead < cn->cn_Size)
{
register STRPTR src;
src = buffer + ByteRead;
if(src[0] < MAX_NUMFIELD) {
register STRPTR dest = (STRPTR)prefs+offsets[*src];
if(sizefields[ *src ] == 0) dest = *(STRPTR *)dest;
CopyMem(src+2, dest, src[1]);
}
ByteRead += src[1]+2;
}
} else err = RETURN_FAIL;
if(buffer != NULL) FreeVec( buffer );
} else err = RETURN_FAIL;
} else err = RETURN_FAIL;
close_prefs(file);
} else err = RETURN_FAIL;
if(err == RETURN_OK)
{
info_screen(prefs, IntuitionBase->ActiveScreen);
/* If user wants to use a custom font for its interface, try lo **
** load it, otherwise use default screen font of parent screen: */
if(!prefs->use_scrfont ||
!(prefs->scrfont = (void *) OpenDiskFont( &prefs->attrscr )) )
prefs->scrfont = prefs->parent->RastPort.Font;
/* Ditto with text font */
if(!prefs->use_txtfont ||
!(prefs->txtfont = (void *) OpenDiskFont( &prefs->attrtxt )) )
prefs->txtfont = GfxBase->DefaultFont;
/* Makes valid pointers */
text_to_attr(prefs->scrfont, &prefs->attrscr);
text_to_attr(prefs->txtfont, &prefs->attrtxt);
/* Special characters that separate words */
unpack_separators(prefs->wordssep);
}
else set_default_prefs(prefs, IntuitionBase->ActiveScreen);
/* All done */
return err;
}
// Initialise a new lister
IPC_StartupCode(lister_init, Lister *, lister, static)
{
// Store IPC and lister pointers
lister->ipc=ipc;
ipc->userdata=lister;
// Store IPC pointer in backdrop info
lister->backdrop_info->ipc=ipc;
// Path history list
lister->path_history=Att_NewList(LISTF_LOCK);
// Initialise reselection
InitReselect(&lister->reselect);
lister->abort_signal=-1;
// Create message ports and signals
if (!(lister->app_port=CreateMsgPort()) ||
!(lister->timer_port=CreateMsgPort()) ||
(lister->hot_name_bit=AllocSignal(-1))==-1 ||
(lister->abort_signal=AllocSignal(-1))==-1)
return 0;
// Allocate some timers
if (!(lister->busy_timer=AllocTimer(UNIT_VBLANK,lister->timer_port)) ||
!(lister->scroll_timer=AllocTimer(UNIT_VBLANK,lister->timer_port)) ||
!(lister->edit_timer=AllocTimer(UNIT_VBLANK,lister->timer_port)) ||
!(lister->foo_timer=AllocTimer(UNIT_VBLANK,lister->timer_port)))
return 0;
StartTimer(lister->foo_timer,5,0);
// Create regions
if (!(lister->title_region=NewRegion()) ||
!(lister->refresh_extra=NewRegion()))
return 0;
// Lock buffer list
lock_listlock(&GUI->buffer_list,TRUE);
// Allocate initial buffer
if (!(lister->cur_buffer=lister_get_empty_buffer()) &&
!(lister->cur_buffer=lister_new_buffer(lister)))
return 0;
lister->cur_buffer->buf_CurrentLister=lister;
// Unlock buffer list
unlock_listlock(&GUI->buffer_list);
// Allocate "special" buffer
if (!(lister->special_buffer=buffer_new()))
return 0;
// Build popup menu
lister_build_menu(lister);
// Initialise flags
lister->flags|=LISTERF_FIRST_TIME;
lister->flags2|=LISTERF2_UNAVAILABLE;
lister->tool_sel=-1;
lister->toolbar_offset=0;
// Fix priority
lister->normal_pri=environment->env->settings.pri_lister[0];
lister->busy_pri=environment->env->settings.pri_lister[1];
SetTaskPri((struct Task *)lister->ipc->proc,lister->normal_pri);
// Get font to use
lister->lister_font.ta_Name=lister->font_name;
lister->lister_font.ta_YSize=lister->font_size;
lister->lister_font.ta_Flags=0;
lister->lister_font.ta_Style=0;
// Open font
if ((lister->font=OpenDiskFont(&lister->lister_font)))
{
// Proportional font?
if (lister->font->tf_Flags&FPF_PROPORTIONAL)
lister->more_flags|=LISTERF_PROP_FONT;
// Set font in text area
InitRastPort(&lister->text_area.rast);
SetFont(&lister->text_area.rast,lister->font);
}
return 1;
}
struct Window *lister_open_window(Lister *lister,struct Screen *screen)
{
struct Gadget *gadget,*lock_gad;
struct IBox *dims;
ULONG mode;
// If lister is already open, return
if (!lister || lister->window) return lister->window;
// Is lister meant to be iconified?
if (lister->flags&LISTERF_ICONIFIED) return 0;
// Is lister iconified?
if (lister->appicon)
{
// Update icon position
lister_update_icon(lister);
// Remove AppIcon
RemoveAppIcon(lister->appicon);
lister->appicon=0;
// Free icon
if (lister->appicon_icon)
{
FreeDiskObjectCopy(lister->appicon_icon);
lister->appicon_icon=0;
}
}
// If lister was zoomed, swap dimensions around
if ((lister->dimensions.wd_Flags&(WDF_VALID|WDF_ZOOMED))==(WDF_VALID|WDF_ZOOMED))
{
struct IBox temp;
// Swap dimensions
temp=lister->dimensions.wd_Zoomed;
lister->dimensions.wd_Zoomed=lister->dimensions.wd_Normal;
lister->dimensions.wd_Normal=temp;
// Clear zoomed flag
lister->dimensions.wd_Flags&=~WDF_ZOOMED;
}
// Get dimensions pointer
dims=&lister->dimensions.wd_Normal;
// Get screen font
AskFont(&screen->RastPort,&lister->screen_font);
// Calculate minimum size
lister_calc_limits(lister,screen);
// Check lister size against minimums
if (dims->Width<lister->win_limits.Left) dims->Width=lister->win_limits.Left;
if (dims->Height<lister->win_limits.Top) dims->Height=lister->win_limits.Top;
// Initialise backfill pattern
#if defined(__MORPHOS__)
lister->pattern.hook.h_Entry = (HOOKFUNC)HookEntry;
lister->pattern.hook.h_SubEntry=(ULONG (*)())PatternBackfill;
#else
lister->pattern.hook.h_Entry=(ULONG (*)())PatternBackfill;
#endif
lister->pattern.hook.h_Data=lister->backdrop_info;
lister->pattern.pattern=&GUI->pattern[PATTERN_LISTER];
// Is pattern initially enabled?
if (lister->flags&LISTERF_VIEW_ICONS)
lister->pattern.disabled=FALSE;
else lister->pattern.disabled=TRUE;
// Get refresh mode
if (environment->env->lister_options&LISTEROPTF_SIMPLE) mode=WA_SimpleRefresh;
else mode=WA_SmartRefresh;
// Initialise boopsi list
NewList(&lister->backdrop_info->boopsi_list);
// Create iconify gadget
gadget=
create_iconify_gadget(
screen,
&lister->backdrop_info->boopsi_list,
(lister->flags&LISTERF_LOCK_POS)?TRUE:FALSE);
// Create lock gadget
if (!(GUI->flags2&GUIF2_NO_PADLOCK) &&
(lock_gad=
CreateTitleGadget(
screen,
&lister->backdrop_info->boopsi_list,
(lister->flags&LISTERF_LOCK_POS)?TRUE:FALSE,
(gadget)?-gadget->Width+TBGADGETOFFSET:0,
IM_LOCK,
GAD_LOCK)))
{
// Chain gadgets
if (gadget) gadget->NextGadget=lock_gad;
else gadget=lock_gad;
// Fix selection flags
lock_gad->Activation|=GACT_TOGGLESELECT;
if (lister->more_flags&LISTERF_LOCK_FORMAT)
lock_gad->Flags|=GFLG_SELECTED;
}
// Open lister window
if (!(lister->window=OpenWindowTags(0,
WA_Left,dims->Left,
WA_Top,dims->Top,
WA_Width,dims->Width,
WA_Height,dims->Height,
WA_MinWidth,lister->win_limits.Left,
WA_MinHeight,lister->win_limits.Top,
WA_MaxWidth,(ULONG)~0,
WA_MaxHeight,(ULONG)~0,
(lister->dimensions.wd_Flags&WDF_VALID)?WA_Zoom:TAG_IGNORE,(ULONG)&lister->dimensions.wd_Zoomed,
WA_IDCMP,
IDCMP_ACTIVEWINDOW|
IDCMP_CHANGEWINDOW|
IDCMP_CLOSEWINDOW|
IDCMP_GADGETDOWN|
IDCMP_GADGETUP|
IDCMP_INACTIVEWINDOW|
IDCMP_MENUHELP|
IDCMP_MENUPICK|
IDCMP_MENUVERIFY|
IDCMP_MOUSEBUTTONS|
IDCMP_MOUSEMOVE|
#ifdef __amigaos4__
IDCMP_EXTENDEDMOUSE|
#endif
IDCMP_NEWSIZE|
IDCMP_REFRESHWINDOW|
IDCMP_RAWKEY,
WA_AutoAdjust,TRUE,
WA_CloseGadget,!(lister->flags&LISTERF_LOCK_POS),
WA_DragBar,!(lister->flags&LISTERF_LOCK_POS),
WA_DepthGadget,TRUE,
WA_MenuHelp,TRUE,
WA_NewLookMenus,TRUE,
WA_SizeGadget,TRUE,
WA_SizeBRight,TRUE,
WA_SizeBBottom,TRUE,
WA_CustomScreen,screen,
WA_ScreenTitle,GUI->screen_title,
WA_WindowName, DOPUS_WIN_NAME,
WA_Gadgets,gadget,
mode,TRUE,
(lister->flags&LISTERF_LOCK_POS)?WA_Title:TAG_IGNORE,"",
WA_BackFill,&lister->pattern,
TAG_END))) return 0;
// Fix title gadgets
FixTitleGadgets(lister->window);
// Save left border
lister->old_border_left=lister->window->BorderLeft;
// Initialise ID
SetWindowID(lister->window,&lister->id,WINDOW_LISTER,(struct MsgPort *)lister->ipc);
// Initialise dimensions
InitWindowDims(lister->window,&lister->dimensions);
// Close existing font
if (lister->font) CloseFont(lister->font);
// Clear proportional font flag
lister->more_flags&=~LISTERF_PROP_FONT;
// Open font
if ((lister->font=OpenDiskFont(&lister->lister_font)))
{
// Proportional font?
if (lister->font->tf_Flags&FPF_PROPORTIONAL)
{
lister->more_flags|=LISTERF_PROP_FONT;
}
}
// Got a font?
if (lister->font)
{
// Set font in window and text area
SetFont(lister->window->RPort,lister->font);
SetFont(&lister->text_area.rast,lister->font);
}
// Otherwise, get info on default font
else
{
// Get font info
AskFont(lister->window->RPort,&lister->lister_font);
}
// Get DrawInfo
lister->drawinfo=GetScreenDrawInfo(lister->window->WScreen);
// Set menus
display_get_menu(lister->window);
display_fix_menu(
lister->window,
(lister->flags&LISTERF_VIEW_ICONS)?WINDOW_LISTER_ICONS:WINDOW_LISTER,
lister);
lister_fix_menus(lister,0);
// Initialise backdrop info
backdrop_init_info(lister->backdrop_info,lister->window,0);
// Turn on gauge if needed
lister_set_gauge(lister,FALSE);
// Fill out size covering gadget
if ((gadget=FindGadgetType(lister->window->FirstGadget,GTYP_SIZING)))
{
// Copy size gadget
fill_out_cover_gadget(gadget,&lister->size_cover_gadget);
// Clear image in original gadget if lister is locked
if (lister->flags&LISTERF_LOCK_POS)
{
gadget->Flags&=~GFLG_GADGIMAGE;
gadget->GadgetRender=0;
}
}
// Fill out zoom covering gadget
if ((gadget=FindGadgetType(lister->window->FirstGadget,GTYP_WZOOM)))
{
// Copy zoom gadget
fill_out_cover_gadget(gadget,&lister->zoom_cover_gadget);
// Clear image in original gadget if lister is locked
if (lister->flags&LISTERF_LOCK_POS)
{
// Clear image in original gadget
gadget->Flags&=~GFLG_GADGIMAGE;
gadget->GadgetRender=0;
}
// Otherwise, change gadget type
else
{
// Clear zoom flag, set ID
gadget->GadgetType&=~(GTYP_SYSTYPEMASK|GTYP_SYSGADGET);
gadget->GadgetID=GAD_ZOOM;
}
}
// Is lister locked?
if (lister->flags&LISTERF_LOCK_POS)
{
// Add to window
lister->size_cover_gadget.NextGadget=0;
AddGList(lister->window,&lister->size_cover_gadget,0,1,0);
RefreshWindowFrame(lister->window);
}
// Fix next pointer
else lister->size_cover_gadget.NextGadget=&lister->zoom_cover_gadget;
// Create edit hook
lister->path_edit_hook=
GetEditHookTags(
0,
OBJECTF_NO_SELECT_NEXT,
GTCustom_History,lister->path_history,
TAG_END);
// Create path field
if (!(lister->path_field=(struct Gadget *)
NewObject(0,"dopusstrgclass",
GA_ID,GAD_PATH,
GA_Left,lister->window->BorderLeft,
GA_RelBottom,-(lister->window->BorderBottom+FIELD_FONT->tf_YSize+4),
GA_RelWidth,-(lister->window->BorderLeft+lister->window->BorderRight),
GA_Height,FIELD_FONT->tf_YSize+4,
GA_RelVerify,TRUE,
GA_Immediate,TRUE,
GTCustom_ThinBorders,TRUE,
GTCustom_NoGhost,TRUE,
STRINGA_TextVal,(lister->cur_buffer)?lister->cur_buffer->buf_Path:"",
STRINGA_MaxChars,511,
STRINGA_Buffer,lister->path_buffer,
STRINGA_UndoBuffer,GUI->global_undo_buffer,
STRINGA_WorkBuffer,GUI->global_undo_buffer+512,
STRINGA_Font,FIELD_FONT,
STRINGA_EditHook,lister->path_edit_hook,
TAG_END)))
{
lister_close(lister,0);
return 0;
}
DoMethod((Object *)lister->path_field,OM_ADDTAIL,&lister->backdrop_info->boopsi_list);
// Initialise side parent button
lister->parent_button.NextGadget=lister->path_field;
lister->parent_button.TopEdge=lister->window->BorderTop;
lister->parent_button.Width=lister->window->BorderLeft;
lister->parent_button.Height=-(lister->window->BorderTop+lister->window->BorderBottom);
lister->parent_button.Flags=GFLG_GADGHCOMP|GFLG_RELHEIGHT;
lister->parent_button.Activation=GACT_RELVERIFY;
lister->parent_button.GadgetType=GTYP_BOOLGADGET;
lister->parent_button.GadgetID=GAD_PARENT;
// Try to add AppWindow
lister->appwindow=AddAppWindowA(
WINDOW_LISTER,
(ULONG)lister,
lister->window,
lister->app_port,0);
// Is lister busy?
if (lister->flags&LISTERF_BUSY || lister->old_flags&LISTERF_BUSY)
{
lister->flags&=~(LISTERF_BUSY|LISTERF_LOCK|LISTERF_LOCKED);
lister_busy(lister,0);
}
else
if (lister->flags&LISTERF_LOCKED || lister->old_flags&LISTERF_LOCKED)
{
lister->flags&=~(LISTERF_BUSY|LISTERF_LOCK|LISTERF_LOCKED);
lister_busy(lister,1);
}
// Initialise lister flags
lister->flags&=
LISTERF_LOCK_POS|LISTERF_BUSY|
LISTERF_LOCK|LISTERF_LOCKED|
LISTERF_VIEW_ICONS|LISTERF_SHOW_ALL|LISTERF_PATH_FIELD|
LISTERF_STORED_SOURCE|LISTERF_STORED_DEST|LISTERF_ICON_ACTION|
LISTERF_FIRST_TIME;
lister->more_flags&=~LISTERF_TITLEBARRED;
// Update selection count if in icon mode
if (lister->flags&LISTERF_ICON_ACTION)
backdrop_fix_count(lister->backdrop_info,0);
// Initialise cursor setting
lister->cursor_line=-1;
lister->edit_type=-1;
// Setup lister display
lister_init_display(lister);
lister_refresh(lister,LREFRESH_FULL);
lister_refresh_name(lister);
// Clear old flags
lister->old_flags=0;
// Is this our first time open?
if (lister->flags&LISTERF_FIRST_TIME)
{
char buf[16];
// Build handle string
lsprintf(buf,"%ld",lister);
// Launch script
RunScript(SCRIPT_OPEN_LISTER,buf);
}
// If busy, show progress window
if (lister->progress_window)
ShowProgressWindow(lister->progress_window,0,lister->window);
// Fix current directory
lister_fix_cd(lister);
// Initialise things
lister->title_click=-1;
// Return window pointer
return lister->window;
}
struct TextFont *ami_font_open_disk_font(struct TextAttr *tattr)
{
struct TextFont *tfont = OpenDiskFont(tattr);
return tfont;
}
