static void getvisual(void)
{
if (!(scr = LockPubScreen(0)))
{
cleanup("Can't lock pub screen!");
}
if (!(dri = GetScreenDrawInfo(scr)))
{
cleanup("Can't get screen drawinfo!");
}
vp = &scr->ViewPort;
cm = vp->ColorMap;
pen1 = ObtainPen(cm, -1, 0, 0, 0, PENF_EXCLUSIVE);
pen2 = ObtainPen(cm, -1, 0, 0, 0, PENF_EXCLUSIVE);
pens[0] = pen1;
pens[1] = pen2;
if ((pen1 == -1) || (pen2 == -1)) cleanup("Can't obtain 2 pens!");
if (GetBitMapAttr(scr->RastPort.BitMap, BMA_DEPTH) >= 15) truecolor = TRUE;
}
static struct gui_window_2 *ami_menu_layout(struct gui_window_2 *gwin)
{
int i, j;
int txtlen = 0;
struct RastPort *rp = &scrn->RastPort;
struct DrawInfo *dri = GetScreenDrawInfo(scrn);
if(menu_glyphs_loaded == false)
ami_menu_load_glyphs(dri);
for(i=0; i <= AMI_MENU_AREXX_MAX; i++)
{
if(gwin->menutype[i] == NM_TITLE) {
j = i + 1;
txtlen = 0;
int item_size = 0;
do {
if(gwin->menulab[j] != NM_BARLABEL) {
if(gwin->menutype[j] == NM_ITEM) {
item_size = TextLength(rp, gwin->menulab[j], strlen(gwin->menulab[j]));
if(gwin->menukey[j]) {
item_size += TextLength(rp, &gwin->menukey[j], 1);
item_size += menu_glyph_width[NSA_GLYPH_AMIGAKEY];
/**TODO: take account of the size of other imagery too
*/
}
if(item_size > txtlen) {
txtlen = item_size;
}
}
}
j++;
} while((gwin->menutype[j] != NM_TITLE) && (gwin->menutype[j] != 0));
}
if(LIB_IS_AT_LEAST((struct Library *)GadToolsBase, 53, 6)) {
/* GadTools 53.6+ only. For now we will only create the menu
using label.image if there's a bitmap associated with the item. */
if((gwin->menuicon[i] != NULL) && (gwin->menulab[i] != NM_BARLABEL)) {
int icon_width = 0;
Object *submenuarrow = NULL;
Object *icon = BitMapObject,
BITMAP_Screen, scrn,
BITMAP_SourceFile, gwin->menuicon[i],
BITMAP_Masking, TRUE,
BitMapEnd;
GetAttr(IA_Width, icon, (ULONG *)&icon_width);
if((gwin->menutype[i] == NM_ITEM) && (gwin->menutype[i+1] == NM_SUB)) {
submenuarrow = NewObject(NULL, "sysiclass",
SYSIA_Which, MENUSUB,
SYSIA_DrawInfo, dri,
IA_Left, txtlen - TextLength(rp, gwin->menulab[i], strlen(gwin->menulab[i])) -
menu_glyph_width[NSA_GLYPH_SUBMENU] - icon_width,
TAG_DONE);
}
/**TODO: Checkmark/MX images and keyboard shortcuts
*/
gwin->menuobj[i] = LabelObject,
LABEL_DrawInfo, dri,
LABEL_DisposeImage, TRUE,
LABEL_Image, icon,
LABEL_Text, gwin->menulab[i],
LABEL_DisposeImage, TRUE,
LABEL_Image, submenuarrow,
LabelEnd;
if(gwin->menuobj[i]) gwin->menutype[i] |= MENU_IMAGE;
}
}
gwin->menu[i].nm_Type = gwin->menutype[i];
if(gwin->menuobj[i])
gwin->menu[i].nm_Label = (void *)gwin->menuobj[i];
else
gwin->menu[i].nm_Label = gwin->menulab[i];
if(gwin->menukey[i]) gwin->menu[i].nm_CommKey = &gwin->menukey[i];
gwin->menu[i].nm_Flags = 0;
if(gwin->menu_hook[i].h_Entry) gwin->menu[i].nm_UserData = &gwin->menu_hook[i];
if(gwin->menuicon[i]) {
free(gwin->menuicon[i]);
gwin->menuicon[i] = NULL;
}
}
FreeScreenDrawInfo(scrn, dri);
return gwin;
}
struct DragObj * PRIVATE CreateDragObj(struct DragGadget *dg,int x,int y)
{
struct Screen *scr;
struct RastPort *rp;
struct DragObj *gdo;
ULONG line;
int wordwidth;
int width,height,depth;
int i = 0,xpos,ypos;
scr = dg->dg_Window->WScreen;
rp = &scr->RastPort;
if (dg->dg_Flags & DGF_IMAGES && ((struct ImageNode *)dg->dg_Object.od_Object)->in_Image)
dg->dg_Image = ((struct ImageNode *)dg->dg_Object.od_Object)->in_Image;
if (!dg->dg_Width || !dg->dg_Height)
{
if ((dg->dg_Type == LISTVIEW_KIND) && !dg->dg_Image)
{
dg->dg_Width = dg->dg_Gadget->Width-20;
dg->dg_Height = dg->dg_ItemHeight;
}
else if (!dg->dg_RenderHook && dg->dg_Image)
{
dg->dg_Width = dg->dg_Image->Width;
dg->dg_Height = dg->dg_Image->Height;
}
else /* be sure width & height are not zero */
{
dg->dg_Width = dg->dg_Gadget->Width;
dg->dg_Height = dg->dg_Gadget->Height;
}
}
width = dg->dg_Width;
height = dg->dg_Height;
memset(&dm,0,sizeof(struct DropMessage));
if (dg->dg_Type == LISTVIEW_KIND)
{
xpos = dg->dg_Gadget->LeftEdge+2;
ypos = dg->dg_Gadget->TopEdge+2;
dg->dg_Object.od_Object = NULL;
if (y < ypos || y > ypos+dg->dg_Gadget->Height-5)
return(NULL);
line = (y-ypos)/dg->dg_ItemHeight;
ypos += line*dg->dg_ItemHeight;
GT_GetGadgetAttrs(dg->dg_Gadget,dg->dg_Window,NULL,GTLV_Labels,&dg->dg_List,TAG_END);
if (dg->dg_List && !IsListEmpty(dg->dg_List))
{
GT_GetGadgetAttrs(dg->dg_Gadget,dg->dg_Window,NULL,GTLV_Top,&i,TAG_END);
i += line;
if (i < CountNodes(dg->dg_List))
{
struct Node *ln;
dm.dm_SourceEntry = i;
for(ln = dg->dg_List->lh_Head;i;i--,ln = ln->ln_Succ);
if (dg->dg_Flags & DGF_TREEVIEW && TREENODE(ln)->tn_Flags & TNF_STATIC)
{
mx = ~0L; // avoid a following drag
return(NULL);
}
dg->dg_Object.od_Object = ln;
if (dg->dg_ObjectFunc)
dg->dg_ObjectFunc(dg->dg_Window,dg->dg_Gadget,&dg->dg_Object,dm.dm_SourceEntry);
}
}
}
else
{
if (dg->dg_ObjectFunc)
dg->dg_ObjectFunc(dg->dg_Window,dg->dg_Gadget,&dg->dg_Object,0L);
dm.dm_SourceEntry = dg->dg_SourceEntry;
xpos = x-width/2;
ypos = y-height/2;
}
if (!dg->dg_Object.od_Object)
{
mx = ~0L; // avoid a following drag
return(NULL);
}
wordwidth = (width + 15) >> 4;
depth = GetBitMapAttr(rp->BitMap,BMA_DEPTH);
if (dg->dg_Object.od_Object && (gdo = AllocMem(sizeof(struct DragObj), MEMF_CLEAR | MEMF_PUBLIC)))
{
#ifdef LOCKLAYERS
LockLayers(&scr->LayerInfo);
UnlockLayer(dg->dg_Window->RPort->Layer);
#endif
gdo->do_Screen = scr;
gdo->do_ScrRPort = rp;
gdo->do_BitMap = AllocBitMap(width,height,depth,BMF_CLEAR | BMF_MINPLANES,!(GetBitMapAttr( rp->BitMap, BMA_FLAGS ) & BMF_INTERLEAVED) ? rp->BitMap : NULL);
gdo->do_SaveBack = AllocBitMap(width,height,depth,BMF_CLEAR | BMF_MINPLANES,rp->BitMap);
gdo->do_RefreshMap = AllocBitMap(width*2,height*2,depth,BMF_CLEAR | BMF_MINPLANES,rp->BitMap);
if (GetBitMapAttr(gdo->do_BitMap,BMA_FLAGS) & BMF_STANDARD)
i = MEMF_CHIP | MEMF_PUBLIC;
else
i = 0;
gdo->do_FullShadow = AllocMem(2*wordwidth*height,i | MEMF_CLEAR);
gdo->do_HalfShadow = AllocMem(2*wordwidth*height,i);
if (gdo->do_BitMap && gdo->do_SaveBack && gdo->do_RefreshMap && gdo->do_FullShadow && gdo->do_HalfShadow)
{
InitRastPort(&gdo->do_RPort);
gdo->do_RPort.BitMap = gdo->do_BitMap;
InitRastPort(&gdo->do_RefreshRPort);
gdo->do_RefreshRPort.BitMap = gdo->do_RefreshMap;
gdo->do_DragGadget = dg;
CopyMem(&dg->dg_Object,&dm.dm_Object,sizeof(struct ObjectDescription));
dm.dm_Window = dg->dg_Window;
dm.dm_Gadget = dg->dg_Gadget;
/*** create the drag&drop image ***/
if (dg->dg_RenderHook)
{
struct LVDrawMsg lvdm;
SetFont(&gdo->do_RPort,scr->RastPort.Font);
lvdm.lvdm_MethodID = LV_DRAW;
lvdm.lvdm_RastPort = &gdo->do_RPort;
lvdm.lvdm_DrawInfo = GetScreenDrawInfo(scr);
lvdm.lvdm_Bounds.MinX = 0;
lvdm.lvdm_Bounds.MinY = 0;
lvdm.lvdm_Bounds.MaxX = width-1;
lvdm.lvdm_Bounds.MaxY = height-1;
lvdm.lvdm_State = LVR_SELECTED;
CallHookPkt(dg->dg_RenderHook,dm.dm_Object.od_Object,&lvdm);
FreeScreenDrawInfo(scr,lvdm.lvdm_DrawInfo);
}
else if (dg->dg_Image)
DrawImage(&gdo->do_RPort,dg->dg_Image,0,0);
else
ClipBlit(dg->dg_Window->RPort,xpos,ypos,&gdo->do_RPort,0,0,width,height,0xc0);
/*** initialize drag object structure ***/
gdo->do_X = -9999;
gdo->do_Y = ypos+dg->dg_Window->TopEdge;
gdo->do_PX = -9999;
gdo->do_Width = width;
gdo->do_Height = height;
gdo->do_DeltaX = xpos-x+dg->dg_Window->LeftEdge;
gdo->do_DeltaY = ypos-y+dg->dg_Window->TopEdge;
gdo->do_Mask = gdo->do_FullShadow;
/*** create masks (transparent and full imagery) ***/
if (CyberGfxBase && (GetBitMapAttr(gdo->do_BitMap,BMA_FLAGS) & BMF_STANDARD) == 0L)
{
struct BitMap tbm;
ULONG col;
InitBitMap(&tbm,1,width,height);
tbm.Planes[0] = (UBYTE *)gdo->do_FullShadow;
/* if (!GetCyberMapAttr(gdo->do_BitMap, CYBRMATTR_PIXELFMT)) */
if (GetBitMapAttr(gdo->do_BitMap, BMA_DEPTH) > 8L)
{
ULONG triplet[3];
GetRGB32(scr->ViewPort.ColorMap,0L,1L,triplet);
col = (triplet[0] & 0xff0000) | (triplet[1] & 0xff00) | (triplet[2] & 0xff);
}
else
col = 0;
// ExtractColor(rp,&tbm,col,xpos,ypos,width,height);
ExtractColor(&gdo->do_RPort,&tbm,col,0,0,width,height);
BltBitMap(&tbm,0,0,&tbm,0,0,width,height,0x50,0xff,NULL); // invertieren der Maske
}
else
{
UWORD *p = gdo->do_FullShadow;
for(ypos = 0;ypos < height;ypos++)
{
for(xpos = 0;xpos < wordwidth;xpos++,p++)
{
for(i = 0;i < depth;i++)
*p |= *((UWORD *)gdo->do_BitMap->Planes[i]+ypos*(gdo->do_BitMap->BytesPerRow >> 1)+xpos);
}
}
}
{
UWORD *p = gdo->do_HalfShadow;
CopyMem(gdo->do_FullShadow,p,2*wordwidth*height);
for(line = 0x5555,ypos = 0;ypos < height;ypos++)
{
line = ~line;
for(xpos = 0;xpos < wordwidth;xpos++,p++)
*p &= (UWORD)line;
}
}
if (!boopsigad)
FakeInputEvent();
UpdateDragObj(gdo,gdo->do_X,gdo->do_Y); /* show drag object */
return(gdo);
}
void main()
{
ULONG class,code;
struct Gadget *gadget;
struct IntuiMessage *message;
struct DrawInfo *dri;
BOOL running=TRUE;
unless(Scr=LockPubScreen("Workbench")) LEAVE;
unless(dri=GetScreenDrawInfo(Scr)) LEAVE;
unless(SmartBitMapBase=OpenLibrary("images/smartbitmap.image",36L)) LEAVE;
unless(ImClass=GetSmartBitMapClass()) LEAVE;
GetRGB32(Scr->ViewPort.ColorMap,0,1,&pal[0].R);
unless(Im=NewObject(ImClass,NULL,
IA_Left,25,
IA_Top,25,
IA_Width,20,
SMBM_Border,FALSE,
SMBM_SelBorder,TRUE,
SMBM_Screen,Scr,
SMBM_BitMap,&TBCOLORWHEELBitMap,
// SMBM_BitMap,&Size45UDBitMap,
SMBM_Palette,pal,
TAG_DONE)) LEAVE;
unless(MainWnd=OpenWindowTags(NULL,
WA_Left,0,
WA_Top,0,
WA_Width,600,
WA_Height,200,
WA_IDCMP,IDCMP_CLOSEWINDOW|IDCMP_GADGETUP,
WA_Flags,WFLG_CLOSEGADGET|WFLG_DRAGBAR|WFLG_DEPTHGADGET|WFLG_ACTIVATE|WFLG_SIZEGADGET,
WA_CustomScreen,Scr,
TAG_DONE)) LEAVE;
DrawImageState(MainWnd->RPort,(struct Image *)Im,0,0,IDS_NORMAL,dri);
while(running)
{
Wait(1L<<MainWnd->UserPort->mp_SigBit);
while(message=GT_GetIMsg(MainWnd->UserPort))
{
class=message->Class;
code=message->Code;
gadget=(struct Gadget *)message->IAddress;
GT_ReplyIMsg(message);
switch(class)
{
case IDCMP_CLOSEWINDOW:
running=FALSE;
break;
}
}
}
end:
if(MainWnd)
{
CloseWindow(MainWnd);
}
if(Im) DisposeObject(Im);
if(SmartBitMapBase) CloseLibrary(SmartBitMapBase);
if(dri) FreeScreenDrawInfo(Scr,dri);
if(Scr) UnlockPubScreen(NULL,Scr);
}
/*
** main routine. Open required library and window and draw the images.
** This routine opens a very simple window with no IDCMP. See the
** chapters on "Windows" and "Input and Output Methods" for more info.
** Free all resources when done.
*/
int main(int argc, char **argv)
{
struct Screen *screen;
struct DrawInfo *drawinfo;
struct Window *win;
struct IntuiText myIText;
struct TextAttr myTextAttr;
ULONG myTEXTPEN;
ULONG myBACKGROUNDPEN;
IntuitionBase = (struct IntuitionBase *)OpenLibrary("intuition.library",37);
if (IntuitionBase)
{
#ifdef __AROS__
if ((screen = LockPubScreen(NULL)))
#else
if (screen = LockPubScreen(NULL))
#endif
{
#ifdef __AROS__
if ((drawinfo = GetScreenDrawInfo(screen)))
#else
if (drawinfo = GetScreenDrawInfo(screen))
#endif
{
/* Get a copy of the correct pens for the screen.
** This is very important in case the user or the
** application has the pens set in a unusual way.
*/
myTEXTPEN = drawinfo->dri_Pens[TEXTPEN];
myBACKGROUNDPEN = drawinfo->dri_Pens[BACKGROUNDPEN];
/* create a TextAttr that matches the specified font. */
myTextAttr.ta_Name = drawinfo->dri_Font->tf_Message.mn_Node.ln_Name;
myTextAttr.ta_YSize = drawinfo->dri_Font->tf_YSize;
myTextAttr.ta_Style = drawinfo->dri_Font->tf_Style;
myTextAttr.ta_Flags = drawinfo->dri_Font->tf_Flags;
/* open a simple window on the workbench screen for displaying
** a text string. An application would probably never use such a
** window, but it is useful for demonstrating graphics...
*/
#ifdef __AROS__
if ((win = OpenWindowTags(NULL,
WA_PubScreen, (IPTR)screen,
WA_RMBTrap, TRUE,
WA_IDCMP, IDCMP_RAWKEY,
TAG_END)))
#else
if (win = OpenWindowTags(NULL,
WA_PubScreen, screen,
WA_RMBTrap, TRUE,
TAG_END))
#endif
{
myIText.FrontPen = myTEXTPEN;
myIText.BackPen = myBACKGROUNDPEN;
myIText.DrawMode = JAM2;
myIText.LeftEdge = MYTEXT_LEFT;
myIText.TopEdge = MYTEXT_TOP;
myIText.ITextFont = &myTextAttr;
myIText.IText = "Hello, World. ;-)";
myIText.NextText = NULL;
/* Draw the text string at 10,10 */
PrintIText(win->RPort,&myIText,10,10);
#ifdef __AROS__
/* Wait for keypress */
Wait (1L << win->UserPort->mp_SigBit);
#else
/* Wait a bit, then quit.
** In a real application, this would be an event loop,
** like the one described in the Intuition Input and
** Output Methods chapter.
*/
Delay(200);
#endif
CloseWindow(win);
}
FreeScreenDrawInfo(screen,drawinfo);
}
UnlockPubScreen(NULL,screen);
}
CloseLibrary((struct Library *)IntuitionBase);
}
return 0;
}
VOID __stdargs
__main( char *argstring )
{
static struct Args args;
LONG rev;
/* Get arguments if started from CLI */
if( !_WBenchMsg )
{
if( !( RDArgs = ReadArgs( TEMPLATE, ( IPTR * ) &args, NULL ) ) )
{
PrintFault( IoErr(), GetString( MSG_ERROR_ARGS ) );
__exit( 0 );
}
}
IntuiHook.h_Entry = ( HOOKFUNC ) IntuiMsgFunc;
// DefaultPrefs.Flags = 0;
DefaultPrefs.ReqDefaults[ RTPREF_OTHERREQ ].ReqPos = REQPOS_POINTER;
DefaultPrefs.ReqDefaults[ RTPREF_FILEREQ ].Size = 75;
DefaultPrefs.ReqDefaults[ RTPREF_FONTREQ ].Size =
DefaultPrefs.ReqDefaults[ RTPREF_SCREENMODEREQ ].Size =
DefaultPrefs.ReqDefaults[ RTPREF_VOLUMEREQ ].Size = 65;
DefaultPrefs.ReqDefaults[ RTPREF_FILEREQ ].ReqPos =
DefaultPrefs.ReqDefaults[ RTPREF_FONTREQ ].ReqPos =
DefaultPrefs.ReqDefaults[ RTPREF_SCREENMODEREQ ].ReqPos =
DefaultPrefs.ReqDefaults[ RTPREF_VOLUMEREQ ].ReqPos =
DefaultPrefs.ReqDefaults[ RTPREF_PALETTEREQ ].ReqPos = REQPOS_TOPLEFTSCR;
DefaultPrefs.ReqDefaults[ RTPREF_FILEREQ ].LeftOffset =
DefaultPrefs.ReqDefaults[ RTPREF_FONTREQ ].LeftOffset =
DefaultPrefs.ReqDefaults[ RTPREF_SCREENMODEREQ ].LeftOffset =
DefaultPrefs.ReqDefaults[ RTPREF_VOLUMEREQ ].LeftOffset =
DefaultPrefs.ReqDefaults[ RTPREF_PALETTEREQ ].LeftOffset =
DefaultPrefs.ReqDefaults[ RTPREF_OTHERREQ ].LeftOffset = 25;
DefaultPrefs.ReqDefaults[ RTPREF_FILEREQ ].TopOffset =
DefaultPrefs.ReqDefaults[ RTPREF_FONTREQ ].TopOffset =
DefaultPrefs.ReqDefaults[ RTPREF_SCREENMODEREQ ].TopOffset =
DefaultPrefs.ReqDefaults[ RTPREF_VOLUMEREQ ].TopOffset =
DefaultPrefs.ReqDefaults[ RTPREF_PALETTEREQ ].TopOffset =
DefaultPrefs.ReqDefaults[ RTPREF_OTHERREQ ].TopOffset = 18;
DefaultPrefs.ReqDefaults[ RTPREF_FILEREQ ].MinEntries = 10;
DefaultPrefs.ReqDefaults[ RTPREF_FONTREQ ].MinEntries =
DefaultPrefs.ReqDefaults[ RTPREF_SCREENMODEREQ ].MinEntries =
DefaultPrefs.ReqDefaults[ RTPREF_VOLUMEREQ ].MinEntries = 6;
DefaultPrefs.ReqDefaults[ RTPREF_FILEREQ ].MaxEntries = 50;
DefaultPrefs.ReqDefaults[ RTPREF_FONTREQ ].MaxEntries =
DefaultPrefs.ReqDefaults[ RTPREF_SCREENMODEREQ ].MaxEntries =
DefaultPrefs.ReqDefaults[ RTPREF_VOLUMEREQ ].MaxEntries = 10;
if( !( IntuitionBase = ( struct IntuitionBase * ) OpenLibrary( "intuition.library", 37 ) ) )
{
BPTR con;
if( ( con = Open( "CON:40/20/320/40/ReqTools 2.8", MODE_NEWFILE ) ) )
{
Write( con, "\nNeed OS 2.04 or better!\n", 25 );
Delay( 120L );
Close( con );
}
FreeExit( 0 );
}
InitLocale();
GfxBase = OpenLib( "graphics.library", 37 );
UtilityBase = OpenLib( "utility.library", 36 );
IconBase = OpenLib( "icon.library", 0 );
GadToolsBase = OpenLib( "gadtools.library", 37 );
ReqToolsBase = OpenLib( "reqtools.library", 38 );
rev = ReqToolsBase->LibNode.lib_Revision;
if( ( rev >= 693 && rev <= 811 ) || ( rev >= 347 && rev <= 363 ) )
{
LocEZReq( MSG_WRONG_REQTOOLS_VERSION, MSG_ABORT );
FreeExit( RETURN_FAIL );
}
if( rtLockPrefs()->PrefsSize != PREFSLEN )
{
LocEZReq( MSG_ALL_PREFS_NOT_SUPPORTED, MSG_OK );
}
rtUnlockPrefs();
if( _WBenchMsg )
{
struct WBArg *wbarg;
BPTR oldcd;
CreateIcons = TRUE;
wbarg = &_WBenchMsg->sm_ArgList[ 0 ];
oldcd = CurrentDir( wbarg->wa_Lock );
if( ( DiskObject = GetDiskObject( wbarg->wa_Name ) ) )
{
STRPTR str;
if( ( str = FindToolType( (UBYTE **)DiskObject->do_ToolTypes, "CREATEICONS" ) ) )
{
CreateIcons = Stricmp( str, "NO" );
}
if( ( str = FindToolType( (UBYTE **)DiskObject->do_ToolTypes, "SCREENFONT" ) ) )
{
UseScreenFont = Stricmp( str, "NO" );
}
if( ( str = FindToolType( (UBYTE **)DiskObject->do_ToolTypes, "PUBSCREEN" ) ) )
{
args.PubScreen = str;
}
}
CurrentDir( oldcd );
}
else
{
if( args.ScreenFont )
{
UseScreenFont = Stricmp( args.ScreenFont, "NO" );
}
}
if( !( FileReq = rtAllocRequestA( RT_FILEREQ, NULL ) ) )
{
FreeExit( RETURN_FAIL );
}
{
struct TagItem tags[] =
{
{RTFI_Dir , (IPTR)"Presets" },
{TAG_DONE }
};
rtChangeReqAttrA( FileReq, tags );
}
/* Get current prefs from ReqTools */
CopyMem( rtLockPrefs(), &RTPrefs, sizeof( struct ReqToolsPrefs ) );
rtUnlockPrefs();
/* If FROM was used load prefs from disk */
if( args.From )
{
if( !LoadConfig( args.From ) )
{
FreeExit( RETURN_ERROR );
}
}
WheelType = GetWheelType( RTPrefs.Flags );
if( !( Screen = LockPubScreen( args.PubScreen ) ) )
{
LocEZReq( MSG_COULDNT_LOCK_PUBSCREEN, MSG_ABORT );
FreeExit( RETURN_ERROR );
}
if( !( DrawInfo = GetScreenDrawInfo( Screen ) ) )
{
LocEZReq( MSG_ERROR_GETSCREENDRAWINFO, MSG_ABORT );
FreeExit( RETURN_ERROR );
}
if( !( VisualInfo = GetVisualInfoA( Screen, NULL ) ) )
{
LocEZReq( MSG_ERROR_GETVISUALINFO, MSG_ABORT );
FreeExit( RETURN_FAIL );
}
if( IntuitionBase->LibNode.lib_Version >= 39 )
{
Zoom[ 0 ] = Zoom[ 1 ] = 65535;
}
else
{
Zoom[ 1 ] = Screen->BarHeight + 1;
}
Zoom[ 2 ] = 250;
Zoom[ 3 ] = Screen->WBorTop + Screen->Font->ta_YSize + 1;
LocalizeMenus( NewMenu );
if( !( Menus = CreateMenusA( NewMenu, NULL ) ) )
{
LocEZReq( MSG_ERROR_MENUS, MSG_ABORT );
FreeExit( RETURN_FAIL );
}
LayoutMenus( Menus, VisualInfo,
GTMN_NewLookMenus, TRUE,
TAG_END );
if( !OpenGUI() )
{
LocEZReq( MSG_COULDNT_OPEN_WINDOW, MSG_ABORT );
FreeExit( RETURN_FAIL );
}
{
struct MenuItem *iconItem;
iconItem = ItemAddress( Menus, FULLMENUNUM( OPTIONS_MENU, SAVEICONS_ITEM, NOSUB ) );
if( !CreateIcons )
{
iconItem->Flags &= ~CHECKED;
}
}
CurrentReq = RTPREF_FILEREQ;
ReqDefs = &RTPrefs.ReqDefaults[ CurrentReq ];
LoopGUI();
FreeExit( 0 );
}
STATIC VOID GetPensAndFont(struct Gadget *gad,
UWORD *pens,
struct Window *win,
struct RastPort *rp,
struct IntuitionBase *IntuitionBase)
{
struct DrawInfo *dri = GetScreenDrawInfo(win->WScreen);
BOOL docursor = FALSE;
SetFont(rp, dri->dri_Font);
if (gad->Flags & GFLG_STRINGEXTEND)
{
struct StringExtend *strext;
strext = ((struct StringInfo *)gad->SpecialInfo)->Extension;
if (strext->Font)
{
SetFont(rp, strext->Font);
}
if ((gad->Flags & GFLG_SELECTED) == GFLG_SELECTED)
{
pens[STRTEXTPEN] = strext->ActivePens[0];
pens[STRBACKPEN] = strext->ActivePens[1];
}
else
{
pens[STRTEXTPEN] = strext->Pens[0];
pens[STRBACKPEN] = strext->Pens[1];
}
}
else
{
/* We don't care to lock the screen because the window we're
** drawn on does this. If the window is moved to another
** public screen we will be called again to rerender (and get new
** valid pens). If the window is closed, and the screen is closed
** we won't be here anymore.
*/
/* jDc: set the font to Topaz,8! */
if (GetPrivIBase(IntuitionBase)->TopazFont)
{
SetFont(rp,GetPrivIBase(IntuitionBase)->TopazFont);
} else {
SetFont(rp,GfxBase->DefaultFont);
}
#if 0
if ((gad->Flags & GFLG_SELECTED) == GFLG_SELECTED)
{
pens[STRTEXTPEN] = dri->dri_Pens[TEXTPEN];
pens[STRBACKPEN] = dri->dri_Pens[BACKGROUNDPEN];
}
else
{
#endif
pens[STRTEXTPEN] = dri->dri_Pens[TEXTPEN];
pens[STRBACKPEN] = dri->dri_Pens[BACKGROUNDPEN];
#if 0
}
#endif
}
pens[CURSORPEN] = dri->dri_Pens[FILLPEN];
/* do some protection against stupid apps so we don't get into white text on white background pb */
if (pens[STRTEXTPEN] == pens[STRBACKPEN])
{
if (pens[STRTEXTPEN] != 0)
{
pens[STRBACKPEN] = 0;
if (pens[STRTEXTPEN] != 3) docursor = TRUE;
}
else
{
pens[STRTEXTPEN] = 1;
pens[STRBACKPEN] = 0;
docursor = TRUE;
}
}
if ((pens[CURSORPEN] == pens[STRTEXTPEN]) || (pens[CURSORPEN] == pens[STRBACKPEN]))
{
pens[CURSORPEN] = (docursor ? 3 : ((pens[STRTEXTPEN] == 2) ? 2 : 1));
}
FreeScreenDrawInfo(win->WScreen, dri);
return;
}
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;
}
