From 4c3e25549d0271154ef111d455fd0eae6ff7e386 Mon Sep 17 00:00:00 2001 From: marcus Date: Fri, 12 Sep 2014 21:28:29 +0000 Subject: [PATCH] AROS: syscall-ified ASL, GadTools and MUI from AROS branch git-svn-id: trunk@28646 - --- .gitattributes | 3 + packages/arosunits/Makefile.fpc.fpcmake | 2 +- packages/arosunits/fpmake.pp | 3 + packages/arosunits/src/asl.pas | 555 ++++ packages/arosunits/src/gadtools.pas | 482 +++ packages/arosunits/src/mui.pas | 3894 +++++++++++++++++++++++ 6 files changed, 4938 insertions(+), 1 deletion(-) create mode 100644 packages/arosunits/src/asl.pas create mode 100644 packages/arosunits/src/gadtools.pas create mode 100644 packages/arosunits/src/mui.pas diff --git a/.gitattributes b/.gitattributes index 596ffa81c7..a615cd3272 100644 --- a/.gitattributes +++ b/.gitattributes @@ -1129,9 +1129,11 @@ packages/arosunits/Makefile.fpc.fpcmake svneol=native#text/plain packages/arosunits/fpmake.pp svneol=native#text/plain packages/arosunits/src/agraphics.pas svneol=native#text/plain packages/arosunits/src/amigados.pas svneol=native#text/plain +packages/arosunits/src/asl.pas svneol=native#text/plain packages/arosunits/src/clipboard.pas svneol=native#text/plain packages/arosunits/src/diskfont.pas svneol=native#text/plain packages/arosunits/src/exec.pas svneol=native#text/plain +packages/arosunits/src/gadtools.pas svneol=native#text/plain packages/arosunits/src/hardware.pas svneol=native#text/plain packages/arosunits/src/icon.pas svneol=native#text/plain packages/arosunits/src/iffparse.pas svneol=native#text/plain @@ -1140,6 +1142,7 @@ packages/arosunits/src/intuition.pas svneol=native#text/plain packages/arosunits/src/keymap.pas svneol=native#text/plain packages/arosunits/src/layers.pas svneol=native#text/plain packages/arosunits/src/longarray.pas svneol=native#text/plain +packages/arosunits/src/mui.pas svneol=native#text/plain packages/arosunits/src/tagsarray.pas svneol=native#text/plain packages/arosunits/src/timer.pas svneol=native#text/plain packages/arosunits/src/utility.pas svneol=native#text/plain diff --git a/packages/arosunits/Makefile.fpc.fpcmake b/packages/arosunits/Makefile.fpc.fpcmake index e38965d46e..03fc5acb28 100644 --- a/packages/arosunits/Makefile.fpc.fpcmake +++ b/packages/arosunits/Makefile.fpc.fpcmake @@ -9,7 +9,7 @@ version=2.7.1 [target] units= agraphics amigados exec hardware inputevent intuition keymap layers \ longarray tagsarray timer utility diskfont iffparse clipboard \ - workbench icon + workbench icon gadtools asl mui [compiler] includedir=src diff --git a/packages/arosunits/fpmake.pp b/packages/arosunits/fpmake.pp index f813ef08ff..89b9e81238 100644 --- a/packages/arosunits/fpmake.pp +++ b/packages/arosunits/fpmake.pp @@ -48,6 +48,9 @@ begin T:=P.Targets.AddUnit('clipboard.pas'); T:=P.Targets.AddUnit('workbench.pas'); T:=P.Targets.AddUnit('icon.pas'); + T:=P.Targets.AddUnit('gadtools.pas'); + T:=P.Targets.AddUnit('asl.pas'); + T:=P.Targets.AddUnit('mui.pas'); {$ifndef ALLPACKAGES} Run; diff --git a/packages/arosunits/src/asl.pas b/packages/arosunits/src/asl.pas new file mode 100644 index 0000000000..61b8587b8e --- /dev/null +++ b/packages/arosunits/src/asl.pas @@ -0,0 +1,555 @@ +{ + This file is part of the Free Pascal run time library. + Copyright (c) 2014 by Free Pascal development team + + asl.library functions + + See the file COPYING.FPC, included in this distribution, + for details about the copyright. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + + **********************************************************************} + +unit asl; + +{$mode objfpc} + +interface + +uses + exec, utility, workbench, agraphics, tagsarray; + +{************************************************************************} + +CONST + ASLNAME: PChar = 'asl.library'; + ASL_TB = TAG_USER+$80000; + +{************************************************************************} + +{ Types of requesters known to ASL, used as arguments to AllocAslRequest() } + ASL_FileRequest = 0; + ASL_FontRequest = 1; + ASL_ScreenModeRequest = 2; + + +{**************************************************************************** + * + * ASL File Requester data structures and constants + * + * This structure must only be allocated by asl.library amd is READ-ONLY! + * Control of the various fields is provided via tags when the requester + * is created with AllocAslRequest() and when it is displayed via + * AslRequest() + } + +type + PFileRequester = ^TFileRequester; + TFileRequester = record + rf_Reserved0 : array[0..3] of Byte; + rf_File : STRPTR; { Filename pointer } + rf_Dir : STRPTR; { Directory name pointer } + rf_Reserved1 : array[0..9] of Byte; + rf_LeftEdge : SmallInt; + rf_TopEdge : SmallInt; { Preferred window pos } + rf_Width : SmallInt; + rf_Height : SmallInt; { Preferred window size } + rf_Reserved2 : array[0..1] of Byte; + rf_NumArgs : LongInt; { A-la WB Args, FOR multiselects } + rf_ArgList : PWBArgList; + rf_UserData : Pointer; { Applihandle (you may write!!) } + rf_Reserved3 : array[0..7] of Byte; + rf_Pat : STRPTR; { Pattern match pointer } + END; { note - more reserved fields follow } + + +{ File requester tag values, used by AllocAslRequest() and AslRequest() } + +const +{ Window control } + ASLFR_Window = ASL_TB+2 ; { Parent window } + ASLFR_Screen = ASL_TB+40; { Screen to open on if no window } + ASLFR_PubScreenName = ASL_TB+41; { Name of public screen } + ASLFR_PrivateIDCMP = ASL_TB+42; { Allocate private IDCMP? } + ASLFR_IntuiMsgFunc = ASL_TB+70; { function to handle IntuiMessages } + ASLFR_SleepWindow = ASL_TB+43; { Block input in ASLFR_Window? } + ASLFR_UserData = ASL_TB+52; { What to put in fr_UserData } + ASLFR_PopToFront = ASL_TB+131; { Make the requester window visible } + ASLFR_Activate = ASL_TB+132; { Activate the requester window when } + +{ Text display } + ASLFR_TextAttr = ASL_TB+51; { Text font to use for gadget text } + ASLFR_Locale = ASL_TB+50; { Locale ASL should use for text } + ASLFR_TitleText = ASL_TB+1 ; { Title of requester } + ASLFR_PositiveText = ASL_TB+18; { Positive gadget text } + ASLFR_NegativeText = ASL_TB+19; { Negative gadget text } + +{ Initial settings } + ASLFR_InitialLeftEdge= ASL_TB+3 ; { Initial requester coordinates } + ASLFR_InitialTopEdge = ASL_TB+4 ; + ASLFR_InitialWidth = ASL_TB+5 ; { Initial requester dimensions } + ASLFR_InitialHeight = ASL_TB+6 ; + ASLFR_InitialFile = ASL_TB+8 ; { Initial contents of File gadget } + ASLFR_InitialDrawer = ASL_TB+9 ; { Initial contents of Drawer gadg. } + ASLFR_InitialPattern = ASL_TB+10; { Initial contents of Pattern gadg.} + ASLFR_InitialShowVolumes = ASL_TB+130; { Initially, show the volume list (V44) } + +{ Options } + ASLFR_Flags1 = ASL_TB+20; { Option flags } + ASLFR_Flags2 = ASL_TB+22; { Additional option flags } + ASLFR_DoSaveMode = ASL_TB+44; { Being used for saving? } + ASLFR_DoMultiSelect = ASL_TB+45; { Do multi-select? } + ASLFR_DoPatterns = ASL_TB+46; { Display a Pattern gadget? } + +{ Filtering } + ASLFR_DrawersOnly = ASL_TB+47; { Don't display files? } + ASLFR_FilterFunc = ASL_TB+49; { function to filter files } + ASLFR_RejectIcons = ASL_TB+60; { Display .info files? } + ASLFR_RejectPattern = ASL_TB+61; { Don't display files matching pat } + ASLFR_AcceptPattern = ASL_TB+62; { Accept only files matching pat } + ASLFR_FilterDrawers = ASL_TB+63; { Also filter drawers with patterns} + ASLFR_HookFunc = ASL_TB+7 ; { Combined callback function } + +{ Sorting } + ASLFR_SetSortBy = ASL_TB+124; { Sort criteria (name, date, size) } + ASLFR_GetSortBy = ASL_TB+125; + ASLFR_SetSortDrawers = ASL_TB+126; { Placement of drawers in the list } + ASLFR_GetSortDrawers = ASL_TB+127; + ASLFR_SetSortOrder = ASL_TB+128; { Order (ascending or descending) } + ASLFR_GetSortOrder = ASL_TB+129; + + +{ Flag bits for the ASLFR_Flags1 tag } + FRB_FILTERFUNC = 7; + FRB_INTUIFUNC = 6; + FRB_DOSAVEMODE = 5; + FRB_PRIVATEIDCMP = 4; + FRB_DOMULTISELECT = 3; + FRB_DOPATTERNS = 0; + + FRF_FILTERFUNC = 128; + FRF_INTUIFUNC = 64; + FRF_DOSAVEMODE = 32; + FRF_PRIVATEIDCMP = 16; + FRF_DOMULTISELECT = 8; + FRF_DOPATTERNS = 1; + +{ Flag bits for the ASLFR_Flags2 tag } + FRB_DRAWERSONLY = 0; + FRB_FILTERDRAWERS = 1; + FRB_REJECTICONS = 2; + + FRF_DRAWERSONLY = 1; + FRF_FILTERDRAWERS = 2; + FRF_REJECTICONS = 4; + +{ Sort criteria for the ASLFR_SetSortBy/ASLFR_GetSortBy tags } + ASLFRSORTBY_Name = 0; + ASLFRSORTBY_Date = 1; + ASLFRSORTBY_Size = 2; + +{ Drawer placement for the ASLFR_SetSortDrawers/ASLFR_GetSortDrawers tags } + ASLFRSORTDRAWERS_First = 0; + ASLFRSORTDRAWERS_Mix = 1; + ASLFRSORTDRAWERS_Last = 2; + +{ Sort order for the ASLFR_SetSortOrder/ASLFR_GetSortOrder tags } + ASLFRSORTORDER_Ascend = 0; + ASLFRSORTORDER_Descend = 1; + +{**************************************************************************** + * + * ASL Font Requester data structures and constants + * + * This structure must only be allocated by asl.library amd is READ-ONLY! + * Control of the various fields is provided via tags when the requester + * is created with AllocAslRequest() and when it is displayed via + * AslRequest() + } + +Type + PFontRequester = ^TFontRequester; + TFontRequester = record + fo_Reserved0 : array[0..7] of Byte; + fo_Attr : TTextAttr; { Returned TextAttr } + fo_FrontPen : Byte; { Returned front pen } + fo_BackPen : Byte; { Returned back pen } + fo_DrawMode : Byte; { Returned drawing mode } + fo_Reserved1 : Byte; + fo_UserData : Pointer; { You can store your own data here } + fo_LeftEdge : smallint; { Coordinates Of requester on Exit } + fo_TopEdge : smallint; + fo_Width : smallint; + fo_Height : smallint; + fo_TAttr : tTTextAttr; { Returned TTextAttr } + end; + + +{ Font requester tag values, used by AllocAslRequest() AND AslRequest() } + +const +{ Window control } + ASLFO_Window = ASL_TB+2 ; { Parent window } + ASLFO_Screen = ASL_TB+40; { Screen to open on if no window } + ASLFO_PubScreenName = ASL_TB+41; { Name of public screen } + ASLFO_PrivateIDCMP = ASL_TB+42; { Allocate private IDCMP? } + ASLFO_IntuiMsgFunc = ASL_TB+70; { function to handle IntuiMessages } + ASLFO_SleepWindow = ASL_TB+43; { Block input in ASLFO_Window? } + ASLFO_UserData = ASL_TB+52; { What to put in fo_UserData } + ASLFO_PopToFront = ASL_TB+131; { Make the requester window visible + * when it opens (V44) + } + ASLFO_Activate = ASL_TB+132; { Activate the requester window when + * it opens (V45). + } +{ Text display } + ASLFO_TextAttr = ASL_TB+51; { Text font to use for gadget text } + ASLFO_Locale = ASL_TB+50; { Locale ASL should use for text } + ASLFO_TitleText = ASL_TB+1 ; { Title of requester } + ASLFO_PositiveText = ASL_TB+18; { Positive gadget text } + ASLFO_NegativeText = ASL_TB+19; { Negative gadget text } + +{ Initial settings } + ASLFO_InitialLeftEdge= ASL_TB+3 ; { Initial requester coordinates } + ASLFO_InitialTopEdge = ASL_TB+4 ; + ASLFO_InitialWidth = ASL_TB+5 ; { Initial requester dimensions } + ASLFO_InitialHeight = ASL_TB+6 ; + ASLFO_InitialName = ASL_TB+10; { Initial contents of Name gadget } + ASLFO_InitialSize = ASL_TB+11; { Initial contents of Size gadget } + ASLFO_InitialStyle = ASL_TB+12; { Initial font style } + ASLFO_InitialFlags = ASL_TB+13; { Initial font flags for TextAttr } + ASLFO_InitialFrontPen= ASL_TB+14; { Initial front pen } + ASLFO_InitialBackPen = ASL_TB+15; { Initial back pen } + ASLFO_InitialDrawMode= ASL_TB+59; { Initial draw mode } + +{ Options } + ASLFO_Flags = ASL_TB+20; { Option flags } + ASLFO_DoFrontPen = ASL_TB+44; { Display Front color selector? } + ASLFO_DoBackPen = ASL_TB+45; { Display Back color selector? } + ASLFO_DoStyle = ASL_TB+46; { Display Style checkboxes? } + ASLFO_DoDrawMode = ASL_TB+47; { Display DrawMode cycle gadget? } + ASLFO_SampleText = ASL_TB+133; { Text to display in font sample area (V45) } + +{ Filtering } + ASLFO_FixedWidthOnly = ASL_TB+48; { Only allow fixed-width fonts? } + ASLFO_MinHeight = ASL_TB+16; { Minimum font height to display } + ASLFO_MaxHeight = ASL_TB+17; { Maximum font height to display } + ASLFO_FilterFunc = ASL_TB+49; { function to filter fonts } + ASLFO_HookFunc = ASL_TB+7 ; { Combined callback function } + ASLFO_MaxFrontPen = ASL_TB+66; { Max # of colors in front palette } + ASLFO_MaxBackPen = ASL_TB+67; { Max # of colors in back palette } + +{ Custom additions } + ASLFO_ModeList = ASL_TB+21; { Substitute list for drawmodes } + ASLFO_FrontPens = ASL_TB+64; { Color table for front pen palette} + ASLFO_BackPens = ASL_TB+65; { Color table for back pen palette } + +{ Flag bits for ASLFO_Flags tag } + FOB_DOFRONTPEN = 0; + FOB_DOBACKPEN = 1; + FOB_DOSTYLE = 2; + FOB_DODRAWMODE = 3; + FOB_FIXEDWIDTHONLY= 4; + FOB_PRIVATEIDCMP = 5; + FOB_INTUIFUNC = 6; + FOB_FILTERFUNC = 7; + + FOF_DOFRONTPEN = 1; + FOF_DOBACKPEN = 2; + FOF_DOSTYLE = 4; + FOF_DODRAWMODE = 8; + FOF_FIXEDWIDTHONLY = 16; + FOF_PRIVATEIDCMP = 32; + FOF_INTUIFUNC = 64; + FOF_FILTERFUNC = 128; + +{**************************************************************************** + * + * ASL Screen Mode Requester data structures and constants + * + * This structure must only be allocated by asl.library and is READ-ONLY! + * Control of the various fields is provided via tags when the requester + * is created with AllocAslRequest() and when it is displayed via + * AslRequest() + } + +type + PScreenModeRequester = ^TScreenModeRequester; + TScreenModeRequester = record + sm_DisplayID : LongWord; { Display mode ID } + sm_DisplayWidth : LongWord; { Width Of display IN pixels } + sm_DisplayHeight : LongWord; { Height Of display IN pixels } + sm_DisplayDepth : Word; { Number OF bit-planes OF display } + sm_OverscanType : Word; { TYPE OF overscan OF display } + sm_AutoScroll : Boolean; { Display should auto-scroll? } + + sm_BitMapWidth : LongWord; { Used TO create your own BitMap } + sm_BitMapHeight : LongWord; + + sm_LeftEdge : smallint; { Coordinates OF requester on Exit } + sm_TopEdge : smallint; + sm_Width : smallint; + sm_Height : smallint; + + sm_InfoOpened : Boolean; { Info window opened on exit? } + sm_InfoLeftEdge : smallint; { Last coordinates OF Info window } + sm_InfoTopEdge : smallint; + sm_InfoWidth : smallint; + sm_InfoHeight : smallint; + + sm_UserData : Pointer; { You can store your own data here } + end; + + +{ An Exec list of custom modes can be added to the list of available modes. + * The DimensionInfo structure must be completely initialized, including the + * Header. See . Custom mode ID's must be in the range + * $FFFF0000..$FFFFFFFF. Regular properties which apply to your custom modes + * can be added in the dn_PropertyFlags field. Custom properties are not + * allowed. + } + PDisplayMode = ^TDisplayMode; + TDisplayMode = record + dm_Node : TNode; { see ln_Name } + dm_DimensionInfo : tDimensionInfo; { mode description } + dm_PropertyFlags : LongWord; { applicable properties } + end; + + +{ ScreenMode requester tag values, used by AllocAslRequest() and AslRequest() } +const +{ Window control } + ASLSM_Window = ASL_TB+2 ; { Parent window } + ASLSM_Screen = ASL_TB+40; { Screen to open on if no window } + ASLSM_PubScreenName = ASL_TB+41; { Name of public screen } + ASLSM_PrivateIDCMP = ASL_TB+42; { Allocate private IDCMP? } + ASLSM_IntuiMsgFunc = ASL_TB+70; { function to handle IntuiMessages } + ASLSM_SleepWindow = ASL_TB+43; { Block input in ASLSM_Window? } + ASLSM_UserData = ASL_TB+52; { What to put in sm_UserData } + ASLSM_PopToFront = ASL_TB+131; { Make the requester window visible + * when it opens (V44) + } + ASLSM_Activate = ASL_TB+132; { Activate the requester window when + * it opens (V45). + } + +{ Text display } + ASLSM_TextAttr = ASL_TB+51; { Text font to use for gadget text } + ASLSM_Locale = ASL_TB+50; { Locale ASL should use for text } + ASLSM_TitleText = ASL_TB+1 ; { Title of requester } + ASLSM_PositiveText = ASL_TB+18; { Positive gadget text } + ASLSM_NegativeText = ASL_TB+19; { Negative gadget text } + +{ Initial settings } + ASLSM_InitialLeftEdge = ASL_TB+3 ; { Initial requester coordinates } + ASLSM_InitialTopEdge = ASL_TB+4 ; + ASLSM_InitialWidth = ASL_TB+5 ; { Initial requester dimensions } + ASLSM_InitialHeight = ASL_TB+6 ; + ASLSM_InitialDisplayID = ASL_TB+100; { Initial display mode id } + ASLSM_InitialDisplayWidth = ASL_TB+101; { Initial display width } + ASLSM_InitialDisplayHeight = ASL_TB+102; { Initial display height } + ASLSM_InitialDisplayDepth = ASL_TB+103; { Initial display depth } + ASLSM_InitialOverscanType = ASL_TB+104; { Initial type of overscan } + ASLSM_InitialAutoScroll = ASL_TB+105; { Initial autoscroll setting } + ASLSM_InitialInfoOpened = ASL_TB+106; { Info wndw initially opened? } + ASLSM_InitialInfoLeftEdge = ASL_TB+107; { Initial Info window coords. } + ASLSM_InitialInfoTopEdge = ASL_TB+108; + +{ Options } + ASLSM_DoWidth = ASL_TB+109; { Display Width gadget? } + ASLSM_DoHeight = ASL_TB+110; { Display Height gadget? } + ASLSM_DoDepth = ASL_TB+111; { Display Depth gadget? } + ASLSM_DoOverscanType = ASL_TB+112; { Display Overscan Type gadget? } + ASLSM_DoAutoScroll = ASL_TB+113; { Display AutoScroll gadget? } + +{ Filtering } + ASLSM_PropertyFlags = ASL_TB+114; { Must have these Property flags } + ASLSM_PropertyMask = ASL_TB+115; { Only these should be looked at } + ASLSM_MinWidth = ASL_TB+116; { Minimum display width to allow } + ASLSM_MaxWidth = ASL_TB+117; { Maximum display width to allow } + ASLSM_MinHeight = ASL_TB+118; { Minimum display height to allow } + ASLSM_MaxHeight = ASL_TB+119; { Maximum display height to allow } + ASLSM_MinDepth = ASL_TB+120; { Minimum display depth } + ASLSM_MaxDepth = ASL_TB+121; { Maximum display depth } + ASLSM_FilterFunc = ASL_TB+122; { function to filter mode id's } + +{ Custom additions } + ASLSM_CustomSMList = ASL_TB+123; { Exec list of struct DisplayMode } + +{***************************************************************************} + + ASL_LAST_TAG = ASL_TB+133; + +{***************************************************************************} + +{ This defines the rendezvous data for setting and querying asl.library's + * defaults for the window size and the file requester sort order. The name + * of the semaphore is given below; it exists only with asl.library V45 and + * IPrefs V45 and beyond. + } + ASL_SEMAPHORE_NAME : Pchar = 'asl.library'; + +type + PAslSemaphore = ^TAslSemaphore; + TAslSemaphore = record + as_Semaphore : TSignalSemaphore; + as_Version : Word; { Must be >= 45 } + as_Size : LongWord; { Size of this data structure. } + as_SortBy : Byte; { File requester defaults; name, date or size } + as_SortDrawers : Byte; { File requester defaults; first, mix or last } + as_SortOrder : Byte; { File requester defaults; ascending or descending } + as_SizePosition : Byte; { See below } + as_RelativeLeft : Smallint;{ Window position offset } + as_RelativeTop : Smallint; + as_RelativeWidth : Byte; { Window size factor; this is + * a percentage of the parent + * window/screen width. + } + as_RelativeHeight : Byte; + end; + +const +{ Default position of the ASL window. } + ASLPOS_DefaultPosition = 0; { Position is calculated according to the builtin rules. } + ASLPOS_CenterWindow = 1; { Centred within the bounds of the parent window. } + ASLPOS_CenterScreen = 2; { Centred within the bounds of the parent screen. } + ASLPOS_WindowPosition = 3; { Relative to the top left corner of the parent window, + * using the offset values provided in the + * as_RelativeLeft/as_RelativeTop members. + } + ASLPOS_ScreenPosition = 4; { Relative to the top left corner of the parent screen, + * using the offset values provided in the + * as_RelativeLeft/as_RelativeTop members. + } + ASLPOS_CenterMouse = 5; { Directly below the mouse pointer. } + ASLPOS_MASK = $0F; + +{ Default size of the ASL window. } + ASLSIZE_DefaultSize = (0 shl 4); { Size is calculated according to the builtin rules. } + ASLSIZE_RelativeSize = (1 shl 4); { Size is relative to the size of the parent + * window or screen, using the values provided in + * the as_RelativeWidth/as_RelativeHeight members. + * The as_RelativeWidth/as_RelativeHeight values are + * taken as percentage, i.e. a value of "50" stands for + * 50% of the width/height of the parent window/screen. + } + ASLSIZE_MASK = $30; + +{ Other options. } + ASLOPTION_ASLOverrides = (1 shl 6); { ASL determines placement and size of requester + * windows; application's choice is ignored. + } + + +{**************************************************************************** + * + * Obsolete ASL definitions, here for source code compatibility only. + * Please do NOT use in new code. + * + * define ASL_V38_NAMES_ONLY to remove these older names + } +{$define ASL_V38_NAMES_ONLY} +{$ifndef ASL_V38_NAMES_ONLY} +Const + ASL_Dummy = (TAG_USER + $80000); + ASL_Hail = ASL_Dummy+1 ; + ASL_Window = ASL_Dummy+2 ; + ASL_LeftEdge = ASL_Dummy+3 ; + ASL_TopEdge = ASL_Dummy+4 ; + ASL_Width = ASL_Dummy+5 ; + ASL_Height = ASL_Dummy+6 ; + ASL_HookFunc = ASL_Dummy+7 ; + ASL_File = ASL_Dummy+8 ; + ASL_Dir = ASL_Dummy+9 ; + ASL_FontName = ASL_Dummy+10; + ASL_FontHeight = ASL_Dummy+11; + ASL_FontStyles = ASL_Dummy+12; + ASL_FontFlags = ASL_Dummy+13; + ASL_FrontPen = ASL_Dummy+14; + ASL_BackPen = ASL_Dummy+15; + ASL_MinHeight = ASL_Dummy+16; + ASL_MaxHeight = ASL_Dummy+17; + ASL_OKText = ASL_Dummy+18; + ASL_CancelText = ASL_Dummy+19; + ASL_FuncFlags = ASL_Dummy+20; + ASL_ModeList = ASL_Dummy+21; + ASL_ExtFlags1 = ASL_Dummy+22; + ASL_Pattern = ASL_FontName; +{ remember what I said up there? Do not use these anymore! } + FILB_DOWILDFUNC = 7; + FILB_DOMSGFUNC = 6; + FILB_SAVE = 5; + FILB_NEWIDCMP = 4; + FILB_MULTISELECT = 3; + FILB_PATGAD = 0; + FILF_DOWILDFUNC = 128; + FILF_DOMSGFUNC = 64; + FILF_SAVE = 32; + FILF_NEWIDCMP = 16; + FILF_MULTISELECT = 8; + FILF_PATGAD = 1; + FIL1B_NOFILES = 0; + FIL1B_MATCHDIRS = 1; + FIL1F_NOFILES = 1; + FIL1F_MATCHDIRS = 2; + FONB_FRONTCOLOR = 0; + FONB_BACKCOLOR = 1; + FONB_STYLES = 2; + FONB_DRAWMODE = 3; + FONB_FIXEDWIDTH = 4; + FONB_NEWIDCMP = 5; + FONB_DOMSGFUNC = 6; + FONB_DOWILDFUNC = 7; + FONF_FRONTCOLOR = 1; + FONF_BACKCOLOR = 2; + FONF_STYLES = 4; + FONF_DRAWMODE = 8; + FONF_FIXEDWIDTH = 16; + FONF_NEWIDCMP = 32; + FONF_DOMSGFUNC = 64; + FONF_DOWILDFUNC = 128; +{$endif ASL_V38_NAMES_ONLY} + +var + AslBase: PLibrary; + + +function AllocAslRequestA(ReqType: LongWord; TagList: PTagItem): Pointer; syscall AslBase 8; +function AllocFileRequest: PFileRequester; syscall AslBase 5; +function AslRequestA(Requester: Pointer; TagList: PTagItem): LongBool; syscall AslBase 10; +procedure FreeAslRequest(Requester: Pointer); syscall AslBase 9; +procedure FreeFileRequest(FileReq: PFileRequester); syscall AslBase 6; +function RequestFile(FileReq: PFileRequester): LongBool; syscall AslBase 7; + +procedure AbortAslRequest(Requester: Pointer); syscall AslBase 13; +procedure ActivateAslRequest(Requester: Pointer); syscall AslBase 14; + + +function AllocAslRequest(ReqType: LongWord; const Tags: array of const): Pointer; +function AslRequest(Requester: Pointer; const Tags: array of const): LongBool; + + +implementation + + +function AllocAslRequest(ReqType: LongWord; const Tags: array of const): Pointer; +begin + AllocAslRequest := AllocAslRequestA(reqType , readintags(tags)); +end; + +function AslRequest(Requester: Pointer; const Tags: array of const): LongBool; +begin + AslRequest := AslRequestA(Requester , readintags(tags)); +end; + +initialization + AslBase := OpenLibrary(ASLNAME, 36); +finalization + CloseLibrary(AslBase); + +end. + + diff --git a/packages/arosunits/src/gadtools.pas b/packages/arosunits/src/gadtools.pas new file mode 100644 index 0000000000..2ca926b9fd --- /dev/null +++ b/packages/arosunits/src/gadtools.pas @@ -0,0 +1,482 @@ +{ + This file is part of the Free Pascal run time library. + Copyright (c) 2014 by Free Pascal development team + + gadtools.library functions + + See the file COPYING.FPC, included in this distribution, + for details about the copyright. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + + **********************************************************************} + +unit gadtools; + +interface + +uses + exec, intuition, agraphics, utility; + +{------------------------------------------------------------------------} + +{ The kinds (almost classes) of gadgets in the toolkit. Use these + identifiers when calling CreateGadgetA() } + +CONST + GENERIC_KIND = 0; + BUTTON_KIND = 1; + CHECKBOX_KIND = 2; + INTEGER_KIND = 3; + LISTVIEW_KIND = 4; + MX_KIND = 5; + NUMBER_KIND = 6; + CYCLE_KIND = 7; + PALETTE_KIND = 8; + SCROLLER_KIND = 9; +{ Kind number 10 is reserved } + SLIDER_KIND = 11; + STRING_KIND = 12; + TEXT_KIND = 13; + + NUM_KINDS = 14; + + GADTOOLSNAME : PChar = 'gadtools.library'; + + +{------------------------------------------------------------------------} + +{ 'Or' the appropriate set together for your Window IDCMPFlags: } + + ARROWIDCMP = (IDCMP_GADGETUP + IDCMP_GADGETDOWN + + IDCMP_INTUITICKS + IDCMP_MOUSEBUTTONS); + + BUTTONIDCMP = (IDCMP_GADGETUP); + CHECKBOXIDCMP = (IDCMP_GADGETUP); + INTEGERIDCMP = (IDCMP_GADGETUP); + LISTVIEWIDCMP = (IDCMP_GADGETUP + IDCMP_GADGETDOWN + + IDCMP_MOUSEMOVE + ARROWIDCMP); + + MXIDCMP = (IDCMP_GADGETDOWN); + NUMBERIDCMP = 0; + CYCLEIDCMP = (IDCMP_GADGETUP); + PALETTEIDCMP = (IDCMP_GADGETUP); + +{ Use ARROWIDCMP+SCROLLERIDCMP if your scrollers have arrows: } + SCROLLERIDCMP = (IDCMP_GADGETUP + IDCMP_GADGETDOWN + IDCMP_MOUSEMOVE); + SLIDERIDCMP = (IDCMP_GADGETUP + IDCMP_GADGETDOWN + IDCMP_MOUSEMOVE); + STRINGIDCMP = (IDCMP_GADGETUP); + + TEXTIDCMP = 0; + + +{------------------------------------------------------------------------} + +{ Generic NewGadget used by several of the gadget classes: } + +Type + PNewGadget = ^tNewGadget; + tNewGadget = record + ng_LeftEdge, ng_TopEdge : SmallInt; { gadget position } + ng_Width, ng_Height : SmallInt; { gadget size } + ng_GadgetText : STRPTR; { gadget label } + ng_TextAttr : PTextAttr; { desired font for gadget label } + ng_GadgetID : Word; { gadget ID } + ng_Flags : LongWord; { see below } + ng_VisualInfo : Pointer; { Set to retval of GetVisualInfo() } + ng_UserData : Pointer; { gadget UserData } + END; + + +{ ng_Flags control certain aspects of the gadget. The first five control + the placement of the descriptive text. All larger groups supply a + default: } + +CONST + PLACETEXT_LEFT = $0001; { Right-align text on left side } + PLACETEXT_RIGHT = $0002; { Left-align text on right side } + PLACETEXT_ABOVE = $0004; { Center text above } + PLACETEXT_BELOW = $0008; { Center text below } + PLACETEXT_IN = $0010; { Center text on } + + NG_HIGHLABEL = $0020; { Highlight the label } + +{------------------------------------------------------------------------} + +{ Fill out an array of these and pass that to CreateMenus(): } + +Type + pNewMenu = ^tNewMenu; + tNewMenu = record + nm_Type : Byte; { See below } + nm_Label : STRPTR; { Menu's label } + nm_CommKey : STRPTR; { MenuItem Command Key Equiv } + nm_Flags : Word; { Menu OR MenuItem flags (see note) } + nm_MutualExclude : Longint; { MenuItem MutualExclude word } + nm_UserData : Pointer; { For your own use, see note } + END; + +const +{ Needed only by inside IM_ definitions below } + MENU_IMAGE = 128; + +{ nm_Type determines what each NewMenu structure corresponds to. + * for the NM_TITLE, NM_ITEM, and NM_SUB values, nm_Label should + * be a text string to use for that menu title, item, or sub-item. + * For IM_ITEM or IM_SUB, set nm_Label to point at the Image structure + * you wish to use for this item or sub-item. + * NOTE: At present, you may only use conventional images. + * Custom images created from Intuition image-classes do not work. + } + NM_TITLE = 1; { Menu header } + NM_ITEM = 2; { Textual menu item } + NM_SUB = 3; { Textual menu sub-item } + + IM_ITEM = (NM_ITEM OR MENU_IMAGE); { Graphical menu item } + IM_SUB = (NM_SUB OR MENU_IMAGE); { Graphical menu sub-item } + +{ The NewMenu array should be terminated with a NewMenu whose + * nm_Type equals NM_END. + } + NM_END = 0; { End of NewMenu array } + +{ Starting with V39, GadTools will skip any NewMenu entries whose + * nm_Type field has the NM_IGNORE bit set. + } + NM_IGNORE = 64; + + +{ nm_Label should be a text string for textual items, a pointer + * to an Image structure for graphical menu items, or the special + * constant NM_BARLABEL, to get a separator bar. + } + NM_BARLABEL = -1; + +{ The nm_Flags field is used to fill out either the Menu->Flags or + * MenuItem->Flags field. Note that the sense of the MENUENABLED or + * ITEMENABLED bit is inverted between this use and Intuition's use, + * in other words, NewMenus are enabled by default. The following + * labels are provided to disable them: + } + NM_MENUDISABLED = MENUENABLED; + NM_ITEMDISABLED = ITEMENABLED; + +{ New for V39: NM_COMMANDSTRING. For a textual MenuItem or SubItem, + * point nm_CommKey at an arbitrary string, and set the NM_COMMANDSTRING + * flag. + } + NM_COMMANDSTRING = COMMSEQ; + +{ The following are pre-cleared (COMMSEQ, ITEMTEXT, and HIGHxxx are set + * later as appropriate): + * Under V39, the COMMSEQ flag bit is not cleared, since it now has + * meaning. + } + NM_FLAGMASK = not (COMMSEQ or ITEMTEXT or HIGHFLAGS); + NM_FLAGMASK_V39 = not (ITEMTEXT or HIGHFLAGS); + +{ You may choose among CHECKIT, MENUTOGGLE, and CHECKED. + * Toggle-select menuitems are of type CHECKIT|MENUTOGGLE, along + * with CHECKED if currently selected. Mutually exclusive ones + * are of type CHECKIT, and possibly CHECKED too. The nm_MutualExclude + * is a bit-wise representation of the items excluded by this one, + * so in the simplest case (choose 1 among n), these flags would be + * ~1, ~2, ~4, ~8, ~16, etc. See the Intuition Menus chapter. + } + +{ A UserData pointer can be associated with each Menu and MenuItem structure. + * The CreateMenus() call allocates space for a UserData after each + * Menu or MenuItem (header, item or sub-item). You should use the + * GTMENU_USERDATA() or GTMENUITEM_USERDATA() macro to extract it. + } + +const +{ These return codes can be obtained through the GTMN_SecondaryError tag } + GTMENU_TRIMMED = $00000001; { Too many menus, items, or subitems, + * menu has been trimmed down + } + GTMENU_INVALID = $00000002; { Invalid NewMenu array } + GTMENU_NOMEM = $00000003; { Out of memory } + +{------------------------------------------------------------------------} + +{ Starting with V39, checkboxes and mx gadgets can be scaled to your + * specified gadget width/height. Use the new GTCB_Scaled or GTMX_Scaled + * tags, respectively. Under V37, and by default in V39, the imagery + * is of the following fixed size: + } + +{ MX gadget default dimensions: } + MX_WIDTH = 17; + MX_HEIGHT = 9; + +{ Checkbox default dimensions: } + CHECKBOX_WIDTH = 26; + CHECKBOX_HEIGHT = 11; + +{------------------------------------------------------------------------} + + +{------------------------------------------------------------------------} + +{ Tags for GadTools functions: } +CONST + GT_TagBase = TAG_USER + $80000; + + GTVI_NewWindow = GT_TagBase+1; { Unused } + GTVI_NWTags = GT_TagBase+2; { Unused } + + GT_Private0 = GT_TagBase+3; { (private) } + + GTCB_Checked = GT_TagBase+4; { State of checkbox } + + GTLV_Top = GT_TagBase+5; { Top visible one in listview } + GTLV_Labels = GT_TagBase+6; { List to display in listview } + GTLV_ReadOnly = GT_TagBase+7; { TRUE IF listview is to be + read-only } + GTLV_ScrollWidth = GT_TagBase+8; { Width of scrollbar } + + GTMX_Labels = GT_TagBase+9; { NULL-terminated array of labels } + GTMX_Active = GT_TagBase+10; { Active one in mx gadget } + + GTTX_Text = GT_TagBase+11; { Text to display } + GTTX_CopyText = GT_TagBase+12; { Copy text label instead of + referencing it } + + GTNM_Number = GT_TagBase+13; { Number to display } + + GTCY_Labels = GT_TagBase+14; { NULL-terminated array of labels } + GTCY_Active = GT_TagBase+15; { The active one in the cycle gad } + + GTPA_Depth = GT_TagBase+16; { Number of bitplanes in palette } + GTPA_Color = GT_TagBase+17; { Palette color } + GTPA_ColorOffset = GT_TagBase+18; { First color to use in palette } + GTPA_IndicatorWidth = GT_TagBase+19; { Width of current-color indicator } + GTPA_IndicatorHeight = GT_TagBase+20; { Height of current-color indicator } + + GTSC_Top = GT_TagBase+21; { Top visible in scroller } + GTSC_Total = GT_TagBase+22; { Total in scroller area } + GTSC_Visible = GT_TagBase+23; { Number visible in scroller } + GTSC_Overlap = GT_TagBase+24; { Unused } + +{ GT_TagBase+25 through GT_TagBase+37 are reserved } + + GTSL_Min = GT_TagBase+38; { Slider min value } + GTSL_Max = GT_TagBase+39; { Slider max value } + GTSL_Level = GT_TagBase+40; { Slider level } + GTSL_MaxLevelLen = GT_TagBase+41; { Max length of printed level } + GTSL_LevelFormat = GT_TagBase+42; { Format string for level } + GTSL_LevelPlace = GT_TagBase+43; { Where level should be placed } + GTSL_DispFunc = GT_TagBase+44; { Callback for number calculation + before display } + + GTST_String = GT_TagBase+45; { String gadget's displayed string } + GTST_MaxChars = GT_TagBase+46; { Max length of string } + + GTIN_Number = GT_TagBase+47; { Number in integer gadget } + GTIN_MaxChars = GT_TagBase+48; { Max number of digits } + + GTMN_TextAttr = GT_TagBase+49; { MenuItem font TextAttr } + GTMN_FrontPen = GT_TagBase+50; { MenuItem text pen color } + + GTBB_Recessed = GT_TagBase+51; { Make BevelBox recessed } + + GT_VisualInfo = GT_TagBase+52; { result of VisualInfo call } + + GTLV_ShowSelected = GT_TagBase+53; { show selected entry beneath + listview, set tag data = NULL for display-only, or pointer + to a string gadget you've created } + GTLV_Selected = GT_TagBase+54; { Set ordinal number of selected + entry in the list } + GT_Reserved0 = GT_TagBase+55; { Reserved } + GT_Reserved1 = GT_TagBase+56; { Reserved for future use } + + GTTX_Border = GT_TagBase+57; { Put a border around + Text-display gadgets } + GTNM_Border = GT_TagBase+58; { Put a border around + Number-display gadgets } + + GTSC_Arrows = GT_TagBase+59; { Specify size of arrows for + scroller } + + GTMN_Menu = GT_TagBase+60; { Pointer to Menu for use by + LayoutMenuItems() } + GTMX_Spacing = GT_TagBase+61; { Added to font height to + figure spacing between mx choices. Use this instead + of LAYOUTA_SPACING for mx gadgets. } + +{ New to V37 GadTools. Ignored by GadTools V36 } + GTMN_FullMenu = GT_TagBase+62; { Asks CreateMenus() to + validate that this is a complete menu structure } + GTMN_SecondaryError = GT_TagBase+63; { ti_Data is a pointer + to a LongWord to receive error reports from CreateMenus() } + GT_Underscore = GT_TagBase+64; { ti_Data points to the symbol + that preceeds the character you'd like to underline in a + gadget label } + +{ New to V39 GadTools. Ignored by GadTools V36 and V37 } + GTMN_Checkmark = GT_TagBase+65; { ti_Data is checkmark img to use } + GTMN_AmigaKey = GT_TagBase+66; { ti_Data is Amiga-key img to use } + GTMN_NewLookMenus = GT_TagBase+67; { ti_Data is boolean } + +{ New to V39 GadTools. Ignored by GadTools V36 and V37. + * Set to TRUE if you want the checkbox or mx image scaled to + * the gadget width/height you specify. Defaults to FALSE, + * for compatibility. + } + GTCB_Scaled = GT_TagBase+68; { ti_Data is boolean } + GTMX_Scaled = GT_TagBase+69; { ti_Data is boolean } + + GTPA_NumColors = GT_TagBase+70; { Number of colors in palette } + + GTMX_TitlePlace = GT_TagBase+71; { Where to put the title } + + GTTX_FrontPen = GT_TagBase+72; { Text color in TEXT_KIND gad } + GTTX_BackPen = GT_TagBase+73; { Bgrnd color in TEXT_KIND gad } + GTTX_Justification = GT_TagBase+74; { See GTJ_#? constants } + + GTNM_FrontPen = GT_TagBase+72; { Text color in NUMBER_KIND gad } + GTNM_BackPen = GT_TagBase+73; { Bgrnd color in NUMBER_KIND gad } + GTNM_Justification = GT_TagBase+74; { See GTJ_#? constants } + GTNM_Format = GT_TagBase+75; { Formatting string for number } + GTNM_MaxNumberLen = GT_TagBase+76; { Maximum length of number } + + GTBB_FrameType = GT_TagBase+77; { defines what kind of boxes + * DrawBevelBox() renders. See + * the BBFT_#? constants for + * possible values + } + + GTLV_MakeVisible = GT_TagBase+78; { Make this item visible } + GTLV_ItemHeight = GT_TagBase+79; { Height of an individual item } + + GTSL_MaxPixelLen = GT_TagBase+80; { Max pixel size of level display } + GTSL_Justification = GT_TagBase+81; { how should the level be displayed } + + GTPA_ColorTable = GT_TagBase+82; { colors to use in palette } + + GTLV_CallBack = GT_TagBase+83; { general-purpose listview call back } + GTLV_MaxPen = GT_TagBase+84; { maximum pen number used by call back } + + GTTX_Clipped = GT_TagBase+85; { make a TEXT_KIND clip text } + GTNM_Clipped = GT_TagBase+85; { make a NUMBER_KIND clip text } + + +{------------------------------------------------------------------------} + +{ Justification types for GTTX_Justification and GTNM_Justification tags } + GTJ_LEFT = 0; + GTJ_RIGHT = 1; + GTJ_CENTER = 2; + +{------------------------------------------------------------------------} + +{ Bevel box frame types for GTBB_FrameType tag } + BBFT_BUTTON = 1; { Standard button gadget box } + BBFT_RIDGE = 2; { Standard string gadget box } + BBFT_ICONDROPBOX = 3; { Standard icon drop box } + +{------------------------------------------------------------------------} + +{ Typical suggested spacing between "elements": } + INTERWIDTH = 8; + INTERHEIGHT = 4; + +{------------------------------------------------------------------------} + + +{ "NWay" is an old synonym for cycle gadgets } + NWAY_KIND = CYCLE_KIND; + NWAYIDCMP = CYCLEIDCMP; + GTNW_Labels = GTCY_Labels; + GTNW_Active = GTCY_Active; + +{------------------------------------------------------------------------} + +{ These two definitions are obsolete, but are here for backwards + * compatibility. You never need to worry about these: + } + GADTOOLBIT = ($8000); +{ Use this mask to isolate the user part: } + GADTOOLMASK = not (GADTOOLBIT); + +{------------------------------------------------------------------------} + +{ These definitions are for the GTLV_CallBack tag } + +{ The different types of messages that a listview callback hook can see } + LV_DRAW = $202; { draw yourself, with state } + +{ Possible return values from a callback hook } + LVCB_OK = 0; { callback understands this message type } + LVCB_UNKNOWN = 1; { callback does not understand this message } + +{ states for LVDrawMsg.lvdm_State } + LVR_NORMAL = 0; { the usual } + LVR_SELECTED = 1; { for selected gadgets } + LVR_NORMALDISABLED = 2; { for disabled gadgets } + LVR_SELECTEDDISABLED = 8; { disabled and selected } + +Type +{ structure of LV_DRAW messages, object is a (struct Node *) } + pLVDrawMsg = ^tLVDrawMsg; + tLVDrawMsg = record + lvdm_MethodID : LongWord; { LV_DRAW } + lvdm_RastPort : PRastPort; { where to render to } + lvdm_DrawInfo : PDrawInfo; { useful to have around } + lvdm_Bounds : TRectangle; { limits of where to render } + lvdm_State : LongWord; { how to render } + end; + + +var + GadToolsBase: PLibrary; + +function CreateContext(GListPtr: PGadget): PGadget; syscall GadToolsBase 19; +function CreateGadgetA(Kind: LongWord; Gad: PGadget; const ng: PNewGadget; const TagList: PTagItem): PGadget; syscall GadToolsBase 5; +function CreateMenusA(const NewMenu: PNewMenu; const TagList: PTagItem): PMenu; syscall GadToolsBase 8; +procedure DrawBevelBoxA(RPort: PRastPort; Left: LongInt; Top: LongInt; Width: LongInt; Height: LongInt; const TagList: PTagItem); syscall GadToolsBase 20; +procedure FreeGadgets(Gad: PGadget); syscall GadToolsBase 6; +procedure FreeMenus(Menu: PMenu); syscall GadToolsBase 9; +procedure FreeVisualInfo(vi: Pointer); syscall GadToolsBase 22; +function GetVisualInfoA(Screen: PScreen; const TagList: PTagItem): Pointer; syscall GadToolsBase 21; +procedure GT_BeginRefresh(Win: PWindow); syscall GadToolsBase 15; +procedure GT_EndRefresh(Win: PWindow; Complete: LongInt); syscall GadToolsBase 16; +function GT_FilterIMsg(const IMsg: PIntuiMessage): PIntuiMessage; syscall GadToolsBase 17; + +FUNCTION GT_GetIMsg(IPort: PMsgPort): PIntuiMessage; syscall GadToolsBase 12; +FUNCTION GT_PostFilterIMsg(IMsg: PIntuiMessage): PIntuiMessage; syscall GadToolsBase 18; +procedure GT_RefreshWindow(Win: PWindow; Req: PRequester); syscall GadToolsBase 14; +procedure GT_ReplyIMsg(IMsg: PIntuiMessage); syscall GadToolsBase 13; +function GT_GetGadgetAttrsA(Gad: PGadget; Win: PWindow; Req: PRequester; const TagList: PTagItem): LongInt; syscall GadToolsBase 29; +procedure GT_SetGadgetAttrsA(Gad: PGadget; Win: PWindow; Req: PRequester; const TagList: PTagItem); syscall GadToolsBase 7; +function LayoutMenuItemsA(FirstItem: PMenuItem; vi: Pointer; const TagList: PTagItem): LongBool; syscall GadToolsBase 10; +function LayoutMenusA(FirstMenu: PMenu; vi: Pointer; const TagList: PTagItem): LongBool; syscall GadToolsBase 11; + +function GTMENUITEM_USERDATA(MenuItem: PMenuItem): Pointer; +function GTMENU_USERDATA(Menu: PMenu): Pointer; + + +implementation + +function GTMENUITEM_USERDATA(menuitem : pMenuItem): pointer; +begin + GTMENUITEM_USERDATA := Pointer((PMenuItem(MenuItem) + 1)); +end; + +function GTMENU_USERDATA(Menu: PMenu): Pointer; +begin + GTMENU_USERDATA := Pointer((PMenu(Menu) + 1)); +end; + +initialization + GadToolsBase := OpenLibrary('gadtools.library', 36); +finalization + CloseLibrary(GadToolsBase); +end. + + + + diff --git a/packages/arosunits/src/mui.pas b/packages/arosunits/src/mui.pas new file mode 100644 index 0000000000..9515ec21ed --- /dev/null +++ b/packages/arosunits/src/mui.pas @@ -0,0 +1,3894 @@ +{ + This file is part of the Free Pascal run time library. + Copyright (c) 2014 by Free Pascal development team + + ZUNE/MUI functions + + See the file COPYING.FPC, included in this distribution, + for details about the copyright. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + + **********************************************************************} +{$mode objfpc} +{$packrecords C} +unit mui; + +interface + + { + + MUI - MagicUserInterface + (c) 1993-1997 Stefan Stuntz + + Main Header File + + + Class Tree + + + rootclass (BOOPSI's base class) + +--Notify (implements notification mechanism) + ! +--Family (handles multiple children) + ! ! +--Menustrip (describes a complete menu strip) + ! ! +--Menu (describes a single menu) + ! ! \--Menuitem (describes a single menu item) + ! +--Application (main class for all applications) + ! +--Window (main class for all windows) + ! ! \--Aboutmui (About window of MUI preferences) + ! +--Area (base class for all GUI elements) + ! +--Rectangle (spacing object) + ! +--Balance (balancing separator bar) + ! +--Image (image display) + ! +--Bitmap (draws bitmaps) + ! ! \--Bodychunk (makes bitmap from ILBM body chunk) + ! +--Text (text display) + ! +--Gadget (base class for intuition gadgets) + ! ! +--String (string gadget) + ! ! +--Boopsi (interface to BOOPSI gadgets) + ! ! \--Prop (proportional gadget) + ! +--Gauge (fule gauge) + ! +--Scale (percentage scale) + ! +--Colorfield (field with changeable color) + ! +--List (line-oriented list) + ! ! +--Floattext (special list with floating text) + ! ! +--Volumelist (special list with volumes) + ! ! +--Scrmodelist (special list with screen modes) + ! ! \--Dirlist (special list with files) + ! +--Numeric (base class for slider gadgets) + ! ! +--Knob (turning knob) + ! ! +--Levelmeter (level display) + ! ! +--Numericbutton (space saving popup slider) + ! ! \--Slider (traditional slider) + ! +--Framedisplay (private) + ! ! \--Popframe (private) + ! +--Imagedisplay (private) + ! ! \--Popimage (private) + ! +--Pendisplay (displays a pen specification) + ! ! \--Poppen (popup button to adjust a pen spec) + ! +--Group (groups other GUI elements) + ! +--Mccprefs (private) + ! +--Register (handles page groups with titles) + ! ! \--Penadjust (group to adjust a pen) + ! +--Settingsgroup (private) + ! +--Settings (private) + ! +--Frameadjust (private) + ! +--Imageadjust (private) + ! +--Virtgroup (handles virtual groups) + ! +--Scrollgroup (virtual groups with scrollbars) + ! +--Scrollbar (traditional scrollbar) + ! +--Listview (listview) + ! +--Radio (radio button) + ! +--Cycle (cycle gadget) + ! +--Coloradjust (several gadgets to adjust a color) + ! +--Palette (complete palette gadget) + ! +--Popstring (base class for popup objects) + ! +--Popobject (popup aynthing in a separate window) + ! ! +--Poplist (popup a simple listview) + ! ! \--Popscreen (popup a list of public screens) + ! \--Popasl (popup an asl requester) + +--Semaphore (semaphore equipped objects) + +--Applist (private) + +--Dataspace (handles general purpose data spaces) + \--Configdata (private) + + + General Header File Information + + + All macro and structure definitions follow these rules: + + Name Meaning + + MUIC_ Name of a class + MUIM__ Method + MUIP__ Methods parameter structure + MUIV___ Special method value + MUIA__ Attribute + MUIV___ Special attribute value + MUIE_ Error return code from MUI_Error() + MUII_ Standard MUI image + MUIX_ Control codes for text strings + MUIO_ Object type for MUI_MakeObject() + + MUIA_... attribute definitions are followed by a comment + consisting of the three possible letters I, S and G. + I: it's possible to specify this attribute at object creation time. + S: it's possible to change this attribute with SetAttrs(). + G: it's possible to get this attribute with GetAttr(). + + Items marked with "Custom Class" are for use in custom classes only! + } + +uses + exec, intuition,utility,agraphics{,iffparse}; + + + const + MUIMASTER_NAME: PChar = 'muimaster.library'; + MUIMASTER_VMIN = 11; + MUIMASTER_VLATEST = 19; + { + !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! + Warning, some of the macros in this header file work only with + muimaster.library V11 and above. If you recompile your programs, + be sure to open muimaster.library with MUIMASTER_VMIN as version number. + !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! + } + + { + Config items for MUIM_GetConfigItem + } + MUICFG_PublicScreen = 36; + { + Black box specification structures for images, pens, frames + } + + type + Plongword = ^LongWord; + + TMUI_PenSpec = record + Buf: array[0..31] of Char; + End; + PMUI_PenSpec = ^TMUI_PenSpec; + + { + Public Screen Stuff + } + { + NOTE: This stuff is only included to allow compilation of the supplied + public screen manager for educational purposes. Everything + here is subject to change without notice and I guarantee to + do that just for fun! + More info can be found in the screen manager source file. + } + + const + PSD_INITIAL_NAME : PChar = '(unnamed)'; + PSD_INITIAL_TITLE : PChar = 'MUI Public Screen'; + + + + const + PSD_NAME_FRONTMOST : PChar = '«Frontmost»'; + PSD_FILENAME_SAVE : PChar = 'envarc:mui/PublicScreens.iff'; + PSD_FILENAME_USE : PChar = 'env:mui/PublicScreens.iff'; + PSD_MAXLEN_NAME = 32; + PSD_MAXLEN_TITLE = 128; + PSD_MAXLEN_FONT = 48; + PSD_MAXLEN_BACKGROUND = 256; + PSD_NUMCOLS = 8; + PSD_MAXSYSPENS = 20; + PSD_NUMSYSPENS = 12; + PSD_MAXMUIPENS = 10; + PSD_NUMMUIPENS = 8; + + type + tMUI_RGBcolor = record + red : LongWord; + green : LongWord; + blue : LongWord; + end; + + pMUI_RGBColor = ^tMUI_RGBColor; + + tMUI_PubScreenDesc = record + Version : LONG; + Name : array[0..(PSD_MAXLEN_NAME)-1] of char; + Title : array[0..(PSD_MAXLEN_TITLE)-1] of char; + Font : array[0..(PSD_MAXLEN_FONT)-1] of char; + Background : array[0..(PSD_MAXLEN_BACKGROUND)-1] of char; + DisplayID : LongWord; + DisplayWidth : WORD; + DisplayHeight : WORD; + DisplayDepth : BYTE; + OverscanType : BYTE; + AutoScroll : BYTE; + NoDrag : BYTE; + Exclusive : BYTE; + Interleaved : BYTE; + SysDefault : BYTE; + Behind : BYTE; + AutoClose : BYTE; + CloseGadget : BYTE; + DummyWasForeign : BYTE; + SystemPens : array[0..(PSD_MAXSYSPENS)-1] of BYTE; + Reserved : array[0..((1 + (7 * 4)) - PSD_MAXSYSPENS)-1] of BYTE; + Palette : array[0..(PSD_NUMCOLS)-1] of tMUI_RGBcolor; + rsvd : array[0..(PSD_MAXSYSPENS - PSD_NUMCOLS)-1] of tMUI_RGBcolor; + rsvd2 : array[0..(PSD_MAXMUIPENS)-1] of tMUI_PenSpec; + Changed : LONG; + UserData : APTR; + end; + pMUI_PubScreenDesc = ^tMUI_PubScreenDesc; + + tMUIS_InfoClient = record + node : tMinNode; + task : PTask; + sigbit : LongWord; + end; + pMUIS_InfoClient = ^tMUIS_InfoClient; + + { + Object Types for MUI_MakeObject() + } + { STRPTR label, LongWord flags } + + const + + MUIO_Label = 1; + { STRPTR label } + MUIO_Button = 2; + { STRPTR label } + MUIO_Checkmark = 3; + { STRPTR label, STRPTR entries } + MUIO_Cycle = 4; + { STRPTR label, STRPTR entries } + MUIO_Radio = 5; + { STRPTR label, LONG min, LONG max } + MUIO_Slider = 6; + { STRPTR label, LONG maxlen } + MUIO_String = 7; + { STRPTR imagespec } + MUIO_PopButton = 8; + { LONG space } + MUIO_HSpace = 9; + { LONG space } + MUIO_VSpace = 10; + { LONG space } + MUIO_HBar = 11; + { LONG space } + MUIO_VBar = 12; + { struct NewMenu nm, LongWord flags } + MUIO_MenustripNM = 13; + { STRPTR label, STRPTR shortcut, LongWord flags, LongWord data } + MUIO_Menuitem = 14; + { STRPTR label } + MUIO_BarTitle = 15; + { STRPTR label, LONG min, LONG max, STRPTR format } + MUIO_NumericButton = 16; + MUIO_Menuitem_CopyStrings = 1 shl 30; + MUIO_Label_SingleFrame = 1 shl 8; + MUIO_Label_DoubleFrame = 1 shl 9; + MUIO_Label_LeftAligned = 1 shl 10; + MUIO_Label_Centered = 1 shl 11; + MUIO_Label_FreeVert = 1 shl 12; + { check for "localized" menu items such as "O\0Open" } + MUIO_MenustripNM_CommandKeyCheck = 1 shl 0; + { + ARexx Interface + } + + type + tMUI_Command = record + mc_Name : Pchar; + mc_Template : Pchar; + mc_Parameters : LONG; + mc_Hook : PHook; + mc_Reserved : array[0..4] of LONG; + end; + pMUI_Command = ^tMUI_Command; + + + + const + { MC_TEMPLATE_ID : PCHar = not(0); } + MC_TEMPLATE_ID = -1; + MUI_RXERR_BADDEFINITION = -(1); + MUI_RXERR_OUTOFMEMORY = -(2); + MUI_RXERR_UNKNOWNCOMMAND = -(3); + MUI_RXERR_BADSYNTAX = -(4); + { + Return values for MUI_Error() + } + MUIE_OK = 0; + MUIE_OutOfMemory = 1; + MUIE_OutOfGfxMemory = 2; + MUIE_InvalidWindowObject = 3; + MUIE_MissingLibrary = 4; + MUIE_NoARexx = 5; + MUIE_SingleTask = 6; + { + Standard MUI Images & Backgrounds + } + { These images are configured } + MUII_WindowBack = 0; + { with the preferences program. } + MUII_RequesterBack = 1; + MUII_ButtonBack = 2; + MUII_ListBack = 3; + MUII_TextBack = 4; + MUII_PropBack = 5; + MUII_PopupBack = 6; + MUII_SelectedBack = 7; + MUII_ListCursor = 8; + MUII_ListSelect = 9; + MUII_ListSelCur = 10; + MUII_ArrowUp = 11; + MUII_ArrowDown = 12; + MUII_ArrowLeft = 13; + MUII_ArrowRight = 14; + MUII_CheckMark = 15; + MUII_RadioButton = 16; + MUII_Cycle = 17; + MUII_PopUp = 18; + MUII_PopFile = 19; + MUII_PopDrawer = 20; + MUII_PropKnob = 21; + MUII_Drawer = 22; + MUII_HardDisk = 23; + MUII_Disk = 24; + MUII_Chip = 25; + MUII_Volume = 26; + MUII_RegisterBack = 27; + MUII_Network = 28; + MUII_Assign = 29; + MUII_TapePlay = 30; + MUII_TapePlayBack = 31; + MUII_TapePause = 32; + MUII_TapeStop = 33; + MUII_TapeRecord = 34; + MUII_GroupBack = 35; + MUII_SliderBack = 36; + MUII_SliderKnob = 37; + MUII_TapeUp = 38; + MUII_TapeDown = 39; + MUII_PageBack = 40; + MUII_ReadListBack = 41; + MUII_Count = 42; + { These are direct color } + MUII_BACKGROUND = 128; + { combinations and are not } + MUII_SHADOW = 129; + { affected by users prefs. } + MUII_SHINE = 130; + MUII_FILL = 131; + { Generally, you should } + MUII_SHADOWBACK = 132; + { avoid using them. Better } + MUII_SHADOWFILL = 133; + { use one of the customized } + MUII_SHADOWSHINE = 134; + { images above. } + MUII_FILLBACK = 135; + MUII_FILLSHINE = 136; + MUII_SHINEBACK = 137; + MUII_FILLBACK2 = 138; + MUII_HSHINEBACK = 139; + MUII_HSHADOWBACK = 140; + MUII_HSHINESHINE = 141; + MUII_HSHADOWSHADOW = 142; + MUII_MARKSHINE = 143; + MUII_MARKHALFSHINE = 144; + MUII_MARKBACKGROUND = 145; + MUII_LASTPAT = 145; + { + Special values for some methods + } + MUIV_TriggerValue = $49893131; + MUIV_NotTriggerValue = $49893133; + MUIV_EveryTime = $49893131; + MUIV_Notify_Self = 1; + MUIV_Notify_Window = 2; + MUIV_Notify_Application = 3; + MUIV_Notify_Parent = 4; + + + const + MUIV_Application_ReturnID_Quit = -(1); + MUIV_List_Insert_Top = 0; + MUIV_List_Insert_Active = -(1); + MUIV_List_Insert_Sorted = -(2); + MUIV_List_Insert_Bottom = -(3); + MUIV_List_Remove_First = 0; + MUIV_List_Remove_Active = -(1); + MUIV_List_Remove_Last = -(2); + MUIV_List_Remove_Selected = -(3); + MUIV_List_Select_Off = 0; + MUIV_List_Select_On = 1; + MUIV_List_Select_Toggle = 2; + MUIV_List_Select_Ask = 3; + MUIV_List_GetEntry_Active = -(1); + MUIV_List_Select_Active = -(1); + MUIV_List_Select_All = -(2); + MUIV_List_Redraw_Active = -(1); + MUIV_List_Redraw_All = -(2); + MUIV_List_Move_Top = 0; + MUIV_List_Move_Active = -(1); + MUIV_List_Move_Bottom = -(2); + { only valid for second parameter } + MUIV_List_Move_Next = -(3); + { only valid for second parameter } + MUIV_List_Move_Previous = -(4); + MUIV_List_Exchange_Top = 0; + MUIV_List_Exchange_Active = -(1); + MUIV_List_Exchange_Bottom = -(2); + { only valid for second parameter } + MUIV_List_Exchange_Next = -(3); + { only valid for second parameter } + MUIV_List_Exchange_Previous = -(4); + MUIV_List_Jump_Top = 0; + MUIV_List_Jump_Active = -(1); + MUIV_List_Jump_Bottom = -(2); + MUIV_List_Jump_Up = -(4); + MUIV_List_Jump_Down = -(3); + MUIV_List_NextSelected_Start = -(1); + MUIV_List_NextSelected_End = -(1); + MUIV_DragQuery_Refuse = 0; + MUIV_DragQuery_Accept = 1; + MUIV_DragReport_Abort = 0; + MUIV_DragReport_Continue = 1; + MUIV_DragReport_Lock = 2; + MUIV_DragReport_Refresh = 3; + { + Control codes for text strings + } + { right justified } + MUIX_R : PChar = '\033r'; + { centered } + MUIX_C : PChar = '\033c'; + { left justified } + MUIX_L : PChar = '\033l'; + { normal } + MUIX_N : PChar = '\033n'; + { bold } + MUIX_B : PChar = '\033b'; + { italic } + MUIX_I : PChar = '\033i'; + { underlined } + MUIX_U : PChar = '\033u'; + { text pen } + MUIX_PT : PChar = '\0332'; + { highlight text pen } + MUIX_PH : PChar = '\0338'; + { + Parameter structures for some classes + } + + type + tMUI_Palette_Entry = record + mpe_ID : LONG; + mpe_Red : LongWord; + mpe_Green : LongWord; + mpe_Blue : LongWord; + mpe_Group : LONG; + end; + pMUI_Palette_Entry = ^tMUI_Palette_Entry; + + const + MUIV_Palette_Entry_End = (-1); + { } + { Application Input Handler } + { } + { see below } + + type + tMUI_InputHandlerNode = record + ihn_Node : tMinNode; + ihn_Object : PObject_; + ihn_stuff : record + case LongInt of + 0 : ( ihn_sigs : LongWord ); + 1 : ( ihn_timer : record + ihn_millis : WORD; + ihn_current : WORD; + end ); + end; + ihn_Flags : LongWord; + ihn_Method : LongWord; + end; + pMUI_InputHandlerNode = ^tMUI_InputHandlerNode; + + const + { ihn_Signals = ihn_stuff.ihn_sigs; + ihn_Millis = ihn_stuff.(ihn_timer.ihn_millis); + ihn_Current = ihn_stuff.(ihn_timer.ihn_current); } + { Flags for ihn_Flags } + { set ihn_Ticks to number of 1/100 sec ticks you want to be triggered } + MUIIHNF_TIMER = 1 shl 0; + { } + { Window Event Handler } + { } + { don't touch! } + { event handlers are inserted according to their priority. } + { certain flags, see below for definitions. } + { object which should receive MUIM_HandleEvent. } + { if !=NULL, MUIM_HandleEvent is invoked on exactly this class with CoerceMethod(). } + { one or more IDCMP flags this handler should react on. } + + type + +{ BinCompat Mode? + tMUI_EventHandlerNode = record + ehn_Node : tMinNode; + ehn_Reserved : BYTE; + ehn_Priority : BYTE; + ehn_Flags : WORD; + ehn_Object : PObject_; + ehn_Class : PIClass; + ehn_Events : LongWord; + end;} + tMUI_EventHandlerNode = record + ehn_Node : tMinNode; + ehn_Flags : WORD; + ehn_Object : PObject_; + ehn_Class : PIClass; + ehn_Events : LongWord; + ehn_Priority : BYTE; + end; + pMUI_EventHandlerNode = ^tMUI_EventHandlerNode; + { flags for ehn_Flags } + + const + MUI_EHF_ALWAYSKEYS = 1 shl 0; + { other values reserved for future use } + { return values for MUIM_HandleEvent (bit-masked, all other bits must be 0) } + { stop MUI from calling other handlers } + MUI_EventHandlerRC_Eat = 1 shl 0; + { } + { List Position Test } + { } + { number of entry, -1 if mouse not over valid entry } + { numer of column, -1 if no valid column } + { see below } + { x offset of mouse click relative to column start } + { y offset of mouse click from center of line + (negative values mean click was above center, + positive values mean click was below center) } + + type + tMUI_List_TestPos_Result = record + entry : LONG; + column : WORD; + flags : WORD; + xoffset : WORD; + yoffset : WORD; + end; + pMUI_List_TestPos_Result = ^tMUI_List_TestPos_Result; + + const + MUI_LPR_ABOVE = 1 shl 0; + MUI_LPR_BELOW = 1 shl 1; + MUI_LPR_LEFT = 1 shl 2; + MUI_LPR_RIGHT = 1 shl 3; + + { + + For Boopsi Image Implementors Only: + + If MUI is using a boopsi image object, it will send a special method + immediately after object creation. This method has a parameter structure + where the boopsi can fill in its minimum and maximum size and learn if + its used in a horizontal or vertical context. + + The boopsi image must use the method id (MUIM_BoopsiQuery) as return + value. That's how MUI sees that the method is implemented. + + Note: MUI does not depend on this method. If the boopsi image doesn't + implement it, minimum size will be 0 and maximum size unlimited. + + } + { this is send to the boopsi and } + + const + MUIM_BoopsiQuery = $80427157; + { must be used as return value } + { parameter structure } + { always MUIM_BoopsiQuery } + { obsolete, use mbq_RenderInfo } + { read only, see below } + { write only, fill in min width } + { write only, fill in min height } + { write only, fill in max width } + { write only, fill in max height } + { write only, fill in def width } + { write only, fill in def height } + { read only, display context } + { may grow in future ... } + + type + tMUI_RenderInfo = record + mri_WindowObject : PObject_; + mri_Screen : PScreen; + mri_DrawInfo : PDrawInfo; + mri_Pens : ^WORD; + mri_Window : PWindow; + mri_RastPort : PRastPort; + mri_Flags : LongWord; + end; + PMUI_RenderInfo = ^tMUI_RenderInfo; + + type + tMUI_BoopsiQuery = record + mbq_MethodID : LongWord; + mbq_Screen : PScreen; + mbq_Flags : LongWord; + mbq_MinWidth : LONG; + mbq_MinHeight : LONG; + mbq_MaxWidth : LONG; + mbq_MaxHeight : LONG; + mbq_DefWidth : LONG; + mbq_DefHeight : LONG; + mbq_RenderInfo : PMUI_RenderInfo; + end; + pMUI_BoopsiQuery = ^tMUI_BoopsiQuery; + { old structure name } + + + MUIP_BoopsiQuery = tMUI_BoopsiQuery; + + const + { object used in a horizontal } + MBQF_HORIZ = 1 shl 0; + { context (else vertical) } + { use this for unlimited MaxWidth/Height } + MBQ_MUI_MAXMAX = 10000; + { } + { Begin of automatic header file creation } + { } + { } + { Notify } + { } + + + const + MUIC_Notify : PChar = 'Notify.mui'; + + { Methods } + { V4 } + + const + MUIM_CallHook = $8042b96b; + { V12 } + MUIM_Export = $80420f1c; + { V8 } + MUIM_FindUData = $8042c196; + { V11 } + MUIM_GetConfigItem = $80423edb; + { V8 } + MUIM_GetUData = $8042ed0c; + { V12 } + MUIM_Import = $8042d012; + { V4 } + MUIM_KillNotify = $8042d240; + { V16 } + MUIM_KillNotifyObj = $8042b145; + { V7 } + MUIM_MultiSet = $8042d356; + { V9 } + MUIM_NoNotifySet = $8042216f; + { V4 } + MUIM_Notify = $8042c9cb; + { V4 } + MUIM_Set = $8042549a; + { V4 } + MUIM_SetAsString = $80422590; + { V8 } + MUIM_SetUData = $8042c920; + { V11 } + MUIM_SetUDataOnce = $8042ca19; + { V6 } + MUIM_WriteLong = $80428d86; + { V6 } + MUIM_WriteString = $80424bf4; + { ... } + + type + tMUIP_CallHook = record + MethodID : LongWord; + Hook : PHook; + param1 : LongWord; + end; + pMUIP_CallHook = ^tMUIP_CallHook; + + tMUIP_Export = record + MethodID : LongWord; + dataspace : PObject_; + end; + pMUIP_Export = ^tMUIP_Export; + + tMUIP_FindUData = record + MethodID : LongWord; + udata : LongWord; + end; + pMUIP_FindUData = ^tMUIP_FindUData; + + tMUIP_GetConfigItem = record + MethodID : LongWord; + id : LongWord; + storage : PLongWord; + end; + pMUIP_GetConfigItem = ^tMUIP_GetConfigItem; + + tMUIP_GetUData = record + MethodID : LongWord; + udata : LongWord; + attr : LongWord; + storage : PLongWord; + end; + pMUIP_GetUData = ^tMUIP_GetUData; + + tMUIP_Import = record + MethodID : LongWord; + dataspace : PObject_; + end; + pMUIP_Import = ^tMUIP_Import; + + tMUIP_KillNotify = record + MethodID : LongWord; + TrigAttr : LongWord; + end; + pMUIP_KillNotify = ^tMUIP_KillNotify; + + tMUIP_KillNotifyObj = record + MethodID : LongWord; + TrigAttr : LongWord; + dest : PObject_; + end; + pMUIP_KillNotifyObj = ^tMUIP_KillNotifyObj; + + { ... } + tMUIP_MultiSet = record + MethodID : LongWord; + attr : LongWord; + val : LongWord; + obj : APTR; + end; + pMUIP_MultiSet = ^tMUIP_MultiSet; + + { ... } + tMUIP_NoNotifySet = record + MethodID : LongWord; + attr : LongWord; + format : Pchar; + val : LongWord; + end; + pMUIP_NoNotifySet = ^tMUIP_NoNotifySet; + + { ... } + tMUIP_Notify = record + MethodID : LongWord; + TrigAttr : LongWord; + TrigVal : LongWord; + DestObj : APTR; + FollowParams : LongWord; + end; + pMUIP_Notify = ^tMUIP_Notify; + + tMUIP_Set = record + MethodID : LongWord; + attr : LongWord; + val : LongWord; + end; + pMUIP_Set = ^tMUIP_Set; + + { ... } + tMUIP_SetAsString = record + MethodID : LongWord; + attr : LongWord; + format : Pchar; + val : LongWord; + end; + pMUIP_SetAsString = ^tMUIP_SetAsString; + + tMUIP_SetUData = record + MethodID : LongWord; + udata : LongWord; + attr : LongWord; + val : LongWord; + end; + pMUIP_SetUData = ^tMUIP_SetUData; + + tMUIP_SetUDataOnce = record + MethodID : LongWord; + udata : LongWord; + attr : LongWord; + val : LongWord; + end; + pMUIP_SetUDataOnce = ^tMUIP_SetUDataOnce; + + tMUIP_WriteLong = record + MethodID : LongWord; + val : LongWord; + memory : PLongWord; + end; + pMUIP_WriteLong = ^tMUIP_WriteLong; + + tMUIP_WriteString = record + MethodID : LongWord; + str : Pchar; + memory : Pchar; + end; + pMUIP_WriteString = ^tMUIP_WriteString; + + { Attributes } + { V4 ..g Object } + + const + MUIA_ApplicationObject = $8042d3ee; + { V5 ..g struct AppMessage } + MUIA_AppMessage = $80421955; + { V4 isg LONG } + MUIA_HelpLine = $8042a825; + { V4 isg STRPTR } + MUIA_HelpNode = $80420b85; + { V7 .s. BOOL } + MUIA_NoNotify = $804237f9; + { V11 isg LongWord } + MUIA_ObjectID = $8042d76e; + { V11 ..g Object } + MUIA_Parent = $8042e35f; + { V4 ..g LONG } + MUIA_Revision = $80427eaa; + { V4 isg LongWord } + MUIA_UserData = $80420313; + { V4 ..g LONG } + MUIA_Version = $80422301; + { } + { Family } + { } + + + const + MUIC_Family : PChar = 'Family.mui'; + + { Methods } + { V8 } + + const + MUIM_Family_AddHead = $8042e200; + { V8 } + MUIM_Family_AddTail = $8042d752; + { V8 } + MUIM_Family_Insert = $80424d34; + { V8 } + MUIM_Family_Remove = $8042f8a9; + { V8 } + MUIM_Family_Sort = $80421c49; + { V8 } + MUIM_Family_Transfer = $8042c14a; + + type + tMUIP_Family_AddHead = record + MethodID : LongWord; + obj : PObject_; + end; + pMUIP_Family_AddHead = ^tMUIP_Family_AddHead; + + tMUIP_Family_AddTail = record + MethodID : LongWord; + obj : PObject_; + end; + pMUIP_Family_AddTail = ^tMUIP_Family_AddTail; + + tMUIP_Family_Insert = record + MethodID : LongWord; + obj : PObject_; + pred : PObject_; + end; + pMUIP_Family_Insert = ^tMUIP_Family_Insert; + + tMUIP_Family_Remove = record + MethodID : LongWord; + obj : PObject_; + end; + pMUIP_Family_Remove = ^tMUIP_Family_Remove; + + tMUIP_Family_Sort = record + MethodID : LongWord; + obj : array[0..0] of PObject_; + end; + pMUIP_Family_Sort = ^tMUIP_Family_Sort; + + tMUIP_Family_Transfer = record + MethodID : LongWord; + family : PObject_; + end; + pMUIP_Family_Transfer = ^tMUIP_Family_Transfer; + + { Attributes } + { V8 i.. Object } + + const + MUIA_Family_Child = $8042c696; + { V8 ..g struct MinList } + MUIA_Family_List = $80424b9e; + { } + { Menustrip } + { } + + + const + MUIC_Menustrip : PChar = 'Menustrip.mui'; + + { Methods } + { Attributes } + { V8 isg BOOL } + + const + MUIA_Menustrip_Enabled = $8042815b; + { } + { Menu } + { } + + + const + MUIC_Menu : PChar = 'Menu.mui'; + + { Methods } + { Attributes } + { V8 isg BOOL } + + const + MUIA_Menu_Enabled = $8042ed48; + { V8 isg STRPTR } + MUIA_Menu_Title = $8042a0e3; + { } + { Menuitem } + { } + + + const + MUIC_Menuitem : PChar = 'Menuitem.mui'; + + { Methods } + { Attributes } + { V8 isg BOOL } + + const + MUIA_Menuitem_Checked = $8042562a; + { V8 isg BOOL } + MUIA_Menuitem_Checkit = $80425ace; + { V16 isg BOOL } + MUIA_Menuitem_CommandString = $8042b9cc; + { V8 isg BOOL } + MUIA_Menuitem_Enabled = $8042ae0f; + { V8 isg LONG } + MUIA_Menuitem_Exclude = $80420bc6; + { V8 isg STRPTR } + MUIA_Menuitem_Shortcut = $80422030; + { V8 isg STRPTR } + MUIA_Menuitem_Title = $804218be; + { V8 isg BOOL } + MUIA_Menuitem_Toggle = $80424d5c; + { V8 ..g struct MenuItem } + MUIA_Menuitem_Trigger = $80426f32; + MUIV_Menuitem_Shortcut_Check = -(1); + { } + { Application } + { } + + + const + MUIC_Application : PChar = 'Application.mui'; + + { Methods } + { V14 } + + const + MUIM_Application_AboutMUI = $8042d21d; + { V11 } + MUIM_Application_AddInputHandler = $8042f099; + { V11 } + MUIM_Application_CheckRefresh = $80424d68; + + { MUI_OBSOLETE } + { V4 } + + const + MUIM_Application_InputBuffered = $80427e59; + { V4 } + MUIM_Application_Load = $8042f90d; + { V11 } + MUIM_Application_NewInput = $80423ba6; + { V11 } + MUIM_Application_OpenConfigWindow = $804299ba; + { V4 } + MUIM_Application_PushMethod = $80429ef8; + { V11 } + MUIM_Application_RemInputHandler = $8042e7af; + { V4 } + MUIM_Application_ReturnID = $804276ef; + { V4 } + MUIM_Application_Save = $804227ef; + { V11 } + MUIM_Application_SetConfigItem = $80424a80; + + { V4 } + + const + MUIM_Application_ShowHelp = $80426479; + + type + tMUIP_Application_AboutMUI = record + MethodID : LongWord; + refwindow : PObject_; + end; + pMUIP_Application_AboutMUI = ^tMUIP_Application_AboutMUI; + + tMUIP_Application_AddInputHandler = record + MethodID : LongWord; + ihnode : PMUI_InputHandlerNode; + end; + pMUIP_Application_AddInputHandler = ^tMUIP_Application_AddInputHandler; + + tMUIP_Application_CheckRefresh = record + MethodID : LongWord; + end; + pMUIP_Application_CheckRefresh = ^tMUIP_Application_CheckRefresh; + + tMUIP_Application_GetMenuCheck = record + MethodID : LongWord; + MenuID : LongWord; + end; + pMUIP_Application_GetMenuCheck = ^tMUIP_Application_GetMenuCheck; + + tMUIP_Application_GetMenuState = record + MethodID : LongWord; + MenuID : LongWord; + end; + pMUIP_Application_GetMenuState = ^tMUIP_Application_GetMenuState; + + tMUIP_Application_Input = record + MethodID : LongWord; + signal : PLONGBITS; + end; + pMUIP_Application_Input = ^tMUIP_Application_Input; + + tMUIP_Application_InputBuffered = record + MethodID : LongWord; + end; + pMUIP_Application_InputBuffered = ^tMUIP_Application_InputBuffered; + + tMUIP_Application_Load = record + MethodID : LongWord; + name : STRPTR; + end; + + tMUIP_Application_NewInput = record + MethodID : LongWord; + signal : PLONGBITS; + end; + pMUIP_Application_NewInput = ^tMUIP_Application_NewInput; + + tMUIP_Application_OpenConfigWindow = record + MethodID : LongWord; + flags : LongWord; + end; + pMUIP_Application_OpenConfigWindow = ^tMUIP_Application_OpenConfigWindow; + + { ... } + tMUIP_Application_PushMethod = record + MethodID : LongWord; + dest : PObject_; + count : LONG; + end; + pMUIP_Application_PushMethod = ^tMUIP_Application_PushMethod; + + tMUIP_Application_RemInputHandler = record + MethodID : LongWord; + ihnode : PMUI_InputHandlerNode; + end; + pMUIP_Application_RemInputHandler = ^tMUIP_Application_RemInputHandler; + + tMUIP_Application_ReturnID = record + MethodID : LongWord; + retid : LongWord; + end; + pMUIP_Application_ReturnID = ^tMUIP_Application_ReturnID; + + tMUIP_Application_Save = record + MethodID : LongWord; + name : STRPTR; + end; + + tMUIP_Application_SetConfigItem = record + MethodID : LongWord; + item : LongWord; + data : APTR; + end; + pMUIP_Application_SetConfigItem = ^tMUIP_Application_SetConfigItem; + + tMUIP_Application_SetMenuCheck = record + MethodID : LongWord; + MenuID : LongWord; + stat : LONG; + end; + pMUIP_Application_SetMenuCheck = ^tMUIP_Application_SetMenuCheck; + + tMUIP_Application_SetMenuState = record + MethodID : LongWord; + MenuID : LongWord; + stat : LONG; + end; + pMUIP_Application_SetMenuState = ^tMUIP_Application_SetMenuState; + + tMUIP_Application_ShowHelp = record + MethodID : LongWord; + window : PObject_; + name : Pchar; + node : Pchar; + line : LONG; + end; + pMUIP_Application_ShowHelp = ^tMUIP_Application_ShowHelp; + + { Attributes } + { V4 isg BOOL } + + const + MUIA_Application_Active = $804260ab; + { V4 i.g STRPTR } + MUIA_Application_Author = $80424842; + { V4 i.g STRPTR } + MUIA_Application_Base = $8042e07a; + { V4 ..g Broker } + MUIA_Application_Broker = $8042dbce; + { V4 isg struct Hook } + MUIA_Application_BrokerHook = $80428f4b; + { V6 ..g struct MsgPort } + MUIA_Application_BrokerPort = $8042e0ad; + { V6 i.g LONG } + MUIA_Application_BrokerPri = $8042c8d0; + { V4 isg struct MUI_Command } + MUIA_Application_Commands = $80428648; + { V4 i.g STRPTR } + MUIA_Application_Copyright = $8042ef4d; + { V4 i.g STRPTR } + MUIA_Application_Description = $80421fc6; + { V4 isg struct DiskObject } + MUIA_Application_DiskObject = $804235cb; + { V4 ..g BOOL } + MUIA_Application_DoubleStart = $80423bc6; + { V5 is. Object } + MUIA_Application_DropObject = $80421266; + { V8 ..g BOOL } + MUIA_Application_ForceQuit = $804257df; + { V8 isg STRPTR } + MUIA_Application_HelpFile = $804293f4; + { V4 .sg BOOL } + MUIA_Application_Iconified = $8042a07f; + + + const + MUIA_Application_MenuAction = $80428961; + { V4 ..g LongWord } + MUIA_Application_MenuHelp = $8042540b; + { V8 i.. Object } + MUIA_Application_Menustrip = $804252d9; + { V7 isg struct Hook } + MUIA_Application_RexxHook = $80427c42; + { V4 ..g struct RxMsg } + MUIA_Application_RexxMsg = $8042fd88; + { V4 .s. STRPTR } + MUIA_Application_RexxString = $8042d711; + { V4 i.. BOOL } + MUIA_Application_SingleTask = $8042a2c8; + { V4 .s. BOOL } + MUIA_Application_Sleep = $80425711; + { V4 i.g STRPTR } + MUIA_Application_Title = $804281b8; + { V10 i.. BOOL } + MUIA_Application_UseCommodities = $80425ee5; + { V10 i.. BOOL } + MUIA_Application_UseRexx = $80422387; + { V4 i.g STRPTR } + MUIA_Application_Version = $8042b33f; + { V4 i.. Object } + MUIA_Application_Window = $8042bfe0; + { V13 ..g struct List } + MUIA_Application_WindowList = $80429abe; + MUIV_Application_Package_NetConnect = $a3ff7b49; + { } + { Window } + { } + + const + MUIC_Window : PChar = 'Window.mui'; + + { V16 } + + const + MUIM_Window_AddEventHandler = $804203b7; + + { V16 } + + const + MUIM_Window_RemEventHandler = $8042679e; + { V4 } + MUIM_Window_ScreenToBack = $8042913d; + { V4 } + MUIM_Window_ScreenToFront = $804227a4; + + { V11 } + + const + MUIM_Window_Snapshot = $8042945e; + { V4 } + MUIM_Window_ToBack = $8042152e; + { V4 } + MUIM_Window_ToFront = $8042554f; + + type + tMUIP_Window_AddEventHandler = record + MethodID : LongWord; + ehnode : PMUI_EventHandlerNode; + end; + pMUIP_Window_AddEventHandler = ^tMUIP_Window_AddEventHandler; + + tMUIP_Window_GetMenuCheck = record + MethodID : LongWord; + MenuID : LongWord; + end; + pMUIP_Window_GetMenuCheck = ^tMUIP_Window_GetMenuCheck; + + tMUIP_Window_GetMenuState = record + MethodID : LongWord; + MenuID : LongWord; + end; + pMUIP_Window_GetMenuState = ^tMUIP_Window_GetMenuState; + + tMUIP_Window_RemEventHandler = record + MethodID : LongWord; + ehnode : PMUI_EventHandlerNode; + end; + pMUIP_Window_RemEventHandler = ^tMUIP_Window_RemEventHandler; + + tMUIP_Window_ScreenToBack = record + MethodID : LongWord; + end; + pMUIP_Window_ScreenToBack = ^tMUIP_Window_ScreenToBack; + + tMUIP_Window_ScreenToFront = record + MethodID : LongWord; + end; + pMUIP_Window_ScreenToFront = ^tMUIP_Window_ScreenToFront; + + tMUIP_Window_SetCycleChain = record + MethodID : LongWord; + obj : array[0..0] of PObject_; + end; + pMUIP_Window_SetCycleChain = ^tMUIP_Window_SetCycleChain; + + tMUIP_Window_SetMenuCheck = record + MethodID : LongWord; + MenuID : LongWord; + stat : LONG; + end; + pMUIP_Window_SetMenuCheck = ^tMUIP_Window_SetMenuCheck; + + tMUIP_Window_SetMenuState = record + MethodID : LongWord; + MenuID : LongWord; + stat : LONG; + end; + pMUIP_Window_SetMenuState = ^tMUIP_Window_SetMenuState; + + tMUIP_Window_Snapshot = record + MethodID : LongWord; + flags : LONG; + end; + pMUIP_Window_Snapshot = ^tMUIP_Window_Snapshot; + + tMUIP_Window_ToBack = record + MethodID : LongWord; + end; + pMUIP_Window_ToBack = ^tMUIP_Window_ToBack; + + tMUIP_Window_ToFront = record + MethodID : LongWord; + end; + pMUIP_Window_ToFront = ^tMUIP_Window_ToFront; + + { Attributes } + { V4 isg BOOL } + + const + MUIA_Window_Activate = $80428d2f; + { V4 .sg Object } + MUIA_Window_ActiveObject = $80427925; + { V4 i.g LONG } + MUIA_Window_AltHeight = $8042cce3; + { V4 i.g LONG } + MUIA_Window_AltLeftEdge = $80422d65; + { V4 i.g LONG } + MUIA_Window_AltTopEdge = $8042e99b; + { V4 i.g LONG } + MUIA_Window_AltWidth = $804260f4; + { V5 i.. BOOL } + MUIA_Window_AppWindow = $804280cf; + { V4 i.. BOOL } + MUIA_Window_Backdrop = $8042c0bb; + { V4 i.. BOOL } + MUIA_Window_Borderless = $80429b79; + { V4 i.. BOOL } + MUIA_Window_CloseGadget = $8042a110; + { V4 ..g BOOL } + MUIA_Window_CloseRequest = $8042e86e; + { V4 isg Object } + MUIA_Window_DefaultObject = $804294d7; + { V4 i.. BOOL } + MUIA_Window_DepthGadget = $80421923; + { V4 i.. BOOL } + MUIA_Window_DragBar = $8042045d; + { V8 isg BOOL } + MUIA_Window_FancyDrawing = $8042bd0e; + { V4 i.g LONG } + MUIA_Window_Height = $80425846; + { V4 isg LongWord } + MUIA_Window_ID = $804201bd; + { V4 ..g struct InputEvent } + MUIA_Window_InputEvent = $804247d8; + { V4 isg BOOL } + MUIA_Window_IsSubWindow = $8042b5aa; + { V4 i.g LONG } + MUIA_Window_LeftEdge = $80426c65; + { MUI_OBSOLETE } + { V8 isg LongWord } + + const + MUIA_Window_MenuAction = $80427521; + { V8 i.g Object } + MUIA_Window_Menustrip = $8042855e; + { V10 ..g Object } + MUIA_Window_MouseObject = $8042bf9b; + { V10 i.. BOOL } + MUIA_Window_NeedsMouseObject = $8042372a; + { V4 is. BOOL } + MUIA_Window_NoMenus = $80429df5; + { V4 .sg BOOL } + MUIA_Window_Open = $80428aa0; + { V6 isg STRPTR } + MUIA_Window_PublicScreen = $804278e4; + { V4 is. Object } + MUIA_Window_RefWindow = $804201f4; + { V4 isg Object } + MUIA_Window_RootObject = $8042cba5; + { V4 isg struct Screen } + MUIA_Window_Screen = $8042df4f; + { V5 isg STRPTR } + MUIA_Window_ScreenTitle = $804234b0; + { V4 i.. BOOL } + MUIA_Window_SizeGadget = $8042e33d; + { V4 i.. BOOL } + MUIA_Window_SizeRight = $80424780; + { V4 .sg BOOL } + MUIA_Window_Sleep = $8042e7db; + { V4 isg STRPTR } + MUIA_Window_Title = $8042ad3d; + { V4 i.g LONG } + MUIA_Window_TopEdge = $80427c66; + { V13 isg BOOL } + MUIA_Window_UseBottomBorderScroller = $80424e79; + { V13 isg BOOL } + MUIA_Window_UseLeftBorderScroller = $8042433e; + { V13 isg BOOL } + MUIA_Window_UseRightBorderScroller = $8042c05e; + { V4 i.g LONG } + MUIA_Window_Width = $8042dcae; + { V4 ..g struct Window } + MUIA_Window_Window = $80426a42; + MUIV_Window_ActiveObject_None = 0; + MUIV_Window_ActiveObject_Next = -(1); + MUIV_Window_ActiveObject_Prev = -(2); + + + const + MUIV_Window_AltHeight_Scaled = -(1000); + MUIV_Window_AltLeftEdge_Centered = -(1); + MUIV_Window_AltLeftEdge_Moused = -(2); + MUIV_Window_AltLeftEdge_NoChange = -(1000); + MUIV_Window_AltTopEdge_Centered = -(1); + MUIV_Window_AltTopEdge_Moused = -(2); + + + const + MUIV_Window_AltTopEdge_NoChange = -(1000); + + + const + MUIV_Window_AltWidth_Scaled = -(1000); + + + + const + MUIV_Window_Height_Scaled = -(1000); + MUIV_Window_Height_Default = -(1001); + MUIV_Window_LeftEdge_Centered = -(1); + MUIV_Window_LeftEdge_Moused = -(2); + + + const + MUIV_Window_TopEdge_Centered = -(1); + MUIV_Window_TopEdge_Moused = -(2); + + + const + MUIV_Window_Width_Scaled = -(1000); + MUIV_Window_Width_Default = -(1001); + { } + { Aboutmui } + { } + + + const + MUIC_Aboutmui : PChar = 'Aboutmui.mui'; + + { Methods } + { Attributes } + { V11 i.. Object } + + const + MUIA_Aboutmui_Application = $80422523; + { } + { Area } + { } + + + const + MUIC_Area : PChar = 'Area.mui'; + + { Methods } + { Custom Class } + { V4 } + + const + MUIM_AskMinMax = $80423874; + { Custom Class } + { V4 } + MUIM_Cleanup = $8042d985; + { V11 } + MUIM_ContextMenuBuild = $80429d2e; + { V11 } + MUIM_ContextMenuChoice = $80420f0e; + { V18 } + MUIM_CreateBubble = $80421c41; + { V11 } + MUIM_CreateShortHelp = $80428e93; + { V18 } + MUIM_DeleteBubble = $804211af; + { V11 } + MUIM_DeleteShortHelp = $8042d35a; + { V11 } + MUIM_DragBegin = $8042c03a; + { V11 } + MUIM_DragDrop = $8042c555; + { V11 } + MUIM_DragFinish = $804251f0; + { V11 } + MUIM_DragQuery = $80420261; + { V11 } + MUIM_DragReport = $8042edad; + { Custom Class } + { V4 } + MUIM_Draw = $80426f3f; + { V11 } + MUIM_DrawBackground = $804238ca; + { Custom Class } + { V16 } + MUIM_HandleEvent = $80426d66; + { Custom Class } + { V4 } + MUIM_HandleInput = $80422a1a; + { Custom Class } + { V4 } + MUIM_Hide = $8042f20f; + { Custom Class } + { V4 } + MUIM_Setup = $80428354; + { Custom Class } + { V4 } + MUIM_Show = $8042cc84; + + type + + { MUI_MinMax structure holds information about minimum, maximum + and default dimensions of an object. } + tMUI_MinMax = record + MinWidth : WORD; + MinHeight : WORD; + MaxWidth : WORD; + MaxHeight : WORD; + DefWidth : WORD; + DefHeight : WORD; + end; + pMUI_MinMax = ^tMUI_MinMax; + + tMUIP_AskMinMax = record + MethodID : LongWord; + MinMaxInfo : PMUI_MinMax; + end; + pMUIP_AskMinMax = ^tMUIP_AskMinMax; + + { Custom Class } + tMUIP_Cleanup = record + MethodID : LongWord; + end; + pMUIP_Cleanup = ^tMUIP_Cleanup; + + { Custom Class } + tMUIP_ContextMenuBuild = record + MethodID : LongWord; + mx : LONG; + my : LONG; + end; + pMUIP_ContextMenuBuild = ^tMUIP_ContextMenuBuild; + + tMUIP_ContextMenuChoice = record + MethodID : LongWord; + item : PObject_; + end; + pMUIP_ContextMenuChoice = ^tMUIP_ContextMenuChoice; + + tMUIP_CreateBubble = record + MethodID : LongWord; + x : LONG; + y : LONG; + txt : Pchar; + flags : LongWord; + end; + pMUIP_CreateBubble = ^tMUIP_CreateBubble; + + tMUIP_CreateShortHelp = record + MethodID : LongWord; + mx : LONG; + my : LONG; + end; + pMUIP_CreateShortHelp = ^tMUIP_CreateShortHelp; + + tMUIP_DeleteBubble = record + MethodID : LongWord; + bubble : APTR; + end; + pMUIP_DeleteBubble = ^tMUIP_DeleteBubble; + + tMUIP_DeleteShortHelp = record + MethodID : LongWord; + help : STRPTR; + end; + pMUIP_DeleteShortHelp = ^tMUIP_DeleteShortHelp; + + tMUIP_DragBegin = record + MethodID : LongWord; + obj : PObject_; + end; + pMUIP_DragBegin = ^tMUIP_DragBegin; + + tMUIP_DragDrop = record + MethodID : LongWord; + obj : PObject_; + x : LONG; + y : LONG; + end; + pMUIP_DragDrop = ^tMUIP_DragDrop; + + tMUIP_DragFinish = record + MethodID : LongWord; + obj : PObject_; + end; + pMUIP_DragFinish = ^tMUIP_DragFinish; + + tMUIP_DragQuery = record + MethodID : LongWord; + obj : PObject_; + end; + pMUIP_DragQuery = ^tMUIP_DragQuery; + + tMUIP_DragReport = record + MethodID : LongWord; + obj : PObject_; + x : LONG; + y : LONG; + update : LONG; + end; + pMUIP_DragReport = ^tMUIP_DragReport; + + tMUIP_Draw = record + MethodID : LongWord; + flags : LongWord; + end; + pMUIP_Draw = ^tMUIP_Draw; + + { Custom Class } + tMUIP_DrawBackground = record + MethodID : LongWord; + left : LONG; + top : LONG; + width : LONG; + height : LONG; + xoffset : LONG; + yoffset : LONG; + flags : LONG; + end; + pMUIP_DrawBackground = ^tMUIP_DrawBackground; + + tMUIP_HandleEvent = record + MethodID : LongWord; + imsg : PIntuiMessage; + muikey : LONG; + end; + pMUIP_HandleEvent = ^tMUIP_HandleEvent; + + { Custom Class } + tMUIP_HandleInput = record + MethodID : LongWord; + imsg : PIntuiMessage; + muikey : LONG; + end; + pMUIP_HandleInput = ^tMUIP_HandleInput; + + { Custom Class } + tMUIP_Hide = record + MethodID : LongWord; + end; + pMUIP_Hide = ^tMUIP_Hide; + + { Custom Class } + tMUIP_Setup = record + MethodID : LongWord; + RenderInfo : PMUI_RenderInfo; + end; + pMUIP_Setup = ^tMUIP_Setup; + + { Custom Class } + tMUIP_Show = record + MethodID : LongWord; + end; + pMUIP_Show = ^tMUIP_Show; + + { Custom Class } + { Attributes } + { V4 is. LONG } + + const + MUIA_Background = $8042545b; + { V4 ..g LONG } + MUIA_BottomEdge = $8042e552; + { V11 isg Object } + MUIA_ContextMenu = $8042b704; + { V11 ..g Object } + MUIA_ContextMenuTrigger = $8042a2c1; + { V4 isg char } + MUIA_ControlChar = $8042120b; + { V11 isg LONG } + MUIA_CycleChain = $80421ce7; + { V4 isg BOOL } + MUIA_Disabled = $80423661; + { V11 isg BOOL } + MUIA_Draggable = $80420b6e; + { V11 isg BOOL } + MUIA_Dropable = $8042fbce; + + { V4 is. BOOL } + + const + MUIA_FillArea = $804294a3; + { V4 i.. LONG } + MUIA_FixHeight = $8042a92b; + { V4 i.. STRPTR } + MUIA_FixHeightTxt = $804276f2; + { V4 i.. LONG } + MUIA_FixWidth = $8042a3f1; + { V4 i.. STRPTR } + MUIA_FixWidthTxt = $8042d044; + { V4 i.g struct TextFont } + MUIA_Font = $8042be50; + { V4 i.. LONG } + MUIA_Frame = $8042ac64; + { V4 i.. BOOL } + MUIA_FramePhantomHoriz = $8042ed76; + { V4 i.. STRPTR } + MUIA_FrameTitle = $8042d1c7; + { V4 ..g LONG } + MUIA_Height = $80423237; + { V11 isg LONG } + MUIA_HorizDisappear = $80429615; + { V4 isg WORD } + MUIA_HorizWeight = $80426db9; + { V4 i.g LONG } + MUIA_InnerBottom = $8042f2c0; + { V4 i.g LONG } + MUIA_InnerLeft = $804228f8; + { V4 i.g LONG } + MUIA_InnerRight = $804297ff; + { V4 i.g LONG } + MUIA_InnerTop = $80421eb6; + { V4 i.. LONG } + MUIA_InputMode = $8042fb04; + { V4 ..g LONG } + MUIA_LeftEdge = $8042bec6; + { V11 i.. LONG } + MUIA_MaxHeight = $804293e4; + { V11 i.. LONG } + MUIA_MaxWidth = $8042f112; + { V4 ..g BOOL } + MUIA_Pressed = $80423535; + { V4 ..g LONG } + MUIA_RightEdge = $8042ba82; + { V4 isg BOOL } + MUIA_Selected = $8042654b; + { V11 isg STRPTR } + MUIA_ShortHelp = $80428fe3; + { V4 isg BOOL } + MUIA_ShowMe = $80429ba8; + { V4 i.. BOOL } + MUIA_ShowSelState = $8042caac; + { V4 ..g LONG } + MUIA_Timer = $80426435; + { V4 ..g LONG } + MUIA_TopEdge = $8042509b; + { V11 isg LONG } + MUIA_VertDisappear = $8042d12f; + { V4 isg WORD } + MUIA_VertWeight = $804298d0; + { V4 i.. WORD } + MUIA_Weight = $80421d1f; + { V4 ..g LONG } + MUIA_Width = $8042b59c; + { V4 ..g struct Window } + MUIA_Window = $80421591; + { V4 ..g Object } + MUIA_WindowObject = $8042669e; + MUIV_Font_Inherit = 0; + MUIV_Font_Normal = -(1); + MUIV_Font_List = -(2); + MUIV_Font_Tiny = -(3); + MUIV_Font_Fixed = -(4); + MUIV_Font_Title = -(5); + MUIV_Font_Big = -(6); + MUIV_Font_Button = -(7); + MUIV_Frame_None = 0; + MUIV_Frame_Button = 1; + MUIV_Frame_ImageButton = 2; + MUIV_Frame_Text = 3; + MUIV_Frame_String = 4; + MUIV_Frame_ReadList = 5; + MUIV_Frame_InputList = 6; + MUIV_Frame_Prop = 7; + MUIV_Frame_Gauge = 8; + MUIV_Frame_Group = 9; + MUIV_Frame_PopUp = 10; + MUIV_Frame_Virtual = 11; + MUIV_Frame_Slider = 12; + MUIV_Frame_Count = 13; + MUIV_InputMode_None = 0; + MUIV_InputMode_RelVerify = 1; + MUIV_InputMode_Immediate = 2; + MUIV_InputMode_Toggle = 3; + { } + { Rectangle } + { } + + + const + MUIC_Rectangle : PChar = 'Rectangle.mui'; + + { Attributes } + { V11 i.g STRPTR } + + const + MUIA_Rectangle_BarTitle = $80426689; + { V7 i.g BOOL } + MUIA_Rectangle_HBar = $8042c943; + { V7 i.g BOOL } + MUIA_Rectangle_VBar = $80422204; + { } + { Balance } + { } + + + const + MUIC_Balance : PChar = 'Balance.mui'; + + { } + { Image } + { } + + + const + MUIC_Image : PChar = 'Image.mui'; + + { Attributes } + { V4 i.. BOOL } + + const + MUIA_Image_FontMatch = $8042815d; + { V4 i.. BOOL } + MUIA_Image_FontMatchHeight = $80429f26; + { V4 i.. BOOL } + MUIA_Image_FontMatchWidth = $804239bf; + { V4 i.. BOOL } + MUIA_Image_FreeHoriz = $8042da84; + { V4 i.. BOOL } + MUIA_Image_FreeVert = $8042ea28; + { V4 i.. struct Image } + MUIA_Image_OldImage = $80424f3d; + { V4 i.. char } + MUIA_Image_Spec = $804233d5; + { V4 is. LONG } + MUIA_Image_State = $8042a3ad; + { } + { Bitmap } + { } + + + const + MUIC_Bitmap : PChar = 'Bitmap.mui'; + + { Attributes } + { V8 isg struct BitMap } + + const + MUIA_Bitmap_Bitmap = $804279bd; + { V8 isg LONG } + MUIA_Bitmap_Height = $80421560; + { V8 isg UBYTE } + MUIA_Bitmap_MappingTable = $8042e23d; + { V11 isg LONG } + MUIA_Bitmap_Precision = $80420c74; + { V11 ..g struct BitMap } + MUIA_Bitmap_RemappedBitmap = $80423a47; + { V8 isg LongWord } + MUIA_Bitmap_SourceColors = $80425360; + { V8 isg LONG } + MUIA_Bitmap_Transparent = $80422805; + { V11 i.. BOOL } + MUIA_Bitmap_UseFriend = $804239d8; + { V8 isg LONG } + MUIA_Bitmap_Width = $8042eb3a; + { } + { Bodychunk } + { } + + + const + MUIC_Bodychunk : PChar = 'Bodychunk.mui'; + + { Attributes } + { V8 isg UBYTE } + + const + MUIA_Bodychunk_Body = $8042ca67; + { V8 isg UBYTE } + MUIA_Bodychunk_Compression = $8042de5f; + { V8 isg LONG } + MUIA_Bodychunk_Depth = $8042c392; + { V8 isg UBYTE } + MUIA_Bodychunk_Masking = $80423b0e; + { } + { Text } + { } + + const + MUIC_Text : PChar = 'Text.mui'; + + { Attributes } + { V4 isg STRPTR } + + const + MUIA_Text_Contents = $8042f8dc; + { V4 i.. char } + MUIA_Text_HiChar = $804218ff; + { V4 isg STRPTR } + MUIA_Text_PreParse = $8042566d; + { V4 i.. BOOL } + MUIA_Text_SetMax = $80424d0a; + { V4 i.. BOOL } + MUIA_Text_SetMin = $80424e10; + { V11 i.. BOOL } + MUIA_Text_SetVMax = $80420d8b; + { } + { Gadget } + { } + + const + MUIC_Gadget : PChar = 'Gadget.mui'; + + { Attributes } + { V11 ..g struct Gadget } + + const + MUIA_Gadget_Gadget = $8042ec1a; + { } + { String } + { } + + + const + MUIC_String : PChar = 'String.mui'; + + { Methods } + { Attributes } + { V4 isg STRPTR } + + const + MUIA_String_Accept = $8042e3e1; + { V4 ..g STRPTR } + MUIA_String_Acknowledge = $8042026c; + { V11 isg BOOL } + MUIA_String_AdvanceOnCR = $804226de; + { V4 isg Object } + MUIA_String_AttachedList = $80420fd2; + { V4 .sg LONG } + MUIA_String_BufferPos = $80428b6c; + { V4 isg STRPTR } + MUIA_String_Contents = $80428ffd; + { V4 .sg LONG } + MUIA_String_DisplayPos = $8042ccbf; + { V7 isg struct Hook } + MUIA_String_EditHook = $80424c33; + { V4 i.g LONG } + MUIA_String_Format = $80427484; + { V4 isg LongWord } + MUIA_String_Integer = $80426e8a; + { V11 isg BOOL } + MUIA_String_LonelyEditHook = $80421569; + { V4 i.g LONG } + MUIA_String_MaxLen = $80424984; + { V4 isg STRPTR } + MUIA_String_Reject = $8042179c; + { V4 i.g BOOL } + MUIA_String_Secret = $80428769; + MUIV_String_Format_Left = 0; + MUIV_String_Format_Center = 1; + MUIV_String_Format_Right = 2; + { } + { Boopsi } + { } + + + const + MUIC_Boopsi : PChar = 'Boopsi.mui'; + + { Attributes } + { V4 isg struct IClass } + + const + MUIA_Boopsi_Class = $80426999; + { V4 isg char } + MUIA_Boopsi_ClassID = $8042bfa3; + { V4 isg LongWord } + MUIA_Boopsi_MaxHeight = $8042757f; + { V4 isg LongWord } + MUIA_Boopsi_MaxWidth = $8042bcb1; + { V4 isg LongWord } + MUIA_Boopsi_MinHeight = $80422c93; + { V4 isg LongWord } + MUIA_Boopsi_MinWidth = $80428fb2; + { V4 ..g Object } + MUIA_Boopsi_Object = $80420178; + { V4 i.. LongWord } + MUIA_Boopsi_Remember = $8042f4bd; + { V9 i.. BOOL } + MUIA_Boopsi_Smart = $8042b8d7; + { V4 isg LongWord } + MUIA_Boopsi_TagDrawInfo = $8042bae7; + { V4 isg LongWord } + MUIA_Boopsi_TagScreen = $8042bc71; + { V4 isg LongWord } + MUIA_Boopsi_TagWindow = $8042e11d; + { } + { Prop } + { } + + + const + MUIC_Prop : PChar = 'Prop.mui'; + + { Methods } + { V16 } + + const + MUIM_Prop_Decrease = $80420dd1; + { V16 } + MUIM_Prop_Increase = $8042cac0; + + type + tMUIP_Prop_Decrease = record + MethodID : LongWord; + amount : LONG; + end; + pMUIP_Prop_Decrease = ^tMUIP_Prop_Decrease; + + tMUIP_Prop_Increase = record + MethodID : LongWord; + amount : LONG; + end; + pMUIP_Prop_Increase = ^tMUIP_Prop_Increase; + + { Attributes } + { V4 isg LONG } + + const + MUIA_Prop_Entries = $8042fbdb; + { V4 isg LONG } + MUIA_Prop_First = $8042d4b2; + { V4 i.g BOOL } + MUIA_Prop_Horiz = $8042f4f3; + { V4 isg BOOL } + MUIA_Prop_Slider = $80429c3a; + { V13 i.. LONG } + MUIA_Prop_UseWinBorder = $8042deee; + { V4 isg LONG } + MUIA_Prop_Visible = $8042fea6; + MUIV_Prop_UseWinBorder_None = 0; + MUIV_Prop_UseWinBorder_Left = 1; + MUIV_Prop_UseWinBorder_Right = 2; + MUIV_Prop_UseWinBorder_Bottom = 3; + { } + { Gauge } + { } + + + const + MUIC_Gauge : PChar = 'Gauge.mui'; + + { Attributes } + { V4 isg LONG } + + const + MUIA_Gauge_Current = $8042f0dd; + { V4 isg BOOL } + MUIA_Gauge_Divide = $8042d8df; + { V4 i.. BOOL } + MUIA_Gauge_Horiz = $804232dd; + { V7 isg STRPTR } + MUIA_Gauge_InfoText = $8042bf15; + { V4 isg LONG } + MUIA_Gauge_Max = $8042bcdb; + { } + { Scale } + { } + + + const + MUIC_Scale : PChar = 'Scale.mui'; + + { Attributes } + { V4 isg BOOL } + + const + MUIA_Scale_Horiz = $8042919a; + { } + { Colorfield } + { } + + + const + MUIC_Colorfield : PChar = 'Colorfield.mui'; + + { Attributes } + { V4 isg LongWord } + + const + MUIA_Colorfield_Blue = $8042d3b0; + { V4 isg LongWord } + MUIA_Colorfield_Green = $80424466; + { V4 ..g LongWord } + MUIA_Colorfield_Pen = $8042713a; + { V4 isg LongWord } + MUIA_Colorfield_Red = $804279f6; + { V4 isg LongWord } + MUIA_Colorfield_RGB = $8042677a; + { } + { List } + { } + + + const + MUIC_List : PChar = 'List.mui'; + + { Methods } + { V4 } + + const + MUIM_List_Clear = $8042ad89; + { V11 } + MUIM_List_CreateImage = $80429804; + { V11 } + MUIM_List_DeleteImage = $80420f58; + { V4 } + MUIM_List_Exchange = $8042468c; + { V4 } + MUIM_List_GetEntry = $804280ec; + { V4 } + MUIM_List_Insert = $80426c87; + { V7 } + MUIM_List_InsertSingle = $804254d5; + { V4 } + MUIM_List_Jump = $8042baab; + { V9 } + MUIM_List_Move = $804253c2; + { V6 } + MUIM_List_NextSelected = $80425f17; + { V4 } + MUIM_List_Redraw = $80427993; + { V4 } + MUIM_List_Remove = $8042647e; + { V4 } + MUIM_List_Select = $804252d8; + { V4 } + MUIM_List_Sort = $80422275; + { V11 } + MUIM_List_TestPos = $80425f48; + + type + tMUIP_List_Clear = record + MethodID : LongWord; + end; + pMUIP_List_Clear = ^tMUIP_List_Clear; + + tMUIP_List_CreateImage = record + MethodID : LongWord; + obj : PObject_; + flags : LongWord; + end; + pMUIP_List_CreateImage = ^tMUIP_List_CreateImage; + + tMUIP_List_DeleteImage = record + MethodID : LongWord; + listimg : APTR; + end; + pMUIP_List_DeleteImage = ^tMUIP_List_DeleteImage; + + tMUIP_List_Exchange = record + MethodID : LongWord; + pos1 : LONG; + pos2 : LONG; + end; + pMUIP_List_Exchange = ^tMUIP_List_Exchange; + + tMUIP_List_GetEntry = record + MethodID : LongWord; + pos : LONG; + entry : PAPTR; + end; + pMUIP_List_GetEntry = ^tMUIP_List_GetEntry; + + tMUIP_List_Insert = record + MethodID : LongWord; + entries : PAPTR; + count : LONG; + pos : LONG; + end; + pMUIP_List_Insert = ^tMUIP_List_Insert; + + tMUIP_List_InsertSingle = record + MethodID : LongWord; + entry : APTR; + pos : LONG; + end; + pMUIP_List_InsertSingle = ^tMUIP_List_InsertSingle; + + tMUIP_List_Jump = record + MethodID : LongWord; + pos : LONG; + end; + pMUIP_List_Jump = ^tMUIP_List_Jump; + + tMUIP_List_Move = record + MethodID : LongWord; + from : LONG; + too : LONG; + end; + pMUIP_List_Move = ^tMUIP_List_Move; + + tMUIP_List_NextSelected = record + MethodID : LongWord; + pos : PLONG; + end; + pMUIP_List_NextSelected = ^tMUIP_List_NextSelected; + + tMUIP_List_Redraw = record + MethodID : LongWord; + pos : LONG; + end; + pMUIP_List_Redraw = ^tMUIP_List_Redraw; + + tMUIP_List_Remove = record + MethodID : LongWord; + pos : LONG; + end; + pMUIP_List_Remove = ^tMUIP_List_Remove; + + tMUIP_List_Select = record + MethodID : LongWord; + pos : LONG; + seltype : LONG; + state : PLONG; + end; + pMUIP_List_Select = ^tMUIP_List_Select; + + tMUIP_List_Sort = record + MethodID : LongWord; + end; + pMUIP_List_Sort = ^tMUIP_List_Sort; + + tMUIP_List_TestPos = record + MethodID : LongWord; + x : LONG; + y : LONG; + res : PMUI_List_TestPos_Result; + end; + pMUIP_List_TestPos = ^tMUIP_List_TestPos; + + { Attributes } + { V4 isg LONG } + + const + MUIA_List_Active = $8042391c; + { V4 i.. BOOL } + MUIA_List_AdjustHeight = $8042850d; + { V4 i.. BOOL } + MUIA_List_AdjustWidth = $8042354a; + { V11 isg BOOL } + MUIA_List_AutoVisible = $8042a445; + { V4 is. struct Hook } + MUIA_List_CompareHook = $80425c14; + { V4 is. struct Hook } + MUIA_List_ConstructHook = $8042894f; + { V4 is. struct Hook } + MUIA_List_DestructHook = $804297ce; + { V4 is. struct Hook } + MUIA_List_DisplayHook = $8042b4d5; + { V11 isg BOOL } + MUIA_List_DragSortable = $80426099; + { V11 ..g LONG } + MUIA_List_DropMark = $8042aba6; + { V4 ..g LONG } + MUIA_List_Entries = $80421654; + { V4 ..g LONG } + MUIA_List_First = $804238d4; + { V4 isg STRPTR } + MUIA_List_Format = $80423c0a; + { V9 ..g LONG } + MUIA_List_InsertPosition = $8042d0cd; + { V4 i.. LONG } + MUIA_List_MinLineHeight = $8042d1c3; + { V4 is. struct Hook } + MUIA_List_MultiTestHook = $8042c2c6; + { V13 i.. APTR } + MUIA_List_Pool = $80423431; + { V13 i.. LongWord } + MUIA_List_PoolPuddleSize = $8042a4eb; + { V13 i.. LongWord } + MUIA_List_PoolThreshSize = $8042c48c; + { V4 .s. BOOL } + MUIA_List_Quiet = $8042d8c7; + { V11 isg BOOL } + MUIA_List_ShowDropMarks = $8042c6f3; + { V4 i.. APTR } + MUIA_List_SourceArray = $8042c0a0; + { V6 isg char } + MUIA_List_Title = $80423e66; + { V4 ..g LONG } + MUIA_List_Visible = $8042191f; + MUIV_List_Active_Off = -(1); + MUIV_List_Active_Top = -(2); + MUIV_List_Active_Bottom = -(3); + MUIV_List_Active_Up = -(4); + MUIV_List_Active_Down = -(5); + MUIV_List_Active_PageUp = -(6); + MUIV_List_Active_PageDown = -(7); + MUIV_List_ConstructHook_String = -(1); + MUIV_List_CopyHook_String = -(1); + MUIV_List_CursorType_None = 0; + MUIV_List_CursorType_Bar = 1; + MUIV_List_CursorType_Rect = 2; + MUIV_List_DestructHook_String = -(1); + { } + { Floattext } + { } + + + const + MUIC_Floattext : PChar = 'Floattext.mui'; + + { Attributes } + { V4 isg BOOL } + + const + MUIA_Floattext_Justify = $8042dc03; + { V4 is. STRPTR } + MUIA_Floattext_SkiPChars = $80425c7d; + { V4 is. LONG } + MUIA_Floattext_TabSize = $80427d17; + { V4 isg STRPTR } + MUIA_Floattext_Text = $8042d16a; + { } + { Volumelist } + { } + + + const + MUIC_Volumelist : PChar = 'Volumelist.mui'; + + { } + { Scrmodelist } + { } + + const + MUIC_Scrmodelist : PChar = 'Scrmodelist.mui'; + + { Attributes } + { } + { Dirlist } + { } + + + const + MUIC_Dirlist : PChar = 'Dirlist.mui'; + + { Methods } + { V4 } + + const + MUIM_Dirlist_ReRead = $80422d71; + + type + MUIP_Dirlist_ReRead = record + MethodID : LongWord; + end; + + { Attributes } + { V4 is. STRPTR } + + const + MUIA_Dirlist_AcceptPattern = $8042760a; + { V4 isg STRPTR } + MUIA_Dirlist_Directory = $8042ea41; + { V4 is. BOOL } + MUIA_Dirlist_DrawersOnly = $8042b379; + { V4 is. BOOL } + MUIA_Dirlist_FilesOnly = $8042896a; + { V4 is. BOOL } + MUIA_Dirlist_FilterDrawers = $80424ad2; + { V4 is. struct Hook } + MUIA_Dirlist_FilterHook = $8042ae19; + { V6 is. BOOL } + MUIA_Dirlist_MultiSelDirs = $80428653; + { V4 ..g LONG } + MUIA_Dirlist_NumBytes = $80429e26; + { V4 ..g LONG } + MUIA_Dirlist_NumDrawers = $80429cb8; + { V4 ..g LONG } + MUIA_Dirlist_NumFiles = $8042a6f0; + { V4 ..g STRPTR } + MUIA_Dirlist_Path = $80426176; + { V4 is. BOOL } + MUIA_Dirlist_RejectIcons = $80424808; + { V4 is. STRPTR } + MUIA_Dirlist_RejectPattern = $804259c7; + { V4 is. LONG } + MUIA_Dirlist_SortDirs = $8042bbb9; + { V4 is. BOOL } + MUIA_Dirlist_SortHighLow = $80421896; + { V4 is. LONG } + MUIA_Dirlist_SortType = $804228bc; + { V4 ..g LONG } + MUIA_Dirlist_Status = $804240de; + MUIV_Dirlist_SortDirs_First = 0; + MUIV_Dirlist_SortDirs_Last = 1; + MUIV_Dirlist_SortDirs_Mix = 2; + MUIV_Dirlist_SortType_Name = 0; + MUIV_Dirlist_SortType_Date = 1; + MUIV_Dirlist_SortType_Size = 2; + MUIV_Dirlist_Status_Invalid = 0; + MUIV_Dirlist_Status_Reading = 1; + MUIV_Dirlist_Status_Valid = 2; + { } + { Numeric } + { } + + const + MUIC_Numeric : PChar = 'Numeric.mui'; + + { Methods } + { V11 } + + const + MUIM_Numeric_Decrease = $804243a7; + { V11 } + MUIM_Numeric_Increase = $80426ecd; + { V11 } + MUIM_Numeric_ScaleToValue = $8042032c; + { V11 } + MUIM_Numeric_SetDefault = $8042ab0a; + { V11 } + MUIM_Numeric_Stringify = $80424891; + { V11 } + MUIM_Numeric_ValueToScale = $80423e4f; + + type + tMUIP_Numeric_Decrease = record + MethodID : LongWord; + amount : LONG; + end; + pMUIP_Numeric_Decrease = ^tMUIP_Numeric_Decrease; + + tMUIP_Numeric_Increase = record + MethodID : LongWord; + amount : LONG; + end; + pMUIP_Numeric_Increase = ^tMUIP_Numeric_Increase; + + tMUIP_Numeric_ScaleToValue = record + MethodID : LongWord; + scalemin : LONG; + scalemax : LONG; + scale : LONG; + end; + pMUIP_Numeric_ScaleToValue = ^tMUIP_Numeric_ScaleToValue; + + tMUIP_Numeric_SetDefault = record + MethodID : LongWord; + end; + pMUIP_Numeric_SetDefault = ^tMUIP_Numeric_SetDefault; + + tMUIP_Numeric_Stringify = record + MethodID : LongWord; + value : LONG; + end; + pMUIP_Numeric_Stringify = ^tMUIP_Numeric_Stringify; + + tMUIP_Numeric_ValueToScale = record + MethodID : LongWord; + scalemin : LONG; + scalemax : LONG; + end; + pMUIP_Numeric_ValueToScale = ^tMUIP_Numeric_ValueToScale; + + { Attributes } + { V11 isg BOOL } + + const + MUIA_Numeric_CheckAllSizes = $80421594; + { V11 isg LONG } + MUIA_Numeric_Default = $804263e8; + { V11 isg STRPTR } + MUIA_Numeric_Format = $804263e9; + { V11 isg LONG } + MUIA_Numeric_Max = $8042d78a; + { V11 isg LONG } + MUIA_Numeric_Min = $8042e404; + { V11 isg BOOL } + MUIA_Numeric_Reverse = $8042f2a0; + { V11 isg BOOL } + MUIA_Numeric_RevLeftRight = $804294a7; + { V11 isg BOOL } + MUIA_Numeric_RevUpDown = $804252dd; + { V11 isg LONG } + MUIA_Numeric_Value = $8042ae3a; + { } + { Knob } + { } + + + const + MUIC_Knob : PChar = 'Knob.mui'; + + { } + { Levelmeter } + { } + + + const + MUIC_Levelmeter : PChar = 'Levelmeter.mui'; + + { Attributes } + { V11 isg STRPTR } + + const + MUIA_Levelmeter_Label = $80420dd5; + { } + { Numericbutton } + { } + + + const + MUIC_Numericbutton : PChar = 'Numericbutton.mui'; + + { } + { Slider } + { } + + + const + MUIC_Slider : PChar = 'Slider.mui'; + + { Attributes } + { V11 isg BOOL } + + const + MUIA_Slider_Horiz = $8042fad1; + + { V6 i.. BOOL } + + const + MUIA_Slider_Quiet = $80420b26; + + { } + { Framedisplay } + { } + + + const + MUIC_Framedisplay : PChar = 'Framedisplay.mui'; + + { Attributes } + { } + { Popframe } + { } + + + const + MUIC_Popframe : PChar = 'Popframe.mui'; + + { } + { Imagedisplay } + { } + + const + MUIC_Imagedisplay : PChar = 'Imagedisplay.mui'; + + { Attributes } + { } + { Popimage } + { } + + + const + MUIC_Popimage : PChar = 'Popimage.mui'; + + { } + { Pendisplay } + { } + + + const + MUIC_Pendisplay : PChar = 'Pendisplay.mui'; + + { Methods } + { V13 } + + const + MUIM_Pendisplay_SetColormap = $80426c80; + { V13 } + MUIM_Pendisplay_SetMUIPen = $8042039d; + { V13 } + MUIM_Pendisplay_SetRGB = $8042c131; + + type + MUIP_Pendisplay_SetColormap = record + MethodID : LongWord; + colormap : LONG; + end; + + MUIP_Pendisplay_SetMUIPen = record + MethodID : LongWord; + muipen : LONG; + end; + + MUIP_Pendisplay_SetRGB = record + MethodID : LongWord; + red : LongWord; + green : LongWord; + blue : LongWord; + end; + + { Attributes } + { V13 ..g Object } + + const + MUIA_Pendisplay_Pen = $8042a748; + { V13 isg Object } + MUIA_Pendisplay_Reference = $8042dc24; + { V11 isg struct MUI_RGBcolor } + MUIA_Pendisplay_RGBcolor = $8042a1a9; + { V11 isg struct MUI_PenSpec } + MUIA_Pendisplay_Spec = $8042a204; + { } + { Poppen } + { } + + + const + MUIC_Poppen : PChar = 'Poppen.mui'; + + { } + { Group } + { } + + + const + MUIC_Group : PChar = 'Group.mui'; + + { Methods } + { V11 } + + const + MUIM_Group_ExitChange = $8042d1cc; + { V11 } + MUIM_Group_InitChange = $80420887; + { V4 } + MUIM_Group_Sort = $80427417; + + type + tMUIP_Group_ExitChange = record + MethodID : LongWord; + end; + pMUIP_Group_ExitChange = ^tMUIP_Group_ExitChange; + + tMUIP_Group_InitChange = record + MethodID : LongWord; + end; + pMUIP_Group_InitChange = ^tMUIP_Group_InitChange; + + tMUIP_Group_Sort = record + MethodID : LongWord; + obj : array[0..0] of PObject_; + end; + pMUIP_Group_Sort = ^tMUIP_Group_Sort; + + { Attributes } + { V5 isg LONG } + + const + MUIA_Group_ActivePage = $80424199; + { V4 i.. Object } + MUIA_Group_Child = $804226e6; + { V4 ..g struct List } + MUIA_Group_ChildList = $80424748; + { V4 is. LONG } + MUIA_Group_Columns = $8042f416; + { V4 i.. BOOL } + MUIA_Group_Horiz = $8042536b; + { V4 isg LONG } + MUIA_Group_HorizSpacing = $8042c651; + { V11 i.. struct Hook } + MUIA_Group_LayoutHook = $8042c3b2; + { V5 i.. BOOL } + MUIA_Group_PageMode = $80421a5f; + { V4 is. LONG } + MUIA_Group_Rows = $8042b68f; + { V4 i.. BOOL } + MUIA_Group_SameHeight = $8042037e; + { V4 i.. BOOL } + MUIA_Group_SameSize = $80420860; + { V4 i.. BOOL } + MUIA_Group_SameWidth = $8042b3ec; + { V4 is. LONG } + MUIA_Group_Spacing = $8042866d; + { V4 isg LONG } + MUIA_Group_VertSpacing = $8042e1bf; + MUIV_Group_ActivePage_First = 0; + MUIV_Group_ActivePage_Last = -(1); + MUIV_Group_ActivePage_Prev = -(2); + MUIV_Group_ActivePage_Next = -(3); + MUIV_Group_ActivePage_Advance = -(4); + { } + { Mccprefs } + { } + + + const + MUIC_Mccprefs : PChar = 'Mccprefs.mui'; + + { } + { Register } + { } + + const + MUIC_Register : PChar = 'Register.mui'; + + { Attributes } + { V7 i.g BOOL } + + const + MUIA_Register_Frame = $8042349b; + { V7 i.g STRPTR } + MUIA_Register_Titles = $804297ec; + { } + { Penadjust } + { } + + + const + MUIC_Penadjust : PChar= 'Penadjust.mui'; + + { Methods } + { Attributes } + { V11 i.. BOOL } + + const + MUIA_Penadjust_PSIMode = $80421cbb; + { } + { Settingsgroup } + { } + + + const + MUIC_Settingsgroup : PChar = 'Settingsgroup.mui'; + + { Methods } + { V11 } + + const + MUIM_Settingsgroup_ConfigToGadgets = $80427043; + { V11 } + MUIM_Settingsgroup_GadgetsToConfig = $80425242; + + type + tMUIP_Settingsgroup_ConfigToGadgets = record + MethodID : LongWord; + configdata : PObject_; + end; + pMUIP_Settingsgroup_ConfigToGadgets = ^tMUIP_Settingsgroup_ConfigToGadgets; + + tMUIP_Settingsgroup_GadgetsToConfig = record + MethodID : LongWord; + configdata : PObject_; + end; + pMUIP_Settingsgroup_GadgetsToConfig = ^tMUIP_Settingsgroup_GadgetsToConfig; + + { Attributes } + { } + { Settings } + { } + + const + MUIC_Settings : PChar = 'Settings.mui'; + + { Methods } + { Attributes } + { } + { Frameadjust } + { } + + + const + MUIC_Frameadjust : PChar = 'Frameadjust.mui'; + + { Methods } + { Attributes } + { } + { Imageadjust } + { } + + + const + MUIC_Imageadjust : PChar = 'Imageadjust.mui'; + + { Methods } + { Attributes } + + const + MUIV_Imageadjust_Type_All = 0; + MUIV_Imageadjust_Type_Image = 1; + MUIV_Imageadjust_Type_Background = 2; + MUIV_Imageadjust_Type_Pen = 3; + { } + { Virtgroup } + { } + + + const + MUIC_Virtgroup : PChar = 'Virtgroup.mui'; + + { Methods } + { Attributes } + { V6 ..g LONG } + + const + MUIA_Virtgroup_Height = $80423038; + { V11 i.. BOOL } + MUIA_Virtgroup_Input = $80427f7e; + { V6 isg LONG } + MUIA_Virtgroup_Left = $80429371; + { V6 isg LONG } + MUIA_Virtgroup_Top = $80425200; + { V6 ..g LONG } + MUIA_Virtgroup_Width = $80427c49; + { } + { Scrollgroup } + { } + + + const + MUIC_Scrollgroup : PChar = 'Scrollgroup.mui'; + + { Methods } + { Attributes } + { V4 i.g Object } + + const + MUIA_Scrollgroup_Contents = $80421261; + { V9 i.. BOOL } + MUIA_Scrollgroup_FreeHoriz = $804292f3; + { V9 i.. BOOL } + MUIA_Scrollgroup_FreeVert = $804224f2; + { V16 ..g Object } + MUIA_Scrollgroup_HorizBar = $8042b63d; + { V13 i.. BOOL } + MUIA_Scrollgroup_UseWinBorder = $804284c1; + { V16 ..g Object } + MUIA_Scrollgroup_VertBar = $8042cdc0; + { } + { Scrollbar } + { } + + + const + MUIC_Scrollbar : PChar = 'Scrollbar.mui'; + + { Attributes } + { V11 i.. LONG } + + const + MUIA_Scrollbar_Type = $8042fb6b; + MUIV_Scrollbar_Type_Default = 0; + MUIV_Scrollbar_Type_Bottom = 1; + MUIV_Scrollbar_Type_Top = 2; + MUIV_Scrollbar_Type_Sym = 3; + { } + { Listview } + { } + + + const + MUIC_Listview : PChar = 'Listview.mui'; + + { Attributes } + { V7 ..g LONG } + + const + MUIA_Listview_ClickColumn = $8042d1b3; + { V7 isg LONG } + MUIA_Listview_DefClickColumn = $8042b296; + { V4 i.g BOOL } + MUIA_Listview_DoubleClick = $80424635; + { V11 isg LONG } + MUIA_Listview_DragType = $80425cd3; + { V4 i.. BOOL } + MUIA_Listview_Input = $8042682d; + { V4 i.g Object } + MUIA_Listview_List = $8042bcce; + { V7 i.. LONG } + MUIA_Listview_MultiSelect = $80427e08; + { V10 i.. BOOL } + MUIA_Listview_ScrollerPos = $8042b1b4; + { V4 ..g BOOL } + MUIA_Listview_SelectChange = $8042178f; + MUIV_Listview_DragType_None = 0; + MUIV_Listview_DragType_Immediate = 1; + MUIV_Listview_MultiSelect_None = 0; + MUIV_Listview_MultiSelect_Default = 1; + MUIV_Listview_MultiSelect_Shifted = 2; + MUIV_Listview_MultiSelect_Always = 3; + MUIV_Listview_ScrollerPos_Default = 0; + MUIV_Listview_ScrollerPos_Left = 1; + MUIV_Listview_ScrollerPos_Right = 2; + MUIV_Listview_ScrollerPos_None = 3; + { } + { Radio } + { } + + + const + MUIC_Radio : PChar = 'Radio.mui'; + + { Attributes } + { V4 isg LONG } + + const + MUIA_Radio_Active = $80429b41; + { V4 i.. STRPTR } + MUIA_Radio_Entries = $8042b6a1; + { } + { Cycle } + { } + + + const + MUIC_Cycle : PChar = 'Cycle.mui'; + + { Attributes } + { V4 isg LONG } + + const + MUIA_Cycle_Active = $80421788; + { V4 i.. STRPTR } + MUIA_Cycle_Entries = $80420629; + MUIV_Cycle_Active_Next = -(1); + MUIV_Cycle_Active_Prev = -(2); + { } + { Coloradjust } + { } + + + const + MUIC_Coloradjust : PChar = 'Coloradjust.mui'; + + { Methods } + { Attributes } + { V4 isg LongWord } + + const + MUIA_Coloradjust_Blue = $8042b8a3; + { V4 isg LongWord } + MUIA_Coloradjust_Green = $804285ab; + { V4 isg LongWord } + MUIA_Coloradjust_ModeID = $8042ec59; + { V4 isg LongWord } + MUIA_Coloradjust_Red = $80420eaa; + { V4 isg LongWord } + MUIA_Coloradjust_RGB = $8042f899; + { } + { Palette } + { } + + + const + MUIC_Palette : PChar = 'Palette.mui'; + + { Attributes } + { V6 i.g struct MUI_Palette_Entry } + + const + MUIA_Palette_Entries = $8042a3d8; + { V6 isg BOOL } + MUIA_Palette_Groupable = $80423e67; + { V6 isg char } + MUIA_Palette_Names = $8042c3a2; + { } + { Popstring } + { } + + + const + MUIC_Popstring : PChar = 'Popstring.mui'; + + { Methods } + { V7 } + + const + MUIM_Popstring_Close = $8042dc52; + { V7 } + MUIM_Popstring_Open = $804258ba; + + type + tMUIP_Popstring_Close = record + MethodID : LongWord; + result : LONG; + end; + pMUIP_Popstring_Close = ^tMUIP_Popstring_Close; + + tMUIP_Popstring_Open = record + MethodID : LongWord; + end; + pMUIP_Popstring_Open = ^tMUIP_Popstring_Open; + + { Attributes } + { V7 i.g Object } + + const + MUIA_Popstring_Button = $8042d0b9; + { V7 isg struct Hook } + MUIA_Popstring_CloseHook = $804256bf; + { V7 isg struct Hook } + MUIA_Popstring_OpenHook = $80429d00; + { V7 i.g Object } + MUIA_Popstring_String = $804239ea; + { V7 isg BOOL } + MUIA_Popstring_Toggle = $80422b7a; + { } + { Popobject } + { } + + + const + MUIC_Popobject : PChar = 'Popobject.mui'; + + { Attributes } + { V7 isg BOOL } + + const + MUIA_Popobject_Follow = $80424cb5; + { V7 isg BOOL } + MUIA_Popobject_Light = $8042a5a3; + { V7 i.g Object } + MUIA_Popobject_Object = $804293e3; + { V7 isg struct Hook } + MUIA_Popobject_ObjStrHook = $8042db44; + { V7 isg struct Hook } + MUIA_Popobject_StrObjHook = $8042fbe1; + { V7 isg BOOL } + MUIA_Popobject_Volatile = $804252ec; + { V9 isg struct Hook } + MUIA_Popobject_WindowHook = $8042f194; + { } + { Poplist } + { } + + + const + MUIC_Poplist : PChar = 'Poplist.mui'; + + { Attributes } + { V8 i.. char } + + const + MUIA_Poplist_Array = $8042084c; + { } + { Popscreen } + { } + + + const + MUIC_Popscreen : PChar = 'Popscreen.mui'; + + { Attributes } + { } + { Popasl } + { } + + const + MUIC_Popasl : PChar = 'Popasl.mui'; + + { Attributes } + { V7 ..g BOOL } + + const + MUIA_Popasl_Active = $80421b37; + { V7 isg struct Hook } + MUIA_Popasl_StartHook = $8042b703; + { V7 isg struct Hook } + MUIA_Popasl_StopHook = $8042d8d2; + { V7 i.g LongWord } + MUIA_Popasl_Type = $8042df3d; + { } + { Semaphore } + { } + + + const + MUIC_Semaphore : PChar = 'Semaphore.mui'; + + { Methods } + { V11 } + + const + MUIM_Semaphore_Attempt = $80426ce2; + { V11 } + MUIM_Semaphore_AttemptShared = $80422551; + { V11 } + MUIM_Semaphore_Obtain = $804276f0; + { V11 } + MUIM_Semaphore_ObtainShared = $8042ea02; + { V11 } + MUIM_Semaphore_Release = $80421f2d; + + type + tMUIP_Semaphore_Attempt = record + MethodID : LongWord; + end; + pMUIP_Semaphore_Attempt = ^tMUIP_Semaphore_Attempt; + + tMUIP_Semaphore_AttemptShared = record + MethodID : LongWord; + end; + pMUIP_Semaphore_AttemptShared = ^tMUIP_Semaphore_AttemptShared; + + tMUIP_Semaphore_Obtain = record + MethodID : LongWord; + end; + pMUIP_Semaphore_Obtain = ^tMUIP_Semaphore_Obtain; + + tMUIP_Semaphore_ObtainShared = record + MethodID : LongWord; + end; + pMUIP_Semaphore_ObtainShared = ^tMUIP_Semaphore_ObtainShared; + + tMUIP_Semaphore_Release = record + MethodID : LongWord; + end; + pMUIP_Semaphore_Release = ^tMUIP_Semaphore_Release; + + { } + { Applist } + { } + + const + MUIC_Applist : PChar = 'Applist.mui'; + { Methods } + { } + { Cclist } + { } + + + const + MUIC_Cclist : PChar = 'Cclist.mui'; + + { Methods } + { } + { Dataspace } + { } + + + const + MUIC_Dataspace : PChar = 'Dataspace.mui'; + + { Methods } + { V11 } + + const + MUIM_Dataspace_Add = $80423366; + { V11 } + MUIM_Dataspace_Clear = $8042b6c9; + { V11 } + MUIM_Dataspace_Find = $8042832c; + { V11 } + MUIM_Dataspace_Merge = $80423e2b; + { V11 } + MUIM_Dataspace_ReadIFF = $80420dfb; + { V11 } + MUIM_Dataspace_Remove = $8042dce1; + { V11 } + MUIM_Dataspace_WriteIFF = $80425e8e; + + type + tMUIP_Dataspace_Add = record + MethodID : LongWord; + data : APTR; + len : LONG; + id : LongWord; + end; + pMUIP_Dataspace_Add = ^tMUIP_Dataspace_Add; + + tMUIP_Dataspace_Clear = record + MethodID : LongWord; + end; + pMUIP_Dataspace_Clear = ^tMUIP_Dataspace_Clear; + + tMUIP_Dataspace_Find = record + MethodID : LongWord; + id : LongWord; + end; + pMUIP_Dataspace_Find = ^tMUIP_Dataspace_Find; + + tMUIP_Dataspace_Merge = record + MethodID : LongWord; + dataspace : PObject_; + end; + pMUIP_Dataspace_Merge = ^tMUIP_Dataspace_Merge; + + tMUIP_Dataspace_ReadIFF = record + MethodID : LongWord; + handle : Pointer;//PIFFHandle; + end; + pMUIP_Dataspace_ReadIFF = ^tMUIP_Dataspace_ReadIFF; + + tMUIP_Dataspace_Remove = record + MethodID : LongWord; + id : LongWord; + end; + pMUIP_Dataspace_Remove = ^tMUIP_Dataspace_Remove; + + tMUIP_Dataspace_WriteIFF = record + MethodID : LongWord; + handle : Pointer; //PIFFHandle; + type_ : LongWord; + id : LongWord; + end; + pMUIP_Dataspace_WriteIFF = ^tMUIP_Dataspace_WriteIFF; + + { Attributes } + { V11 i.. APTR } + + const + MUIA_Dataspace_Pool = $80424cf9; + { } + { Configdata } + { } + + + const + MUIC_Configdata : PChar = 'Configdata.mui'; + + { Methods } + { Attributes } + { } + { Dtpic } + { } + + + const + MUIC_Dtpic : PChar = 'Dtpic.mui'; + { Attributes } + { } + { End of automatic header file creation } + { } + { + Structures and Macros for creating custom classes. + } + { + GENERAL NOTES: + + - Everything described in this header file is only valid within + MUI classes. You may never use any of these things out of + a class, e.g. in a traditional MUI application. + + - Except when otherwise stated, all structures are strictly read only. + } + { Global information for every object } + { ... private data follows ... } + + type + tMUI_GlobalInfo = record + priv0 : LongWord; + mgi_ApplicationObject : PObject_; + end; + pMUI_GlobalInfo = ^tMUI_GlobalInfo; + + { Instance data of notify class } + tMUI_NotifyData = record + mnd_GlobalInfo : PMUI_GlobalInfo; + mnd_UserData : LongWord; + mnd_ObjectID : LongWord; + priv1 : LongWord; + priv2 : LongWord; + priv3 : LongWord; + priv4 : LongWord; + end; + pMUI_NotifyData = ^tMUI_NotifyData; + + + { use this if a dimension is not limited. } + + const + MUI_MAXMAX = 10000; + { Hook message for custom layout } + { type of message (see defines below) } + { list of this groups children, traverse with NextObject() } + { results for MUILM_MINMAX } + { size (and result) for MUILM_LAYOUT } + + type + tMUI_LayoutMsg = record + lm_Type : LongWord; + lm_Children : PMinList; + lm_MinMax : tMUI_MinMax; + lm_Layout : record + Width : LONG; + Height : LONG; + priv5 : LongWord; + priv6 : LongWord; + end; + end; + pMUI_LayoutMsg = ^tMUI_LayoutMsg; + + { MUI wants you to calc your min & max sizes } + + const + MUILM_MINMAX = 1; + { MUI wants you to layout your children } + MUILM_LAYOUT = 2; + { return this if your hook doesn't implement lm_Type } + MUILM_UNKNOWN = -(1); + { (partial) instance data of area class } + { RenderInfo for this object } + { Font } + { min/max/default sizes } + { position and dimension } + { frame & innerspacing left offset } + { frame & innerspacing top offset } + { frame & innerspacing add. width } + { frame & innerspacing add. height } + { see definitions below } + { ... private data follows ... } + + type + tMUI_AreaData = record + mad_RenderInfo : PMUI_RenderInfo; + priv7 : LongWord; + mad_Font : PTextFont; + mad_MinMax : tMUI_MinMax; + mad_Box : tIBox; + mad_addleft : BYTE; + mad_addtop : BYTE; + mad_subwidth : BYTE; + mad_subheight : BYTE; + mad_Flags : LongWord; + end; + pMUI_AreaData = ^tMUI_AreaData; + + { Definitions for mad_Flags, other flags are private } + { completely redraw yourself } + + const + MADF_DRAWOBJECT = 1 shl 0; + { only update yourself } + MADF_DRAWUPDATE = 1 shl 1; + { MUI's draw pens } + MPEN_SHINE = 0; + MPEN_HALFSHINE = 1; + MPEN_BACKGROUND = 2; + MPEN_HALFSHADOW = 3; + MPEN_SHADOW = 4; + MPEN_TEXT = 5; + MPEN_FILL = 6; + MPEN_MARK = 7; + MPEN_COUNT = 8; + { Mask for pens from MUI_ObtainPen() } + MUIPEN_MASK = $0000ffff; + + + { Information on display environment } + { valid between MUIM_Setup/MUIM_Cleanup } + { valid between MUIM_Setup/MUIM_Cleanup } + { valid between MUIM_Setup/MUIM_Cleanup } + { valid between MUIM_Setup/MUIM_Cleanup } + { valid between MUIM_Show/MUIM_Hide } + { valid between MUIM_Show/MUIM_Hide } + { valid between MUIM_Setup/MUIM_Cleanup } + { ... private data follows ... } + + + + { + If mri_Flags & MUIMRI_RECTFILL, RectFill() is quicker + than Move()/Draw() for horizontal or vertical lines. + on the current display. + } + + const + MUIMRI_RECTFILL = 1 shl 0; + { + If mri_Flags & MUIMRI_TRUECOLOR, display environment is a + cybergraphics emulated hicolor or true color display. + } + MUIMRI_TRUECOLOR = 1 shl 1; + { + If mri_Flags & MUIMRI_THINFRAMES, MUI uses thin frames + (1:1) apsect ratio instead of standard 2:1 frames. + } + MUIMRI_THINFRAMES = 1 shl 2; + { + If mri_Flags & MUIMRI_REFRESHMODE, MUI is currently + refreshing a WFLG_SIMPLEREFRESH window and is between + a BeginRefresh()/EndRefresh() pair. + } + MUIMRI_REFRESHMODE = 1 shl 3; + { the following macros can be used to get pointers to an objects + GlobalInfo and RenderInfo structures. } + + type + t__dummyXFC2__ = record + mnd : tMUI_NotifyData; + mad : tMUI_AreaData; + end; + p__dummyXFC2__ = ^t__dummyXFC2__; + + + const + + MUIKEY_RELEASE = -2; + MUIKEY_NONE = -1; + MUIKEY_PRESS = 0; + MUIKEY_TOGGLE = 1; + MUIKEY_UP = 2; + MUIKEY_DOWN = 3; + MUIKEY_PAGEUP = 4; + MUIKEY_PAGEDOWN = 5; + MUIKEY_TOP = 6; + MUIKEY_BOTTOM = 7; + MUIKEY_LEFT = 8; + MUIKEY_RIGHT = 9; + MUIKEY_WORDLEFT = 10; + MUIKEY_WORDRIGHT = 11; + MUIKEY_LINESTART = 12; + MUIKEY_LINEEND = 13; + MUIKEY_GADGET_NEXT = 14; + MUIKEY_GADGET_PREV = 15; + MUIKEY_GADGET_OFF = 16; + MUIKEY_WINDOW_CLOSE = 17; + MUIKEY_WINDOW_NEXT = 18; + MUIKEY_WINDOW_PREV = 19; + MUIKEY_HELP = 20; + MUIKEY_POPUP = 21; + MUIKEY_COUNT = 22; + + MUIKEYF_PRESS = 1 shl MUIKEY_PRESS; + MUIKEYF_TOGGLE = 1 shl MUIKEY_TOGGLE; + MUIKEYF_UP = 1 shl MUIKEY_UP; + MUIKEYF_DOWN = 1 shl MUIKEY_DOWN; + MUIKEYF_PAGEUP = 1 shl MUIKEY_PAGEUP; + MUIKEYF_PAGEDOWN = 1 shl MUIKEY_PAGEDOWN; + MUIKEYF_TOP = 1 shl MUIKEY_TOP; + MUIKEYF_BOTTOM = 1 shl MUIKEY_BOTTOM; + MUIKEYF_LEFT = 1 shl MUIKEY_LEFT; + MUIKEYF_RIGHT = 1 shl MUIKEY_RIGHT; + MUIKEYF_WORDLEFT = 1 shl MUIKEY_WORDLEFT; + MUIKEYF_WORDRIGHT = 1 shl MUIKEY_WORDRIGHT; + MUIKEYF_LINESTART = 1 shl MUIKEY_LINESTART; + MUIKEYF_LINEEND = 1 shl MUIKEY_LINEEND; + MUIKEYF_GADGET_NEXT = 1 shl MUIKEY_GADGET_NEXT; + MUIKEYF_GADGET_PREV = 1 shl MUIKEY_GADGET_PREV; + MUIKEYF_GADGET_OFF = 1 shl MUIKEY_GADGET_OFF; + MUIKEYF_WINDOW_CLOSE = 1 shl MUIKEY_WINDOW_CLOSE; + MUIKEYF_WINDOW_NEXT = 1 shl MUIKEY_WINDOW_NEXT; + MUIKEYF_WINDOW_PREV = 1 shl MUIKEY_WINDOW_PREV; + MUIKEYF_HELP = 1 shl MUIKEY_HELP; + MUIKEYF_POPUP = 1 shl MUIKEY_POPUP; + + { MUI_CustomClass returned by MUI_CreateCustomClass() } + { use for whatever you want } + { MUI has opened these libraries } + { for you automatically. You can } + { use them or decide to open } + { your libraries yourself. } + { pointer to super class } + { pointer to the new class } + { ... private data follows ... } + + type + tMUI_CustomClass = record + mcc_UserData : APTR; + mcc_UtilityBase : PLibrary; + mcc_DOSBase : PLibrary; + mcc_GfxBase : PLibrary; + mcc_IntuitionBase : PLibrary; + mcc_Super : PIClass; + mcc_Class : PIClass; + end; + pMUI_CustomClass = ^tMUI_CustomClass; + +var + MUIMasterBase : pLibrary; + +function MUI_NewObjectA(class_ : PChar; tags : pTagItem) : PObject_; syscall MUIMasterBase 5; +procedure MUI_DisposeObject(obj : PObject_); syscall MUIMasterBase 6; +function MUI_RequestA(app : Pointer; win : Pointer; flags : LONGBITS; title : PChar; gadgets : PChar; format : PChar; params : Pointer) : LongInt; syscall MUIMasterBase 7; +function MUI_AllocAslRequest(typ : LongWord; tags : pTagItem) : Pointer; syscall MUIMasterBase 8; +function MUI_AslRequest(req : Pointer; tags : pTagItem) : LongBool; syscall MUIMasterBase 9; +procedure MUI_FreeAslRequest(req : Pointer); syscall MUIMasterBase 10; +function MUI_Error : LongInt; syscall MUIMasterBase 11; +function MUI_SetError(errnum : LongInt) : LongInt; syscall MUIMasterBase 12; +function MUI_GetClass(name : pCHar) : PIClass; syscall MUIMasterBase 13; +procedure MUI_FreeClass(cl : PIClass); syscall MUIMasterBase 14; +procedure MUI_RequestIDCMP(obj : PObject_; flags : LongWord); syscall MUIMasterBase 15; +procedure MUI_RejectIDCMP(obj : PObject_; flags : LongWord); syscall MUIMasterBase 16; +procedure MUI_Redraw(obj : PObject_; flags : LongWord); syscall MUIMasterBase 17; +function MUI_CreateCustomClass(base : pLibrary; supername : PChar; supermcc : pMUI_CustomClass; datasize : LongInt; dispatcher : Pointer) : PMUI_CustomClass; syscall MUIMasterBase 18; +function MUI_DeleteCustomClass(mcc : pMUI_CustomClass) : LongBool; syscall MUIMasterBase 19; +function MUI_MakeObjectA(typ: LongInt; params : pLongWord) : PObject_; syscall MUIMasterBase 20; +function MUI_Layout(obj: PObject_; l : LongInt; t : LongInt; w : LongInt; h : LongInt; flags : LongWord) : LongBool; syscall MUIMasterBase 21; +function MUI_ObtainPen(mri: PMUI_RenderInfo; spec : pMUI_PenSpec; flags : LongWord) : LongInt; syscall MUIMasterBase 22; +procedure MUI_ReleasePen(mri: PMUI_RenderInfo; pen : LongInt); syscall MUIMasterBase 23; +function MUI_AddClipping(mri: PMUI_RenderInfo; l : smallint; t : smallint; w : smallint; h : smallint) : Pointer; syscall MUIMasterBase 24; +procedure MUI_RemoveClipping(mri: PMUI_RenderInfo; h : Pointer); syscall MUIMasterBase 25; +function MUI_AddClipRegion(mri: PMUI_RenderInfo; region : pRegion) : Pointer; syscall MUIMasterBase 26; +procedure MUI_RemoveClipRegion(mri: PMUI_RenderInfo; region : Pointer); syscall MUIMasterBase 27; +function MUI_BeginRefresh(mri: PMUI_RenderInfo; flags : LongWord) : LongBool; syscall MUIMasterBase 28; +procedure MUI_EndRefresh(mri: PMUI_RenderInfo; flags : LongWord); syscall MUIMasterBase 29; + + +(* +** some procedures to get some information about our object +*) + +function MUINotifyData(obj : APTR) : pMUI_NotifyData; +function MUIAreaData(obj : APTR) : pMUI_AreaData; +function MUIGlobalInfo(obj : APTR) : pMUI_GlobalInfo; +function MUIUserData(obj : APTR) : Pointer ; +function MUIRenderInfo(obj : APTR) : PMUI_RenderInfo; +function MUIPen(pen : LongInt): LongInt; +(* +** some more specialized functions to retain information about special +** object-data like rastport, window, etc. +** +** NOTE: These macros may only be used in custom classes and are +** only valid if your class is inbetween the specified methods! +*) + +function OBJ_App(obj : APTR) : PObject_; (* valid between MUIM_Setup/Cleanup *) +function OBJ_Win(obj : APTR) : PObject_; (* valid between MUIM_Setup/Cleanup *) +function OBJ_Dri(obj : APTR) : pDrawInfo; (* valid between MUIM_Setup/Cleanup *) +function OBJ_Screen(obj : APTR) : pScreen; (* valid between MUIM_Setup/Cleanup *) +function OBJ_Pens(obj : APTR) : pWord; (* valid between MUIM_Setup/Cleanup *) +function OBJ_Window(obj : APTR) : pWindow; (* valid between MUIM_Show/Hide *) +function OBJ_Rp(obj : APTR) : pRastPort; (* valid between MUIM_Show/Hide *) +function OBJ_Left(obj : APTR) : smallint; (* valid during MUIM_Draw *) +function OBJ_Top(obj : APTR) : smallint; (* valid during MUIM_Draw *) +function OBJ_Width(obj : APTR) : smallint; (* valid during MUIM_Draw *) +function OBJ_Height(obj : APTR) : smallint; (* valid during MUIM_Draw *) +function OBJ_Right(obj : APTR) : smallint; (* valid during MUIM_Draw *) +function OBJ_Bottom(obj : APTR) : smallint; (* valid during MUIM_Draw *) +function OBJ_AddLeft(obj : APTR) : smallint; (* valid during MUIM_Draw *) +function OBJ_AddTop(obj : APTR) : smallint; (* valid during MUIM_Draw *) +function OBJ_SubWidth(obj : APTR) : smallint; (* valid during MUIM_Draw *) +function OBJ_SubHeight(obj : APTR) : smallint; (* valid during MUIM_Draw *) +function OBJ_MLeft(obj : APTR) : smallint; (* valid during MUIM_Draw *) +function OBJ_MTop(obj : APTR) : smallint; (* valid during MUIM_Draw *) +function OBJ_MWidth(obj : APTR) : smallint; (* valid during MUIM_Draw *) +function OBJ_MHeight(obj : APTR) : smallint; (* valid during MUIM_Draw *) +function OBJ_MRight(obj : APTR) : smallint; (* valid during MUIM_Draw *) +function OBJ_MBottom(obj : APTR) : smallint; (* valid during MUIM_Draw *) +function OBJ_Font(obj : APTR) : pTextFont; (* valid between MUIM_Setup/Cleanup *) +function OBJ_MinWidth(obj : APTR) : LongWord; (* valid between MUIM_Show/Hide *) +function OBJ_MinHeight(obj : APTR) : LongWord; (* valid between MUIM_Show/Hide *) +function OBJ_MaxWidth(obj : APTR) : LongWord; (* valid between MUIM_Show/Hide *) +function OBJ_MaxHeight(obj : APTR) : LongWord; (* valid between MUIM_Show/Hide *) +function OBJ_DefWidth(obj : APTR) : LongWord; (* valid between MUIM_Show/Hide *) +function OBJ_DefHeight(obj : APTR) : LongWord; (* valid between MUIM_Show/Hide *) +function OBJ_Flags(obj : APTR) : LongWord; + +function OBJ_Between(a,x,b : smallint): boolean; +function OBJ_IsInObject(x,y : smallint; obj : PObject_): boolean; + +function MUIV_Window_AltHeight_MinMax(p : LongInt) : LongInt; +function MUIV_Window_AltHeight_Visible(p : LongInt) : LongInt; +function MUIV_Window_AltHeight_Screen(p : LongInt) : LongInt; +function MUIV_Window_AltTopEdge_Delta(p : LongInt) : LongInt; +function MUIV_Window_AltWidth_MinMax(p : LongInt) : LongInt; +function MUIV_Window_AltWidth_Visible(p : LongInt) : LongInt; +function MUIV_Window_AltWidth_Screen(p : LongInt) : LongInt; +function MUIV_Window_Height_MinMax(p : LongInt) : LongInt; +function MUIV_Window_Height_Visible(p : LongInt) : LongInt; +function MUIV_Window_Height_Screen(p : LongInt) : LongInt; +function MUIV_Window_TopEdge_Delta(p : LongInt) : LongInt; +function MUIV_Window_Width_MinMax(p : LongInt) : LongInt; +function MUIV_Window_Width_Visible(p : LongInt) : LongInt; +function MUIV_Window_Width_Screen(p : LongInt) : LongInt; + +{ + Functions and procedures with array of const go here +} +function MUI_AllocAslRequestTags(_type : longword; const tags : Array Of Const) : Pointer; +function MUI_AslRequestTags(req : Pointer; const tags : Array Of Const) : LongBool; +function MUI_MakeObject(_type : LongInt; const params : Array Of Const) : pLongWord; +function MUI_NewObject(a0arg : pCHAR; const tags : Array Of Const) : pLongWord; +function MUI_Request(app : Pointer; win : Pointer; flags : longword; title : pCHAR; gadgets : pCHAR; format : pCHAR; const params : Array Of Const) : LongInt; + + + +{This is a variable that knows how the unit is compiled} +var + MUIMASTERIsCompiledHow : LongInt; + +implementation + +uses + tagsarray,longarray; + +function MUINotifyData(obj : APTR) : pMUI_NotifyData; +begin + MUINotifyData := pMUI_NotifyData(@p__dummyXFC2__(obj)^.mnd); +end; + +function MUIAreaData(obj : APTR) : pMUI_AreaData; +begin + MUIAreaData := pMUI_AreaData(@p__dummyXFC2__(obj)^.mad); +end; + +function MUIGlobalInfo(obj : APTR) : pMUI_GlobalInfo; +begin + MUIGlobalInfo := pMUI_GlobalInfo(p__dummyXFC2__(obj)^.mnd.mnd_GlobalInfo); +end; + +function MUIUserData(obj : APTR) : Pointer ; +begin + MUIUserData := Pointer(p__dummyXFC2__(obj)^.mnd.mnd_GlobalInfo); +end; + +function MUIRenderInfo(obj : APTR) : PMUI_RenderInfo; +begin + MUIRenderInfo := PMUI_RenderInfo(p__dummyXFC2__(obj)^.mad.mad_RenderInfo); +end; + +function MUIPen(pen : LongInt): LongInt; +begin + MUIPen := LongInt(pen*MUIPEN_Mask); +end; + +function OBJ_App(obj : APTR) : PObject_; (* valid between MUIM_Setup/Cleanup *) +begin + OBJ_App := pMUI_GlobalInfo(obj)^.mgi_ApplicationObject; +end; + +function OBJ_Win(obj : APTR) : PObject_; (* valid between MUIM_Setup/Cleanup *) +begin + OBJ_Win := PMUI_RenderInfo(obj)^.mri_WindowObject; +end; + +function OBJ_Dri(obj : APTR) : pDrawInfo; (* valid between MUIM_Setup/Cleanup *) +begin + OBJ_Dri := PMUI_RenderInfo(obj)^.mri_DrawInfo; +end; + +function OBJ_Screen(obj : APTR) : pScreen; (* valid between MUIM_Setup/Cleanup *) +begin + OBJ_Screen := PMUI_RenderInfo(obj)^.mri_Screen; +end; + +function OBJ_Pens(obj : APTR) : pWord; (* valid between MUIM_Setup/Cleanup *) +begin + OBJ_Pens := PMUI_RenderInfo(obj)^.mri_Pens; +end; + +function OBJ_Window(obj : APTR) : pWindow; (* valid between MUIM_Show/Hide *) +begin + OBJ_Window := PMUI_RenderInfo(obj)^.mri_Window; +end; + +function OBJ_Rp(obj : APTR) : pRastPort; (* valid between MUIM_Show/Hide *) +begin + OBJ_Rp := PMUI_RenderInfo(obj)^.mri_RastPort; +end; + +function OBJ_Left(obj : APTR) : smallint; (* valid during MUIM_Draw *) +begin + OBJ_Left := MUIAreaData(obj)^.mad_Box.Left; +end; + +function OBJ_Top(obj : APTR) : smallint; (* valid during MUIM_Draw *) +begin + OBJ_Top := MUIAreaData(obj)^.mad_Box.Top; +end; + +function OBJ_Width(obj : APTR) : smallint; (* valid during MUIM_Draw *) +begin + OBJ_Width := MUIAreaData(obj)^.mad_Box.Width; +end; + +function OBJ_Height(obj : APTR) : smallint; (* valid during MUIM_Draw *) +begin + OBJ_Height := MUIAreaData(obj)^.mad_Box.Height; +end; + +function OBJ_Right(obj : APTR) : smallint; (* valid during MUIM_Draw *) +begin + OBJ_Right := OBJ_Left(obj) + OBJ_Width(obj) -1; +end; + +function OBJ_Bottom(obj : APTR) : smallint; (* valid during MUIM_Draw *) +begin + OBJ_Bottom := OBJ_Top(obj) + OBJ_Height(obj) -1; +end; + +function OBJ_AddLeft(obj : APTR) : smallint; (* valid during MUIM_Draw *) +begin + OBJ_AddLeft := MUIAreaData(obj)^.mad_AddLeft; +end; + +function OBJ_AddTop(obj : APTR) : smallint; (* valid during MUIM_Draw *) +begin + OBJ_AddTop := MUIAreaData(obj)^.mad_AddTop; +end; + +function OBJ_SubWidth(obj : APTR) : smallint; (* valid during MUIM_Draw *) +begin + OBJ_SubWidth := MUIAreaData(obj)^.mad_SubWidth; +end; + +function OBJ_SubHeight(obj : APTR) : smallint; (* valid during MUIM_Draw *) +begin + OBJ_SubHeight := MUIAreaData(obj)^.mad_SubHeight; +end; + +function OBJ_MLeft(obj : APTR) : smallint; (* valid during MUIM_Draw *) +begin + OBJ_MLeft := OBJ_Left(obj) + OBJ_AddLeft(obj); +end; + +function OBJ_MTop(obj : APTR) : smallint; (* valid during MUIM_Draw *) +begin + OBJ_MTop := OBJ_Top(obj) + OBJ_AddTop(obj); +end; + +function OBJ_MWidth(obj : APTR) : smallint; (* valid during MUIM_Draw *) +begin + OBJ_MWidth := OBJ_Width(obj) -OBJ_SubWidth(obj); +end; + +function OBJ_MHeight(obj : APTR) : smallint; (* valid during MUIM_Draw *) +begin + OBJ_MHeight := OBJ_Height(obj) - OBJ_SubHeight(obj); +end; + +function OBJ_MRight(obj : APTR) : smallint; (* valid during MUIM_Draw *) +begin + OBJ_MRight := OBJ_MLeft(obj) + OBJ_MWidth(obj) -1; +end; + +function OBJ_MBottom(obj : APTR) : smallint; (* valid during MUIM_Draw *) +begin + OBJ_MBottom := OBJ_MTop(obj) + OBJ_MHeight(obj) -1; +end; + +function OBJ_Font(obj : APTR) : pTextFont; (* valid between MUIM_Setup/Cleanup *) +begin + OBJ_Font := MUIAreaData(obj)^.mad_Font; +end; + +function OBJ_MinWidth(obj : APTR) : LongWord; (* valid between MUIM_Show/Hide *) +begin + OBJ_MinWidth := MUIAreaData(obj)^.mad_MinMax.MinWidth; +end; + +function OBJ_MinHeight(obj : APTR) : LongWord; (* valid between MUIM_Show/Hide *) +begin + OBJ_MinHeight := MUIAreaData(obj)^.mad_MinMax.MinHeight; +end; + +function OBJ_MaxWidth(obj : APTR) : LongWord; (* valid between MUIM_Show/Hide *) +begin + OBJ_maxWidth := MUIAreaData(obj)^.mad_MinMax.MaxWidth; +end; + +function OBJ_MaxHeight(obj : APTR) : LongWord; (* valid between MUIM_Show/Hide *) +begin + OBJ_maxHeight := MUIAreaData(obj)^.mad_MinMax.MaxHeight; +end; + +function OBJ_DefWidth(obj : APTR) : LongWord; (* valid between MUIM_Show/Hide *) +begin + OBJ_DefWidth := MUIAreaData(obj)^.mad_MinMax.DefWidth; +end; + +function OBJ_DefHeight(obj : APTR) : LongWord; (* valid between MUIM_Show/Hide *) +begin + OBJ_DefHeight := MUIAreaData(obj)^.mad_MinMax.DefHeight; +end; + +function OBJ_Flags(obj : APTR) : LongWord; +begin + OBJ_Flags := MUIAreaData(obj)^.mad_Flags; +end; + +(* +** 2 useful procedures for testing if some coordinates are inside your object +** (converted from the ones in class3.c. So look there how to use... ) +*) + +function OBJ_Between(a,x,b : smallint): boolean; +begin + OBJ_Between := ((x>=a) and (x<=b)); +end; + +function OBJ_IsInObject(x,y : smallint; obj : PObject_): boolean; +begin + OBJ_IsInObject := (OBJ_Between(OBJ_MLeft(obj),x,OBJ_MRight(obj)) + and OBJ_Between(OBJ_MTop(obj),y,OBJ_MBottom(obj))); +end; + +function MUIV_Window_AltHeight_MinMax(p : LongInt) : LongInt; +begin + MUIV_Window_AltHeight_MinMax := (0 - p); +end; + +function MUIV_Window_AltHeight_Visible(p : LongInt) : LongInt; +begin + MUIV_Window_AltHeight_Visible := (-100 - (p)); +end; + +function MUIV_Window_AltHeight_Screen(p : LongInt) : LongInt; +begin + MUIV_Window_AltHeight_Screen := (-200 - (p)); +end; + +function MUIV_Window_AltTopEdge_Delta(p : LongInt) : LongInt; +begin + MUIV_Window_AltTopEdge_Delta := (-3 - (p)); +end; + +function MUIV_Window_AltWidth_MinMax(p : LongInt) : LongInt; +begin + MUIV_Window_AltWidth_MinMax := 0 - p; +end; + +function MUIV_Window_AltWidth_Visible(p : LongInt) : LongInt; +begin + MUIV_Window_AltWidth_Visible := (-100 - (p)); +end; + +function MUIV_Window_AltWidth_Screen(p : LongInt) : LongInt; +begin + MUIV_Window_AltWidth_Screen := (-200 - (p)); +end; + +function MUIV_Window_Height_MinMax(p : LongInt) : LongInt; +begin + MUIV_Window_Height_MinMax := 0 - p; +end; + +function MUIV_Window_Height_Visible(p : LongInt) : LongInt; +begin + MUIV_Window_Height_Visible := (-100 - (p)); +end; + +function MUIV_Window_Height_Screen(p : LongInt) : LongInt; +begin + MUIV_Window_Height_Screen := (-200 - (p)); +end; + +function MUIV_Window_TopEdge_Delta(p : LongInt) : LongInt; +begin + MUIV_Window_TopEdge_Delta := (-3 - (p)); +end; + +function MUIV_Window_Width_MinMax(p : LongInt) : LongInt; +begin + MUIV_Window_Width_MinMax := 0 - p; +end; + +function MUIV_Window_Width_Visible(p : LongInt) : LongInt; +begin + MUIV_Window_Width_Visible := (-100 - (p)); +end; + +function MUIV_Window_Width_Screen(p : LongInt) : LongInt; +begin + MUIV_Window_Width_Screen := (-200 - (p)); +end; + +{ + Functions and procedures with array of const go here +} +function MUI_AllocAslRequestTags(_type : longword; const tags : Array Of Const) : Pointer; +begin + MUI_AllocAslRequestTags := MUI_AllocAslRequest(_type , readintags(tags)); +end; + +function MUI_AslRequestTags(req : Pointer; const tags : Array Of Const) : LongBool; +begin + MUI_AslRequestTags := MUI_AslRequest(req , readintags(tags)); +end; + +function MUI_MakeObject(_type : LongInt; const params : Array Of Const) : pLongWord; +begin + MUI_MakeObject := MUI_MakeObjectA(_type , readinlongs(params)); +end; + +function MUI_NewObject(a0arg : pCHAR; const tags : Array Of Const) : pLongWord; +begin + MUI_NewObject := MUI_NewObjectA(a0arg , readintags(tags)); +end; + +function MUI_Request(app : Pointer; win : Pointer; flags : longword; title : pCHAR; gadgets : pCHAR; format : pCHAR; const params : Array Of Const) : LongInt; +begin + MUI_Request := MUI_RequestA(app , win , flags , title , gadgets , format , readintags(params)); +end; + +const + { Change VERSION and LIBVERSION to proper values } + + VERSION : string[2] = '0'; + LIBVERSION : longword = 0; + +initialization + MUIMasterBase := OpenLibrary(MUIMASTER_NAME,LIBVERSION); +finalization + CloseLibrary(MUIMasterBase); +end.