wiki:Documentation/API/MUI_Area

Area.mui

Super class

Notify.mui

Inherited by

Balance.mui
Bitmap.mui
Colorfield.mui
Dtpic.mui
Gadget.mui
Gauge.mui
Group.mui
Image.mui
List.mui
Numeric.mui
Pendisplay.mui
Pixmap.mui
Rectangle.mui
Scale.mui
String.mui
Text.mui

Background

Area class is a super class for every other MUI class except windows and applications. It holds information about an object's current position, size and weight and manages frames, fonts and backgrounds.

Additionally, Area class handles the user input. By setting an object's MUIA_InputMode, you can make it behave like a button or like a toggle gadget. That's why MUI doesn't offer an extra button class. A button is simply a text object with a raised frame and a relverify input mode. Since especially group class is a subclass of Area class, you can create rather complex buttons consisting of many other display elements.

Attributes

Attribute Version ISG Type
MUIA_Background V4IS.LONG
MUIA_BottomEdge V4..GLONG
MUIA_ContextMenu V11ISGObject *
MUIA_ContextMenuHook V20ISGstruct Hook *
MUIA_ContextMenuTrigger V11..GObject *
MUIA_ControlChar V4ISGchar
MUIA_CycleChain V11ISGLONG
MUIA_Disabled V4ISGBOOL
MUIA_DoubleBuffer V20ISGBOOL
MUIA_DoubleClick V20..GBOOL
MUIA_Draggable V11ISGBOOL
MUIA_Dropable V11ISGBOOL
MUIA_ExportID V4ISGULONG (OBSOLETE)
MUIA_FillArea V4IS.BOOL
MUIA_FixHeight V4I..LONG
MUIA_FixHeightTxt V4I..STRPTR
MUIA_FixWidth V4I..LONG
MUIA_FixWidthTxt V4I..STRPTR
MUIA_Floating V20ISGBOOL
MUIA_Font V4I.Gstruct TextFont *
MUIA_Frame V4I..LONG
MUIA_FrameDynamic V20ISGBOOL
MUIA_FramePhantomHoriz V4I..BOOL
MUIA_FrameTitle V4ISGSTRPTR
MUIA_FrameVisible V20ISGBOOL
MUIA_Height V4..GLONG
MUIA_HorizDisappear V11ISGLONG
MUIA_HorizWeight V4ISGWORD
MUIA_InnerBottom V4I.GLONG
MUIA_InnerLeft V4I.GLONG
MUIA_InnerRight V4I.GLONG
MUIA_InnerTop V4I.GLONG
MUIA_InputMode V4I..LONG
MUIA_KnowsDisabled V20ISGBOOL
MUIA_LeftEdge V4..GLONG
MUIA_MaxHeight V11I..LONG
MUIA_MaxWidth V11I..LONG
MUIA_MinHeight V20I..LONG
MUIA_MinWidth V20I..LONG
MUIA_PointerType V20ISGLONG
MUIA_Pressed V4..GBOOL
MUIA_RightEdge V4..GLONG
MUIA_Selected V4ISGBOOL
MUIA_ShortHelp V11ISGSTRPTR
MUIA_ShowMe V4ISGBOOL
MUIA_ShowSelState V4I..BOOL
MUIA_Timer V4..GLONG
MUIA_TopEdge V4..GLONG
MUIA_VertDisappear V11ISGLONG
MUIA_VertWeight V4ISGWORD
MUIA_Weight V4I..WORD
MUIA_Width V4..GLONG
MUIA_Window V4..Gstruct Window *
MUIA_WindowObject V4..GObject *


Methods

Method Version
MUIM_AskMinMax V4
MUIM_Cleanup V4
MUIM_ContextMenuAdd V20
MUIM_ContextMenuBuild V11
MUIM_ContextMenuChoice V11
MUIM_CreateBubble V18
MUIM_CreateDragImage V18
MUIM_CreateShortHelp V11
MUIM_DeleteBubble V18
MUIM_DeleteDragImage V18
MUIM_DeleteShortHelp V11
MUIM_DoDrag V20
MUIM_DragBegin V11
MUIM_DragDrop V11
MUIM_DragEvent V20
MUIM_DragFinish V11
MUIM_DragQuery V11
MUIM_DragReport V11
MUIM_Draw V4
MUIM_DrawBackground V11
MUIM_DrawBackgroundParent V20
MUIM_HandleEvent V16
MUIM_HandleInput V4
MUIM_Hide V4
MUIM_Layout V4
MUIM_Relayout V21
MUIM_Setup V4
MUIM_Show V4
MUIM_Text V20
MUIM_TextDim V20
MUIM_UpdateConfig V20
MUIM_WhichPointerType V20


MUIA_Background

NAME

MUIA_Background — V4 [IS.], LONG, 0x8042545b

FUNCTION

Adjust the background for an object.

Every MUI object has its own background setting. The background is displayed "behind" the actual object contents, e.g. behind a the text of a text object or behind the image of an image object.

This attribute takes the same values as MUIA_Image_Spec, please refer to Autodocs of image class for a complete description.

An object without a specific background setting will inherit the pattern from its parent group (1). The default background for a window and many other background patterns are adjustable with the preferences program.

Only a few MUII_xxxxxxx tags make sense as background. Important are:

MUII_ButtonBack
You have to set this when you create a button gadget. Thus, your button will be displayed in the users preferred style.
MUII_TextBack
Set this when you create a text object with a TextFrame, e.g. some kind of status line. Do NOT use MUII_TextBack for simple text without frame (e.g. gadget labels).
MUII_BACKGROUND
MUII_SHADOW
MUII_SHINE
MUII_FILL
MUII_SHADOWBACK
MUII_SHADOWFILL
MUII_SHADOWSHINE
MUII_FILLBACK
MUII_FILLSHINE
MUII_SHINEBACK
MUII_SHINEBACK2
One of MUI's predefined pattern. These are not configurable by the user and will always look the same.

Note: It is important that you test your programs with a fancy pattern configuration. With the default setting you won't notice any errors in your backgrounds.

(1) In case the object had a background already then the background inheritance can be activated by setting MUIA_Background to an empty string "" (as opposed to NULL which will make the object use the window's backfill as background in any case).

SEE ALSO

MUIA_Image_Spec

MUIA_BottomEdge

NAME

MUIA_BottomEdge — V4 [..G], LONG, 0x8042e552

FUNCTION

You can use this to read the current position and dimension of an object, if you e.g. need it to pop up some requester below.

Of course, this attribute is only valid when the parent window of the object is currently open.

SEE ALSO

MUIA_TopEdge, MUIA_Width, MUIA_Height, MUIA_RightEdge, MUIA_LeftEdge

MUIA_ContextMenu

NAME

MUIA_ContextMenu — V11 [ISG], Object *, 0x8042b704

FUNCTION

Specifies a context sensitive popup menu for the current object. For MUI, popup menus are nothing else but standard menus, so you must specify a pointer to a MUI menustrip object (e.g. something returned from MUI_MakeObject(MUIO_MenustripNM,…)) here.

Whenever the user hits the RMB and the mouse is above the parent object, MUI will present the popup menu instead of the windows menu.

Note: MUI will NOT dispose the MUIA_ContextMenu object when the object is disposed. You must take care of the menustrip object yourself. This is because menustrip objects in MUIA_ContextMenu do not actually "belong" to their parent objects, they're just a "reference". You are allowed to use a single menustrip object as MUIA_ContextMenu for different objects of the same window. Do NOT share with objects in other windows or with the default menu of a window or an application!

If the user selects an item, the object will receive a MUIM_ContextMenuChoice method containing the selected menuitem object. If you build your menustrip tree with MUI_MakeObject(MUIO_MenustripNM,…), you will find the nm_UserData of your menu entry in muiUserData(msg→item). If you have control over methods because you are a subclass, you can immediately take approriate actions when receiving MUIM_ContextMenuChoice.

If you don't have a subclass or don't override MUIM_ContextMenuChoice, the method will finally reach Area class and will set the attribute MUIA_ContextMenuTrigger to the appropriate menuitem object. This allows you to react on context menu selections by simple notification and eliminates the need of writing a subclass just for this purpose. Subclasses are always the better solution though!

There is also a possibility to dynamically create popup menus on the fly. See MUIM_ContextMenuBuild for details.

NOTES

MUI uses the same tree-like technique as always (e.g. with drag&drop) to find out which context menu to use on a certain mouse position. This allows you to have a context menu for a group and different context menus for its children. The MUI preferences program makes use of that feature by allowing to control a single gadget or a whole page of gadgets with popup menus.

SEE ALSO

MUIA_ContextMenuHook, MUIA_ContextMenuTrigger, MUIM_ContextMenuChoice, MUIM_ContextMenuBuild

MUIA_ContextMenuHook

NAME

MUIA_ContextMenuHook — V20 [ISG], struct Hook *, 0x80427c6e

FUNCTION

Specifies a hook function to return a context sensitive popup menu for the current object. The hook function gets the current object and a pointer to a struct MUIP_ContextMenuBuild structure passed as parameters to dynamically return different menu objects depending on the object and on the current mouse position. In addition MUIA_ContextMenu MUST be set to TRUE to basically enable context menu support for the object.

Note: MUI will NOT dispose the returned menu object when the object is disposed. You must take care of the menustrip object yourself. This is because menustrip objects from MUIA_ContextMenuHook do not actually "belong" to their parent objects, they're just a "reference". You are allowed to return a single menustrip object from the hook for different objects of the same window. Do NOT share with objects in other windows or with the default menu of a window or an application!

EXAMPLE

ASM Object *ctxmenuFunc(REG(a0, struct Hook *hook),
                        REG(a2, Object *obj),
                        REG(a1, struct MUIP_ContextMenuBuild *msg))
{
  // return a context menu for a specific object
  if(obj == specialObject)
    return specialMenu;

  // "obj" always refers to the object the mouse is currently
  // hovering over. Hence the mouse coordinates are guaranteed
  // to be within the object's realm.

  // return different context menu object for the object's left
  // and right half
  if(msg->mx <= _left(obj)+_width(obj)/2)
    return leftSideMenu;
  else
    return rightSideMenu;
}

[...]
struct Hook ctxmenuHook;
Object *myobj;

memset(&ctxmenuHook, 0, sizeof(struct ctxmenuHook));
ctxmenuHook.h_Entry = (HOOKFUNC)ctxmenuFunc;

myobj = MUI_NewObject("fooclass",
  MUIA_ContextMenu, TRUE,
  MUIA_ContextMenuHook, &ctxmenuHook,
  TAG_DONE);

SEE ALSO

MUIA_ContextMenu, MUIA_ContextMenuTrigger, MUIM_ContextMenuBuild

MUIA_ContextMenuTrigger

NAME

MUIA_ContextMenuTrigger — V11 [..G], Object *, 0x8042a2c1

FUNCTION

Allows reacting on context menus with notificaton. When the MUIM_ContextMenuChoice method reaches Area class because you did not override it in a subclass, it sets MUIA_ContextMenuTrigger to the received parameter which is a pointer to the user-selected menuitem object.

See MUIA_ContextMenu for details.

SEE ALSO

MUIA_ContextMenu, MUIM_ContextMenuChoice, MUIM_ContextMenuBuild

MUIA_ControlChar

NAME

MUIA_ControlChar — V4 [ISG], char, 0x8042120b

FUNCTION

Pressing the control char will have the same effect as pressing return if the object was active.

This can be used to create old style key shortcuts.

Note: Using an uppercase control char will force the user to press shift.

SEE ALSO

mui.h / KeyButton() macro

MUIA_CycleChain

NAME

MUIA_CycleChain — V11 [ISG], LONG, 0x80421ce7

FUNCTION

MUI 3 introduces a new keyboard cycle chain system. All you have to do is to set MUIA_CycleChain to 1 for every object that you want to have in your chain, MUI does the rest automatically. The old MUIM_Window_SetCycleChain will continue to work but is considered obsolete.

SEE ALSO

MUIM_Window_SetCycleChain

MUIA_Disabled

NAME

MUIA_Disabled — V4 [ISG], BOOL, 0x80423661

FUNCTION

Disable or enable a gadget. Setting this attribute causes a gadget to become disabled, it gets a ghost pattern and doesn't respond to user input any longer.

Disabled gadgets cannot be activated with the TAB key.

Using MUIA_Disable on a group of objects will disable all objects within that group.

EXAMPLE

/* we have a radio button gadget with three         */
/* entries, the third should enable a string gadget */
/* with additional parameters                       */

DoMethod(radio, MUIM_Notify, MUIA_Radio_Active, 0,
  string, 3, MUIM_Set,
  MUIA_Disabled, TRUE);

DoMethod(radio, MUIM_Notify, MUIA_Radio_Active, 1,
  string, 3, MUIM_Set,
  MUIA_Disabled, TRUE);

DoMethod(radio, MUIM_Notify, MUIA_Radio_Active, 2,
  string, 3, MUIM_Set,
  MUIA_Disabled, FALSE);



MUIA_DoubleBuffer

NAME

MUIA_DoubleBuffer — V20 [ISG], BOOL, 0x8042a9c7

FUNCTION

Setting this to TRUE will enable a doublebuffer for this objects MUIM_Draw method.

When MUI is about to draw an object with this attribute, it will maintain an extra struct MUI_RenderInfo which points to an offscreen bitmap. Just before calling MUIM_Draw, your object's normal muiRenderInfo(obj) pointer (which stores drawing attributes such as _rp(obj) for example) will be replaced by this buffered MUI_RenderInfo. Also, your object's coordinates (_mleft(obj), _mtop(obj), etc) will be changed to point into the offscreen buffer.

Your MUIM_Draw method can then render as it would normally do, there is no need to change anything for the doublebuffer. When it is completed, MUI will blit the contents of the offscreen-bitmap into view and then restore your object's coordinates and MUI_RenderInfo pointers to their standard values.

NOTES

This attribute is ONLY meant for your own subclasses of Area class. Don't use it on subclasses of Group.mui or on other classes not written by you.

You must absolutely make sure to not render outside your object's bounding box, always stay between _mleft/_mtop/_mright/_bottom. Otherwise you will trash innocent memory since the offscreen bitmap may just be big enough and has no clipping enabled.

Special care must be taken when your classes draw method interfaces other coordinates, like for example the mouse-position. You would have to substract _left/_top in MUIM_HandleEvent from imsg→MouseX/Y before storing the coordinates (ie make them relative to your objects origin) and then, when using them in your MUIM_Draw method, add _left/_top(obj) again. This will ensure everything ends up at its place regardless if you use MUIA_DoubleBuffer or don't.

IMPORTANT: MUI may also use different methods of double buffering, besides allocating new bitmap structures. It may for example decide to do nothing at all when it finds out, that the underlying intuition/layer libraries already implement buffering.

You CANNOT make any assumptions about the double buffer, its bitmap, its coordinates, its lifetime or anything else. Your rendering code must work just as flawlessly with MUIA_DoubleBuffer=TRUE as with MUIA_DoubleBuffer=FALSE.

MUIA_DoubleClick

NAME

MUIA_DoubleClick — V20 [..G], BOOL, 0x8042f057

FUNCTION

This attribute will be set to TRUE whenever a double click on the object is detected. The most appropriate use is in notifications only.

MUIA_Draggable

NAME

MUIA_Draggable — V11 [ISG], BOOL, 0x80420b6e

FUNCTION

Set this if you want the complete object to be dragable for D&D operations.

MUIA_Dropable

NAME

MUIA_Dropable — V11 [ISG], BOOL, 0x8042fbce

FUNCTION

Only objects with this attribute set to TRUE will be asked if they want to become an active Drag & Drop destination at all. Though this attribute defaults to TRUE, this doesn't mean that every object automatically accepts D&D actions, because the MUIM_DragQuery method is answered FALSE when it arrives at Area class.

SEE ALSO

MUIM_DragQuery

MUIA_ExportID

NAME

MUIA_ExportID — V4 [ISG], ULONG, 0x8042d76e (OBSOLETE)

FUNCTION

obsolete. see Notify.mui/MUIA_ObjectID

NOTES

This attribute was renamed to MUIA_ObjectID and moved to Notify.mui in muimaster.library V12.

SEE ALSO

MUIA_ObjectID, MUIM_Application_Load, MUIM_Application_Save

MUIA_FillArea

NAME

MUIA_FillArea — V4 [IS.], BOOL, 0x804294a3

FUNCTION

Set this to FALSE if you are a custom class and don't want Area class to clear your background during the DoSuperMethod() in your MUIM_Draw method. Note that if you set this, your MUIM_Draw method is responsible for filling every pixel of your objects rectangle, otherwise some display trash will remain there.

MUIA_FixHeight

NAME

MUIA_FixHeight — V4 [I..], LONG, 0x8042a92b

FUNCTION

Give your object a fixed pixel height. This tag is absolutely not needed in a general MUI application and only present for emergency situations. Please think twice before using it!

EXAMPLE

/* create an 8x8 pixel rectangle with FILLPEN */

RectangleObject,
  MUIA_FixWidth  , 8,
  MUIA_FixHeight , 8,
  MUIA_Background, MUII_FILL,
  End;

SEE ALSO

MUIA_FixWidth, MUIA_FixWidthTxt, MUIA_FixHeightTxt

MUIA_FixHeightTxt

NAME

MUIA_FixHeightTxt — V4 [I..], STRPTR, 0x804276f2

FUNCTION

Give your object a fixed pixel height. The height will match the height of the given string. This tag is absolutely not needed in a general MUI application and only present for emergency situations. Please think twice before using it!

EXAMPLE

/* create a fixed size rectangle with FILLPEN */

RectangleObject,
  MUIA_FixWidthTxt , "00:00:00",
  MUIA_FixHeightTxt, "\n\n",
  MUIA_Background  , MUII_FILL,
  End;

SEE ALSO

MUIA_FixHeight, MUIA_FixWidth, MUIA_FixWidthTxt

MUIA_FixWidth

NAME

MUIA_FixWidth — V4 [I..], LONG, 0x8042a3f1

FUNCTION

Give your object a fixed pixel width. This tag is absolutely not needed in a general MUI application and only present for emergency situations. Please think twice before using it!

EXAMPLE

/* create an 8x8 pixel rectangle with FILLPEN */

RectangleObject,
  MUIA_FixWidth  , 8,
  MUIA_FixHeight , 8,
  MUIA_Background, MUII_FILL,
  End;

SEE ALSO

MUIA_FixHeight, MUIA_FixWidthTxt, MUIA_FixHeightTxt

MUIA_FixWidthTxt

NAME

MUIA_FixWidthTxt — V4 [I..], STRPTR, 0x8042d044

FUNCTION

Give your object a fixed pixel width. The width will match the width of the given string. This tag is absolutely not needed in a general MUI application and only present for emergency situations. Please think twice before using it!

EXAMPLE

/* create a fixed size rectangle with FILLPEN */

RectangleObject,
  MUIA_FixWidthTxt , "00:00:00",
  MUIA_FixHeightTxt, "\n\n",
  MUIA_Background  , MUII_FILL,
  End;

SEE ALSO

MUIA_FixHeight, MUIA_FixWidth, MUIA_FixHeightTxt

MUIA_Floating

NAME

MUIA_Floating — V20 [ISG], BOOL, 0x80429753

FUNCTION

Usually every MUI object will be layouted and drawn in exactly the same sequence as it has been constructed along with other objects. Floating objects however will be layouted and drawn after all other objects to make sure they appear in front of all other objects in case they overlap. Such object's classes should implement MUIM_Layout to ensure a proper layout.

EXAMPLE

obj1 = ExampleObject,
  MUIA_Floating, TRUE,
  End,
obj2 = ExampleObject,
  MUIA_Floating, FALSE,
  End,
  ...

In this scenario obj1 will be layouted and drawn after obj2, although it was created earlier.

SEE ALSO

MUIM_Layout

MUIA_Font

NAME

MUIA_Font — V4 [I.G], struct TextFont *, 0x8042be50

SPECIAL INPUTS

  • MUIV_Font_Inherit
  • MUIV_Font_Normal
  • MUIV_Font_List
  • MUIV_Font_Tiny
  • MUIV_Font_Fixed
  • MUIV_Font_Title
  • MUIV_Font_Big
  • MUIV_Font_Button
  • MUIV_Font_Slider
  • MUIV_Font_Gauge
  • MUIV_Font_Menu
  • MUIV_Font_Tab
  • MUIV_Font_Bubble
  • MUIV_Font_Last
  • MUIV_Font_Count

FUNCTION

Every MUI object can have its own font, just set it with this tag. Objects without an explicit font setting will inherit it from their parent group.

You normally won't need to open a font yourself, just use one of the predefined values to get a font from the users preferences.

You can also pass a struct TextFont * obtained by OpenFont(). You are responsible for freeing this font yourself after the object is disposed.

EXAMPLE

/* since the text contains tabs,           */
/* use the fixed width font for displaying */

msgread = FloattextObject,
 MUIA_Font, MUIV_Font_Fixed,
 ...,
 End;



MUIA_Frame

NAME

MUIA_Frame — V4 [I..], LONG, 0x8042ac64

SPECIAL INPUTS

  • MUIV_Frame_None
  • MUIV_Frame_Button
  • MUIV_Frame_ImageButton
  • MUIV_Frame_Text
  • MUIV_Frame_String
  • MUIV_Frame_ReadList
  • MUIV_Frame_InputList
  • MUIV_Frame_Prop
  • MUIV_Frame_Gauge
  • MUIV_Frame_Group
  • MUIV_Frame_PopUp
  • MUIV_Frame_Virtual
  • MUIV_Frame_Slider
  • MUIV_Frame_SliderKnob
  • MUIV_Frame_GaugeInner
  • MUIV_Frame_Menudisplay
  • MUIV_Frame_MenudisplayMenu
  • MUIV_Frame_PropKnob
  • MUIV_Frame_Window
  • MUIV_Frame_Requester
  • MUIV_Frame_Page
  • MUIV_Frame_Register
  • MUIV_Frame_GroupTitle
  • MUIV_Frame_RegisterTitle
  • MUIV_Frame_Count

FUNCTION

Define a frame for the current object. Since Area class is a superclass for all elements in a window, you can assign frames to every object you wish.

You don't adjust the style of your frame directly, instead you only specify a type:

MUIV_Frame_Button
for standard buttons with text in it.
MUIV_Frame_ImageButton
for small buttons with images, e.g. the arrows of a scrollbar.
MUIV_Frame_Text
for a text field, e.g. a status line display.
MUIV_Frame_String
for a string gadget.
MUIV_Frame_ReadList
for a read only list.
MUIV_Frame_InputList
for a list that handles input (has a cursor).
MUIV_Frame_Prop
for proportional gadgets.
MUIV_Frame_Group
for groups.

How the frame is going to look is adjustable via the preferences program.

Four spacing values belong to each frame that tell MUI how many pixels should be left free between the frame and its contents. These spacing values are also user adjustable as long as you don't override them with one of MUIA_InnerLeft, MUIA_InnerRight, MUIA_InnerTop or MUIA_InnerBottom.

Starting with version 20 of muimaster.library, you can also pass a pointer to a struct MUI_FrameSpec as MUIA_Frame. This allows the use of customized frames adjustable with the Frameadjust.mui custom class. Note that the pointer to the passed MUI_FrameSpec must remain valid until you overwrite MUIA_Frame with something different or dispose the object. A good place to keep the MUI_FrameSpec is the instance data of your custom class.

Do not pass such pointers if your muimaster.library is version 19 or below!

NOTES

The first object in a window (MUIA_Window_RootObject) can NOT have a frame. If you need this you will have to create a dummy group with just one child.

EXAMPLE

strobj = StringObject,
  MUIA_Frame, MUIV_Frame_String,
  End;

SEE ALSO

MUIA_InnerLeft, MUIA_InnerRight, MUIA_InnerTop, MUIA_InnerBottom

MUIA_FrameDynamic

NAME

MUIA_FrameDynamic — V20 [ISG], BOOL, 0x804223c9

FUNCTION

This attribute defines whether the object's frame will be dynamically visible or not. If set to TRUE the frame will be made visible as soon as the mouse pointer is over the object and made invisible when the mouse leaves the object. Best use the attribute together with MUIA_FrameVisible set to FALSE to make the frame invisible by default.

Defaults to FALSE.

SEE ALSO

MUIA_Frame, MUIA_FrameVisible

MUIA_FramePhantomHoriz

NAME

MUIA_FramePhantomHoriz — V4 [I..], BOOL, 0x8042ed76

FUNCTION

Setting this to TRUE causes the specified frame to be a horizontal phantom frame. The frame will not appear but its vertical components (frame height, inner top and inner bottom spacing) will be used to calculate positions and dimensions (horizontal components are treated as 0).

This is extremely useful for a correct labeling of objects. You would e.g. label a string gadget by using a text object with a phantom string frame. Thus, the label text will be always on the same vertical position as the string gadget text, no matter what spacing values the user configured.

SEE ALSO

Label() macros in "mui.h".

MUIA_FrameTitle

NAME

MUIA_FrameTitle — V4 [ISG], STRPTR, 0x8042d1c7

FUNCTION

This tag identifies a text string that will be displayed in the top line of a frame. This can come in handy if you want to name groups of objects.

You may not use MUIA_FrameTitle without defining a MUIA_Frame.

EXAMPLE

VGroup,
  MUIA_Frame, MUIV_Frame_Group,
  MUIA_FrameTitle, "Spacing",
  ...

SEE ALSO

MUIA_Frame

MUIA_FrameVisible

NAME

MUIA_FrameVisible — V20 [ISG], BOOL, 0x80426498

FUNCTION

This attribute defines whether the object's frame will be visible or not, no matter which kind of frame is set.

Defaults to TRUE.

SEE ALSO

MUIA_Frame, MUIA_FrameDynamic

MUIA_Height

NAME

MUIA_Height — V4 [..G], LONG, 0x80423237

FUNCTION

You can use this to read the current position and dimension of an object, if you e.g. need it to pop up some requester below.

Of course, this attribute is only valid when the parent window of the object is currently open.

SEE ALSO

MUIA_TopEdge, MUIA_Width, MUIA_LeftEdge, MUIA_RightEdge, MUIA_BottomEdge

MUIA_HorizDisappear

NAME

MUIA_HorizDisappear — V11 [ISG], LONG, 0x80429615

FUNCTION

Objects with a disappear level disappear automatically when their parent window gets too small to display them. Use this for things that make your GUI look nicer (e.g. Imagery) but are not absolutely necessary.

By using disappearing objects, you can make nice GUIs which still work on crappy 640x200 screens.

You can give horizontal or vertical disappear levels to objects which are used for horizontal or vertical layout calculations respectively.

Objects with a small disappear level disappear before objects with a big disappear level.

EXAMPLE

// group with objects disappearing from right to left,
// like a row of hotlink buttons in a browser:

// creation:
quickies = HGroup, End;

// add a few buttons:
for(i=0;i<20;i++)
{
  char buf[256];

  snprintf(buf, sizeof(buf), "Quicklink %ld", i);
  DoMethod(quickies, OM_ADDMEMBER, SimpleButton(buf));
}

// set up the disappear levels, right one goes first
int dis; Object *but;
get(quickies,MUIA_Group_ChildCount,&dis);
for(but=NULL; but=(Object *)DoMethod(quickies, MUIM_Group_GetChild, MUIV_Group_GetChild_Next, but);)
{
  SetAttrs(but, MUIA_HorizDisappear, dis--, TAG_DONE);
}

SEE ALSO

MUIA_VertDisappear, MUIM_Group_GetChild

MUIA_HorizWeight

NAME

MUIA_HorizWeight — V4 [ISG], WORD, 0x80426db9

FUNCTION

Adjust the horizontal weight of an object. Usually you can simply use MUIA_Weight instead of this tag but in some two-dimensional groups it may become handy to have different horizontal and vertical weights.

SEE ALSO

MUIA_Weight

MUIA_InnerBottom

NAME

MUIA_InnerBottom — V4 [I.G], LONG, 0x8042f2c0

FUNCTION

Adjust the space between an object and its frame. Usually you shouldn't use this tag since you will override the user's preferred default setting.

SEE ALSO

MUIA_Frame

MUIA_InnerLeft

NAME

MUIA_InnerLeft — V4 [I.G], LONG, 0x804228f8

FUNCTION

Adjust the space between an object and its frame. Usually you shouldn't use this tag since you will override the user's preferred default setting.

SEE ALSO

MUIA_Frame

MUIA_InnerRight

NAME

MUIA_InnerRight — V4 [I.G], LONG, 0x804297ff

FUNCTION

Adjust the space between an object and its frame. Usually you shouldn't use this tag since you will override the user's preferred default setting.

SEE ALSO

MUIA_Frame

MUIA_InnerTop

NAME

MUIA_InnerTop — V4 [I.G], LONG, 0x80421eb6

FUNCTION

Adjust the space between an object and its frame. Usually you shouldn't use this tag since you will override the user's preferred default setting.

SEE ALSO

MUIA_Frame

MUIA_InputMode

NAME

MUIA_InputMode — V4 [I..], LONG, 0x8042fb04

SPECIAL INPUTS

  • MUIV_InputMode_None
  • MUIV_InputMode_RelVerify
  • MUIV_InputMode_Immediate
  • MUIV_InputMode_Toggle

FUNCTION

Adjust the input mode for an object.

MUI has no distinct button class. Instead you can make every object (even groups) behave like a button by setting an input mode for them. Several input modes are available:

MUIV_InputMode_None
No input, this is not a gadget.
MUIV_InputMode_RelVerify
For buttons and similar stuff.
MUIV_InputMode_Immediate
Used e.g. in a radio button object.
MUIV_InputMode_Toggle
For things like checkmark gadgets.

The input mode setting determines how a user action will trigger the attributes MUIA_Selected, MUIA_Pressed and MUIA_Timer. See their documentation for details.

EXAMPLE

/* A traditional button, just a text object with */
/* a button frame and a relverify input mode:    */

okbutton = TextObject,
  MUIA_Frame        , MUIV_Frame_Button,
  MUIA_InputMode    , MUIV_InputMode_RelVerify,
  MUIA_Text_Contents, "OK",
  ...

SEE ALSO

MUIA_Selected, MUIA_Timer, MUIA_Pressed

MUIA_KnowsDisabled

NAME

MUIA_KnowsDisabled — V20 [ISG], BOOL, 0x8042deef

FUNCTION

Usually MUI will take care to draw a suitable disable pattern for objects which have MUIA_Disabled set to TRUE. However, if your class knows a special way to indicate the disabled state in a different way then set this attribute to TRUE. MUI will then no longer apply its own disabled pattern for this object.

SEE ALSO

MUIA_Disabled

MUIA_LeftEdge

NAME

MUIA_LeftEdge — V4 [..G], LONG, 0x8042bec6

FUNCTION

You can use this to read the current position and dimension of an object, if you e.g. need it to pop up some requester below.

Of course, this attribute is only valid when the parent window of the object is currently open.

SEE ALSO

MUIA_TopEdge, MUIA_Width, MUIA_Height, MUIA_RightEdge, MUIA_BottomEdge

MUIA_MaxHeight

NAME

MUIA_MaxHeight — V11 [I..], LONG, 0x804293e4

FUNCTION

Specify a maximum height for an object (in pixels).

SEE ALSO

MUIA_MaxWidth, MUIA_FixWidth, MUIA_FixHeight

MUIA_MaxWidth

NAME

MUIA_MaxWidth — V11 [I..], LONG, 0x8042f112

FUNCTION

Specify a maximum width for an object (in pixels).

SEE ALSO

MUIA_MaxHeight, MUIA_FixWidth, MUIA_FixHeight

MUIA_MinHeight

NAME

MUIA_MinHeight — V20 [I..], LONG, 0x8042c04a

FUNCTION

Specify a minimum height for an object (in pixels). This attribute exists for convenience reasons only. It is a much cleaner approach to create a subclass or Area.mui and overload the MUIM_AskMinMax method to enforce a certain minimum height.

SEE ALSO

MUIA_MinWidth

MUIA_MinWidth

NAME

MUIA_MinWidth — V20 [I..], LONG, 0x80424342

FUNCTION

Specify a minimum width for an object (in pixels). This attribute exists for convenience reasons only. It is a much cleaner approach to create a subclass or Area.mui and overload the MUIM_AskMinMax method to enforce a certain minimum width.

SEE ALSO

MUIA_MinHeight

MUIA_PointerType

NAME

MUIA_PointerType — V20 [ISG], LONG, 0x8042b467

SPECIAL INPUTS

  • MUIV_PointerType_Parent
  • MUIV_PointerType_Normal
  • MUIV_PointerType_Busy
  • MUIV_PointerType_Alias
  • MUIV_PointerType_Cell
  • MUIV_PointerType_ColumnResize
  • MUIV_PointerType_ContextMenu
  • MUIV_PointerType_Copy
  • MUIV_PointerType_Cross
  • MUIV_PointerType_DragAndDrop
  • MUIV_PointerType_EastResize
  • MUIV_PointerType_EastWestResize
  • MUIV_PointerType_Hand
  • MUIV_PointerType_Help
  • MUIV_PointerType_Link
  • MUIV_PointerType_Menu
  • MUIV_PointerType_NoDrop
  • MUIV_PointerType_None
  • MUIV_PointerType_NorthEastResize
  • MUIV_PointerType_NorthEastSouthWestResize
  • MUIV_PointerType_NorthResize
  • MUIV_PointerType_NorthSouthResize
  • MUIV_PointerType_NorthWestResize
  • MUIV_PointerType_NorthWestSouthEastResize
  • MUIV_PointerType_NotAllowed
  • MUIV_PointerType_Progress
  • MUIV_PointerType_RowResize
  • MUIV_PointerType_ScrollAll
  • MUIV_PointerType_SouthEastResize
  • MUIV_PointerType_SouthResize
  • MUIV_PointerType_SouthWestResize
  • MUIV_PointerType_Text
  • MUIV_PointerType_VerticalText
  • MUIV_PointerType_WestResize
  • MUIV_PointerType_ZoomIn
  • MUIV_PointerType_ZoomOut
  • MUIV_PointerType_Pen
  • MUIV_PointerType_Rotate
  • MUIV_PointerType_Rubber
  • MUIV_PointerType_Select
  • MUIV_PointerType_Smudge
  • MUIV_PointerType_Count

FUNCTION

MUIA_PointerType defines the built-in mouse pointer to be used when the mouse hovers over the object. Usually this is used to indicate certain actions which will be triggered when the object is clicked or to make its purpose more obvious. For example, string gadgets may use a text cursur as mouse pointer to indicate that the object accepts text for input.

There is one special value:

MUIV_PointerType_Parent
Use the parent object's mouse pointer. This is useful for embedded objects to use the same pointer as the parent object without having to know which one is actually used. This is the default value.

It is also possible to set custom pointer images created by pointerclass.

In case you need different pointer types depending on the mouse position within the object your object's class must overload the method MUIM_WhichPointerType and return the desired pointer type value.

MUI has built-in images for all kinds of pointer types except the normal and the busy pointer. The system images will be used in this case.

For AmigaOS4.1 intuition.library 53.41+ is able to use truecolor images as mouse pointer images if the hardware is capable to handle these. If all this is the case then the appropriate truecolor system images will be used.

EXAMPLE

set(obj, MUIA_PointerType, MUIV_PointerType_Text);

A detailed example can be found in the source code of the Pointers demo application.

SEE ALSO

MUIM_WhichPointerType

MUIA_Pressed

NAME

MUIA_Pressed — V4 [..G], BOOL, 0x80423535

FUNCTION

Learn if a button is pressed (or released). The MUIA_Pressed attribute of a gadget is triggered by some user action, depending on the input mode:

MUIV_InputMode_RelVerify:

  • set when lmb is pressed.
  • cleared when lmb is released and the mouse is still over the gadget (otherwise it will be cleared too, but without triggering a notification event).

MUIV_InputMode_Immediate:

MUIV_InputMode_Toggle:

Waiting for MUIA_Pressed becoming FALSE is the usual way to react on button gadgets.

EXAMPLE

DoMethod(btcancel, MUIM_Notify, MUIA_Pressed, FALSE,
  app, 2,
  MUIM_Application_ReturnID, ID_CANCEL);

SEE ALSO

MUIA_Selected, MUIA_Timer, MUIA_ShowSelState, MUIA_InputMode

MUIA_RightEdge

NAME

MUIA_RightEdge — V4 [..G], LONG, 0x8042ba82

FUNCTION

You can use this to read the current position and dimension of an object, if you e.g. need it to pop up some requester below.

Of course, this attribute is only valid when the parent window of the object is currently open.

SEE ALSO

MUIA_TopEdge, MUIA_Width, MUIA_Height, MUIA_LeftEdge, MUIA_BottomEdge

MUIA_Selected

NAME

MUIA_Selected — V4 [ISG], BOOL, 0x8042654b

FUNCTION

Get and set the selected state of a gadget. This attribute can be triggered by the user clicking on the gadget (or using the keyboard), depending on the input mode:

MUIV_InputMode_RelVerify:

  • set when lmb is pressed.
  • cleared when lmb is released.
  • cleared when the gadget is selected and the mouse leaves the gadget box.
  • set when the mouse reenters the gadget box.

MUIV_InputMode_Immediate:

  • set when lmb is pressed.

MUIV_InputMode_Toggle:

  • toggled when lmb is pressed.

Of course you may set this attribute yourself, e.g. to adjust the state of a checkmark gadget.

A selected gadget will display its border reverse and get the configured MUII_SelectedBack background. This can be avoided using the MUIA_ShowSelState tag.

SEE ALSO

MUIA_Pressed, MUIA_Timer, MUIA_ShowSelState, MUIA_InputMode

MUIA_ShortHelp

NAME

MUIA_ShortHelp — V11 [ISG], STRPTR, 0x80428fe3

FUNCTION

Specify a string that is to be used as bubble help for this object.

SEE ALSO

MUIM_CreateShortHelp, MUIM_DeleteShortHelp, MUIM_CreateBubble, MUIM_DeleteBubble

MUIA_ShowMe

NAME

MUIA_ShowMe — V4 [ISG], BOOL, 0x80429ba8

FUNCTION

Objects with this attribute set are not displayed. You can set MUIA_ShowMe at any time, causing objects to appear and to disappear immediately. A new layout is calculated whenever some objects are shown or hidden. When necessary, MUI will resize the parent window to make room for the new objects.

NOTES

Currently, MUI does a complete window refresh after showing/hiding objects. This behaviour might get improved in the future.

Do not confuse this attribute with any kind of "visibility" of an object, i.e. on a currently not active page of a register group. get()ing MUIA_ShowMe will just return the last set value or the default (TRUE).

MUIA_ShowSelState

NAME

MUIA_ShowSelState — V4 [I..], BOOL, 0x8042caac

FUNCTION

Normally a gadget will reverse its frame and display the configured MUII_SelectetBack background pattern in its selected state. For some objects (e.g. checkmarks) this is not recommended and can be supressed by setting MUIA_ShowSelState to FALSE.

SEE ALSO

MUIA_Selected

MUIA_Timer

NAME

MUIA_Timer — V4 [..G], LONG, 0x80426435

FUNCTION

MUIA_Timer gets triggered when a relverify button is pressed and (after a little delay) increases every INTUITICK as long as the mouse remains over the gadget.

This makes it possible to have buttons repeatedly cause some actions, just like the arrow gadgets of a scrollbar.

EXAMPLE

DoMethod(btmore, MUIM_Notify, MUIA_Timer, MUIV_EveryTime,
  app, 2,
  MUIM_Application_ReturnID, ID_MORE);

DoMethod(btless, MUIM_Notify, MUIA_Timer, MUIV_EveryTime,
  app, 2,
  MUIM_Application_ReturnID, ID_LESS);

SEE ALSO

MUIA_Pressed, MUIA_Selected

MUIA_TopEdge

NAME

MUIA_TopEdge — V4 [..G], LONG, 0x8042509b

FUNCTION

You can use this to read the current position and dimension of an object, if you e.g. need it to pop up some requester below.

Of course, this attribute is only valid when the parent window of the object is currently open.

SEE ALSO

MUIA_LeftEdge, MUIA_Width, MUIA_Height, MUIA_RightEdge, MUIA_BottomEdge

MUIA_VertDisappear

NAME

MUIA_VertDisappear — V11 [ISG], LONG, 0x8042d12f

FUNCTION

Objects with a disappear level disappear automatically when their parent window gets too small to display them. Use this for things that make your GUI look nicer (e.g. Imagery) but are not absolutely necessary.

By using disappearing objects, you can make nice GUIs which still work on crappy 640x200 screens.

You can give horizontal or vertical disappear levels to objects which are used for horizontal or vertical layout calculations respectively.

Objects with a small disappear level disappear before objects with a big disappear level.

SEE ALSO

MUIA_HorizDisappear

MUIA_VertWeight

NAME

MUIA_VertWeight — V4 [ISG], WORD, 0x804298d0

FUNCTION

Adjust the vertical weight of an object. Usually you can simply use MUIA_Weight instead of this tag but in some two-dimensional groups it may become handy to have different horizontal and vertical weights.

SEE ALSO

MUIA_Weight

MUIA_Weight

NAME

MUIA_Weight — V4 [I..], WORD, 0x80421d1f

FUNCTION

This tag is a shorthand for MUIA_HorizWeight and MUIA_VertWeight, it sets both weights at once.

The weight of an object determines how much room it will get during the layout process. Imagine you have a 100 pixel wide horizontal group with two string gadgets. Usually, each gadget will get half of the room and be 50 pixels wide. If you feel the left gadget is more important and should be bigger, you can give it a weight of 200 (and 100 for the right gadget). Because the left gadget is twice as "heavy" as the right gadget, it will become twice as big (about 66 pixel) as the right one (34 pixel).

Of course giving weights only makes sense if the object is resizable. A MUIA_VertWeight for a (always fixed height) string gadget is useless.

An object with a weight of 0 will always stay at its minimum size.

By default, all objects have a weight of 100.

EXAMPLE

HGroup,
  StringGadget, MUIA_Weight,  50, End,
  StringGadget, MUIA_Weight, 100, End,
  StringGadget, MUIA_Weight, 200, End,
  End;

SEE ALSO

MUIA_HorizWeight, MUIA_VertWeight

MUIA_Width

NAME

MUIA_Width — V4 [..G], LONG, 0x8042b59c

FUNCTION

You can use this to read the current position and dimension of an object, if you e.g. need it to pop up some requester below.

Of course, this attribute is only valid when the parent window of the object is currently open.

SEE ALSO

MUIA_TopEdge, MUIA_LeftEdge, MUIA_Height, MUIA_RightEdge, MUIA_BottomEdge

MUIA_Window

NAME

MUIA_Window — V4 [..G], struct Window *, 0x80421591

FUNCTION

This attribute can be used to get a pointer to the intuition window structure of the parent window of the object. This pointer could e.g. be used in calls to asl.library.

The result is only valid when the window is opened.

SEE ALSO

MUIA_Window_Window

MUIA_WindowObject

NAME

MUIA_WindowObject — V4 [..G], Object *, 0x8042669e

FUNCTION

You can obtain a pointer to the window object that some gadget belongs to by using this attribute. Useful mainly within callback hooks if you do not want to deal with global variables.

SEE ALSO

MUIA_ApplicationObject

MUIM_AskMinMax

NAME

MUIM_AskMinMax — V4, 0x80423874 [For use within custom classes only]

SYNOPSIS

DoMethod(obj, MUIM_AskMinMax, struct MUI_MinMax *MinMaxInfo);

FUNCTION

see developer documentation.

INPUTS

struct MUI_MinMax *MinMaxInfo
a pointer to a MUI_MinMax structure to be filled with the required minimum, default and maximum dimensions.



MUIM_Cleanup

NAME

MUIM_Cleanup — V4, 0x8042d985 [For use within custom classes only]

SYNOPSIS

DoMethod(obj, MUIM_Cleanup);

FUNCTION

see developer documentation.

MUIM_ContextMenuAdd

NAME

MUIM_ContextMenuAdd — V20, 0x8042df9e

SYNOPSIS

DoMethod(obj, MUIM_ContextMenuAdd, Object *menustrip, LONG mx, LONG my, LONG *mxp, LONG *myp);

FUNCTION

Allows dynamic creation of context menus. When MUI is about to show a new context menu, it does not simply use the MUIA_ContextMenu field of Area class. Instead, it sends a MUIM_ContextMenuAdd to the object in question to let it add its own context menu items to the given menustrip object.

When MUIM_ContextMenuAdd reaches Area class, it will pass this method to its parent object, if it exists.

However, if your context menus depend on some internal states of your object or on the mouse position within your object, you have to build a subclass which implements MUIM_ContextMenuAdd and adds some items to the menustrip object.

INPUTS

Object *menustrip
a MenuStrip object to add your own Menu objects to.
LONG mx
current x position of mouse.
LONG my
current y position of mouse.
LONG *mxp
pointer to mx.
LONG *myp
pointer to my.

Since MUI does (unfortunately) not use relative coordinates at all, these two aren't relative either.

By modifying the values in mxp and myp you can let the menu appear at a different position.

EXAMPLE

// create the menu
if((data->menu = MenuObject, MUIA_Menu_Title, "Columns", End) != NULL)
{
  DoMethod(data->menu, OM_ADDMEMBER, MenuitemObject,
    MUIA_Menuitem_Title, "Show all",
  End);
  DoMethod(data->menu, OM_ADDMEMBER, MenuitemObject,
    MUIA_Menuitem_Title, "Reset sizes",
  End);

  // add the menu to the menustrip
  DoMethod(msg->menustrip, OM_ADDMEMBER, data->menu);
}

NOTES

Although MUI will dispose the object you create, you should nevertheless remember it in your class' instance data for later reference during MUIM_ContextMenuChoice.

Even when implementing MUIM_ContextMenuAdd, you MUST set MUIA_ContextMenu of your object to something different from NULL. MUI will find out that your object actually has a popup menu by directly checking the contents of MUIA_ContextMenu in the instance data of Area class due to speed reasons.

Do not forget to OM_ADDMEMBER the created items to the given menustrip objects, otherwise the user will never see those items!

EXAMPLE

struct Data
{
  Object *menu;
  [...]
};

ULONG m_MyClass_ContextMenuAdd(struct IClass *cl, Object *obj,
                               struct MUIP_ContextMenuAdd *msg)
{
  struct Data *data = INST_DATA(cl, obj);

  if((data->menu = MenuObject, MUIA_Menu_Title, "my title", FALSE,
    Child, MenuitemObject,
      MUIA_Menuitem_Title, "my item",
      MUIA_UserData, 1001,
      End,
    [...]
  End) != NULL)
  {
    // very important, add your own menu to the supplied menu strip
    DoMethod(msg->menustrip, OM_ADDMEMBER, data->menu);
  }

  // let your superclass possibly add further own menu items
  return DoSuperMethodA(cl, obj, (Msg)msg);
}

ULONG m_MyClass_ContextMenuChoice(struct IClass *cl, Object *obj,
                                  struct MUIP_ContextMenuChoice *msg)
{
  struct Data *data = INST_DATA(cl, obj);
  ULONG rc = 0;

  // make sure the menu still exists and the item belongs to our menu
  if(data->menu != NULL && DoMethod(data->menu, MUIM_FindObject, msg->item))
  {
    switch(muiUserData(msg->item))
    {
      case 1001:
      {
        // do your desired actions
      }
      break;
    }
  }
  else
  {
    // let the superclass handle its own menus
    rc = DoSuperMethodA(cl, obj, (Msg)msg);
  }

  // forget the menu object, it will be disposed with the menustrip
  data->menu = NULL;

  return rc;
}

SEE ALSO

MUIM_ContextMenuBuild, MUIA_ContextMenu, MUIA_ContextMenuTrigger, MUIM_ContextMenuChoice

MUIM_ContextMenuBuild

NAME

MUIM_ContextMenuBuild — V11, 0x80429d2e

SYNOPSIS

DoMethod(obj, MUIM_ContextMenuBuild, LONG mx, LONG my);

FUNCTION

OBSOLETE - USE MUIM_ContextMenuAdd in new code.

old documentation: Allows dynamic creation of context menus. When MUI is about to show a new context menu, it does not simply use the MUIA_ContextMenu field of Area class. Instead, it sends a MUIM_ContextMenuBuild to the object in question and uses the return value as the new menustrip object.

When MUIM_ContextMenuBuild reaches Area class, it just returns the contents of MUIA_ContextMenu so you don't need to care about this method if you only have static, non-changing context menus.

However, if your context menus depend on some internal states of your object or on the mouse position within your object, you have to build a subclass which overrides MUIM_ContextMenuBuild, creates a nice menustrip object and returns it.

INPUTS

LONG mx
current x position of mouse.
LONG my
current y position of mouse.

Since MUI does (unfortunately) not use relative coordinates at all, these two aren't relative either.

RESULT

If you return a pointer to a menustrip object, MUI will show it as popup menu.

If you return the special value MUIV_ContextMenuBuild_Default, MUI will show the window's default menu instead. This is e.g. recommended for classes that only want popup menus on certain mouse positions.

If you return NULL, nothing will happen. This is for compatibility for pre-MUI4 applications which used MUIM_ContextMenuBuild to detect the right mouse button. This is no longer recommended. With MUI4 and its event handlers, you can simply handle RMB just like LMB.

NOTES

MUI will never dispose the object you return. You must take care of this yourself, e.g. by storing a pointer somewhere in your instance data and killing it on the next invocation of MUIM_ContextMenuBuild or on OM_DISPOSE.

Even when implementing MUIM_ContextMenuBuild, you MUST set MUIA_ContextMenu of your object to something different from NULL. MUI will find out that your object actually has a popup menu by directly checking the contents of MUIA_ContextMenu in the instance data of area class due to speed reasons.

SEE ALSO

MUIM_ContextMenuAdd, MUIA_ContextMenu, MUIA_ContextMenuTrigger, MUIM_ContextMenuChoice

MUIM_ContextMenuChoice

NAME

MUIM_ContextMenuChoice — V11, 0x80420f0e

SYNOPSIS

DoMethod(obj, MUIM_ContextMenuChoice, Object *item);

FUNCTION

Allows reacting on context menus in subclasses.

See MUIA_ContextMenu for details.

INPUTS

Object *item
the selected menu item.

SEE ALSO

MUIA_ContextMenuTrigger, MUIM_ContextMenuChoice, MUIM_ContextMenuBuild

MUIM_CreateBubble

NAME

MUIM_CreateBubble — V18, 0x80421c41

SYNOPSIS

DoMethod(obj, MUIM_CreateBubble, LONG x, LONG y, CONST_STRPTR txt, ULONG flags);

FUNCTION

Together with MUIM_DeleteBubble, this method provides an interface for MUI's bubble mechanism. Applications can use bubbles for their own purpose, e.g. for indicating error conditions on certain gadgets.

MUIM_CreateBubble creates a bubble at the specified coordinates with the specified (textual) contents. It returns a bubble "handle" that has to be passed to MUIM_DeleteBubble when the bubble shall disappear.

There's no limitation on the number of bubbles, you can create lots of them at a time if you wish. Also, these custom bubbles are completely independant of MUI's bubble help system and won't disappear automatically when the mouse is moved.

Note that bubbles will only show up when the object in question is visible. Otherwise MUIM_CreateBubble returns NULL. You are responsible for deleting the bubble before the object becomes invisible. Good place to remove a custom bubble is e.g. the MUIM_Hide method of your object.

INPUTS

LONG x
window-relative X coordinate of the bubble.
LONG y
window-relative Y coordinate of the bubble.
CONST_STRPTR txt
custom text for the bubble. If you pass NULL here, MUI will query the object with MUIM_CreateShortHelp method for a text (like the automatic help system does).
ULONG flags
  • MUIV_CreateBubble_DontHidePointer: prevents MUI from hiding the mouse pointer when displaying the help bubble. It is recommended that you always set this, unless your bubble is meant to disappear as soon as there is some user input.

RESULT

This method returns a pointer to a (black box) bubble handle or NULL on failure. You have to pass the bubble handle to MUIM_DeleteBubble if you want to delete the bubble later.

SEE ALSO

MUIM_DeleteBubble, MUIM_CreateShortHelp, MUIM_DeleteShortHelp, MUIA_ShortHelp

MUIM_CreateDragImage

NAME

MUIM_CreateDragImage — V18, 0x8042eb6f [For use within custom classes only]

SYNOPSIS

DoMethod(obj, MUIM_CreateDragImage, LONG touchx, LONG touchy, ULONG flags);

FUNCTION

Overriding this method allows you to set up a custom image to be used during drap&dDrop operations. The default image is the object's visible imagery at the time the drag&drop operation starts.

INPUTS

LONG touchx
x-distance between "click point" and object coordinates.
LONG touchy
y-distance between "click point" and object coordinates.
ULONG flags
none defined yet, must be 0 for now.

RESULT

You must return a pointer to a struct MUI_DragImage or NULL if you failed to create one. MUI will abort the drag&drop operation if you return either NULL or the bitmap pointer is NULL.

EXAMPLE

MUIM_CreateDragImage method:

struct MUI_DragImage *di;
if((di = AllocVec(sizeof(struct MUI_DragImage), MEMF_CLEAR)) != NULL)
{
  if((bi->bm = AllocBitMap(_width(obj), _height(obj), 8, BMF_CLEAR, NULL) != NULL)
  {
    // paint something fancy into the bitmap
    <...>
    // fill the MUI_DragImage structure with sensible values
    di->width  = _width(obj);
    di->height = _height(obj);
    di->touchx = msg->touchx;
    di->touchy = msg->touchy;
    // if you need an additional mask plane put the pointer to it here
    // and set the MUIF_DRAGIMAGE_HASMASK flag.
    di->flags = 0;
    di->mask = NULL;
    return di;
  }
  // bitmap allocation failed
  FreeVec(di);
}
// signal failure
return NULL;

MUIM_DeleteDragImage method:

FreeBitMap(di->bm);
FreeVec(di);

SEE ALSO

MUIM_DeleteDragImage

MUIM_CreateShortHelp

NAME

MUIM_CreateShortHelp — V11, 0x80428e93

SYNOPSIS

DoMethod(obj, MUIM_CreateShortHelp, LONG mx, LONG my);

FUNCTION

Allows dynamic creation of help bubble texts.

When MUI is about to show a help bubble, it does not simply use the MUIA_ShortHelp field of area class. Instead, it sends a MUIM_CreateShortHelp method to the object in question and uses the return value as text for the bubble.

When MUIM_CreateShortHelp reaches Area class, it just returns the contents of MUIA_ShortHelp, so you needn't care about this method if you only have static, non-changing help bubbles.

However, if your help bubble texts depend on some internal states of your objects or on the mouse position within your objects, you have to create a subclass which overrides MUIM_CreateShortHelp, creates a custom text string and returns it.

You can dynamically allocate memory here. MUI will call the method MUIM_DeleteShortHelp after the bubble has disappeared to give you a chance to free this memory again.

INPUTS

LONG mx
current x position of mouse.
LONG my
current y position of mouse.

Since MUI does (unfortunately) not use relative coordinates at all, these two aren't relative either.

RESULT

You must return a pointer to a string or NULL if you failed to create one. MUI will not show any bubble at all if you return NULL, so you can use this to selectively supply bubble help only on certain areas of your object.

NOTES

This method is sent by MUI. Never send it yourself.

MUI will not free the string you return. You must take care of this yourself, e.g. by using static text or by freeing anything you allocated in the following MUIM_DeleteShortHelp method.

Even when overriding MUIM_CreateShortHelp, you MUST set MUIA_ShortHelp of your object to something different from NULL. MUI will find out that your object actually has a bubble help by directly checking the contents of MUIA_ShortHelp in the instance data of Area class due to speed reasons.

EXAMPLE

Suggested use is something like

obj = NewObject(..., MUIA_ShortHelp, TRUE, ...);

and then override these methods in obj's class.

ULONG MUIM_CreateShortHelp(...)
{
  STRPTR help;
  int mx = msg->mx;
  int my = msg->my;

  mx -= _mleft(obj); // make coordinates relative
  my -= _mtop(obj);

  // no bubble at all if mouse is in a 10 pixel
  // wide x-region at the edge of the object.
  if (mx < 10 || mx > _mwidth(obj)-10)
     return(NULL);

  // allocate space for bubble text
  if((help = AllocVec(300, MEMF_ANY)) == NULL)
     return (ULONG)NULL;

  // fill help string with some dynamic text
  sprintf(help, "Yahoo... very dynamic... %ld %ld", mx, my);

  return (ULONG)help;
}

ULONG MUIM_DeleteShortHelp(...)
{
  FreeVec(msg->help);
  return 0;
}

SEE ALSO

MUIM_DeleteShortHelp, MUIM_CreateBubble, MUIM_DeleteBubble, MUIA_ShortHelp

MUIM_DeleteBubble

NAME

MUIM_DeleteBubble — V18, 0x804211af

SYNOPSIS

DoMethod(obj, MUIM_DeleteBubble, APTR bubble);

FUNCTION

Together with MUIM_CreateBubble, this method provides an interface for MUI's bubble mechanism. Applications can use bubbles for their own purpose, e.g. for indicating error conditions on certain gadgets.

MUIM_DeleteBubble deletes a bubble that was previously created with MUIM_CreateBubble. Note that bubbles have to be deleted before an object becomes invisible!

INPUTS

APTR bubble
pointer to black box bubble handle as returned by MUIM_CreateBubble.

RESULT

The bubble will be removed. The return value is undefined.

SEE ALSO

MUIM_CreateBubble, MUIM_CreateShortHelp, MUIM_DeleteShortHelp

MUIM_DeleteDragImage

NAME

MUIM_DeleteDragImage — V18, 0x80423037 [For use within custom classes only]

SYNOPSIS

DoMethod(obj, MUIM_DeleteDragImage, struct MUI_DragImage *di);

FUNCTION

Free all stuff allocated during MUIM_CreateDragImage.

INPUTS

struct MUI_DragImage *di
the MUI_DragImage structure to be freed.

SEE ALSO

MUIM_CreateDragImage

MUIM_DeleteShortHelp

NAME

MUIM_DeleteShortHelp — V11, 0x8042d35a

SYNOPSIS

DoMethod(obj, MUIM_DeleteShortHelp, STRPTR help);

FUNCTION

Delete the string that MUIM_CreateShortHelp might have allocated.

MUI will call this method if you returned a custom text in MUIM_CreateShortHelp when the bubble has disappeared.

You can free memory that you allocated for the dynamic bubble text here.

INPUTS

STRPTR help
the STRPTR you previously returned in MUIM_CreateShortHelp.

RESULT

Return NULL in every case.

SEE ALSO

MUIM_CreateShortHelp, MUIM_CreateBubble, MUIM_DeleteBubble, MUIA_ShortHelp

MUIM_DoDrag

NAME

MUIM_DoDrag — V20, 0x804216bb

SYNOPSIS

DoMethod(obj, MUIM_DoDrag, LONG touchx, LONG touchy, ULONG flags);

FUNCTION

This method invokes MUI's drag & drop handling. Normally, MUI takes care about this itself when objects are specified as draggable. However, if you e.g. have a whole group of objects that should be dragged (like a toolbar) and just a small "handle" button to start this operation, you must use this method.

INPUTS

LONG touchx
x-distance between "click point" and object coordinates. Using the special value 0x80000000 will make MUI use window→MouseX - _left(obj)
LONG touchy
y-distance between "click point" and object coordinates. Using the special value 0x80000000 will make MUI use window→MouseY - _top(obj)
ULONG flags
none defined yet, must be 0 for now.

EXAMPLE

Child, toolbar = HGroup,
  Child, draghandle = SimpleButton("dragme"),
  Child, SimpleButton("toolbutton1"),
  Child, SimpleButton("toolbutton2"),
  Child, SimpleButton("toolbutton3"),
  Child, SimpleButton("toolbutton4"),
  End,

DoMethod(draghandle, MUIM_Notify, MUIA_Pressed, TRUE,
  toolbar, 4,
  MUIM_DoDrag, 0x80000000, 0x80000000, 0);

SEE ALSO

MUIA_Draggable, MUIM_DragBegin, MUIM_DragQuery, MUIM_DragFinish, MUIM_DragReport, MUIM_DragDrop

MUIM_DragBegin

NAME

MUIM_DragBegin — V11, 0x8042c03a

SYNOPSIS

DoMethod(obj, MUIM_DragBegin, Object *obj);

FUNCTION

Inform an object that it has become the active destination of a drag&drop action. An object will only receive this if it has responded positively to a previous MUIM_DragQuery.

SEE ALSO

MUIM_DragQuery, MUIM_DragFinish, MUIM_DragReport, MUIM_DragDrop

MUIM_DragDrop

NAME

MUIM_DragDrop — V11, 0x8042c555

SYNOPSIS

DoMethod(obj, MUIM_DragDrop, Object *obj, LONG x, LONG y, ULONG qualifier);

FUNCTION

Indicate that the user dropped something on the current object.

SEE ALSO

MUIM_DragBegin, MUIM_DragFinish, MUIM_DragReport, MUIM_DragQuery

MUIM_DragEvent

NAME

MUIM_DragEvent — V20, 0x8042b774 [For use within custom classes only]

SYNOPSIS

DoMethod(obj, MUIM_DragEvent, struct Window *objwindow, Object *obj, struct MUI_DragImage *di, struct IntuiMessage *imsg, LONG muikey, ULONG mouseptrtype, ULONG flags);

FUNCTION

Query the source object of a drag&drop operation for further actions. Overloading this method makes it possible to change the drag images while the drag&drop operation is still in progress or to change the mouse pointer image.

INPUTS

struct Window *objwindow
a pointer to the window the mouse pointer is currently hovering over. This may be a foreign window. If your application is able to handle drops outside the application you must set the flag MUIF_DRAGEVENT_FOREIGNDROP in the flags field.
Object *obj
the current destination object. May be NULL if there is currently no object within the application to accept the drag&drop operation.
struct MUI_DragImage *di
a pointer to a struct MUI_DragImage. If you wish to change the drag image during the drag&drop operation provide a pointer to a new drag image here. You must also set the MUIF_DRAGEVENT_REDRAW flag in the flags field to let MUI accept this change.
struct IntuiMessage *imsg
a pointer to the current IntuiMessage.
LONG muikey
the current standard MUI key.
ULONG mouseptrtype
set this field to the pointer type you want MUI to use during the drag&drop operation. You must also set the MUIF_DRAGEVENT_MOUSECHANGED flag in the flags field to let MUI accept this change. Valid values are all MUIV_PointerType_#? values, except MUIV_PointerType_Parent, as well as pointer image objects created by pointerclass.
ULONG flags
flags indicating which of the above fields were changed and need to be applied to the drag&drop process. Currently these flags exists:
  • MUIF_DRAGEVENT_REDRAW: set by the overloader in case the MUI_DragImage was modified during MUIM_DragEvent.
  • MUIF_DRAGEVENT_FOREIGNDROP: set by the overloader in case it can drop to a foreign window, the actual drop must be implemented in the Application's MUIM_DragDrop method.
  • MUIF_DRAGEVENT_MOUSECHANGED: set by the overloader to force a custom mouse pointer instead of the one picked by MUI.

SEE ALSO

MUIA_PointerType

MUIM_DragFinish

NAME

MUIM_DragFinish — V11, 0x804251f0

SYNOPSIS

DoMethod(obj, MUIM_DragFinish, Object *obj, LONG dropfollows);

FUNCTION

Indicate that an object is no longer the active destination object of a drag&drop action.

INPUTS

Object *obj
the source object being dragged.
LONG dropfollows
a flag indicating whether a MUIM_DragDrop message will follow for the receiving object.

SEE ALSO

MUIM_DragQuery, MUIM_DragBegin, MUIM_DragReport, MUIM_DragDrop

MUIM_DragQuery

NAME

MUIM_DragQuery — V11, 0x80420261

SYNOPSIS

DoMethod(obj, MUIM_DragQuery, Object *obj);

FUNCTION

MUI offers complete drag & drop capabilities for every object. If enabled, the user is able to grab an object, drag it around and drop it on another object. Currently, D&D is limited to single applications, i.e. you cannot take an object from one program and drop it into another one. D&D between different windows of the same application, however, is fine.

MUI controls the D&D actions with a set of five methods: MUIM_DragQuery, MUIM_DragBegin, MUIM_DragReport, MUIM_DragDrop and MUIM_DragFinish. Basically things work this way:

Let's assume the user has taken an object (called the source object) and is now starting to drag it around. During dragging, MUI will find out which object is currently under the mouse pointer and if it found one, send it the MUIM_DragQuery method. An object that receives MUIM_DragQuery can now determine it it wishes to accept drops from the source object or not. If it responds positively, the object will become the current destination object.

Due to the nature of MUIs layout system, a specific x,y pair of coordinates cannot be bound to a specific object immediately. Instead, the coordinates belong to a whole tree of objects, for example some cycle gadget, its parent group, the parent group of the parent group and so on until the tree reaches the windows root object. To allow complete groups of objects to participate in D&D business, the MUIM_DragQuery is first sent to the deepest nested object (the cycle gadget in the example above). If this one doesn't respond, MUI sends a MUIM_DragQuery to its parent group and so on until it either finds some object which accepts the drop or reaches the end of the tree. If there is an accepting object, it will become the current destination. If there isn't one, no destination will be set.

Objects becoming active destinations of a drag process learn about their current state by receiving a MUIM_DragBegin method. This method, when reaching area class, e.g. draws a special frame around the object to indicate the current state to the user.

The opposite of MUIM_DragBegin is MUIM_DragFinish and will be sent as soon as the object stops being destination of the drag process, i.e. because the user aborted the drag or moved out of the bounding box. MUIM_DragFinish will also be sent after a successful drop, you can rely on receiving a MUIM_DragFinish if you received a MUIM_DragBegin before. Furthermore, only one object will be between MUIM_DragBegin and MUIM_DragFinish at any time.

Active destination objects (between MUIM_DragBegin and MUIM_DragFinish) receive MUIM_DragReport methods as long as the user moves the mouse within the object. MUIM_DragReport contains the mouse coordinates, so the object can update its display according to the position of the source object. A listview would e.g. indicate the insert position to give the user an idea where the source would be inserted in case of a drop.

All the methods mentioned above are just interim messages that help visualizing the drag process. When the user actually decides to drop its source object, the current destination object (if any) receives a MUIM_DragDrop method and can perform whatever operation it thinks is suited to handle a D&D action from the source object.

You probably have noticed that D&D is controlled by methods. This means that you need to write subclasses if you intend to use it. However, you don't need to implement all the above mentioned things to reach your goal. In fact, MUIM_DragQuery and MUIM_DragDrop are enough for almost all D&D invocations. Here's a little example of how MUI implements D&D between objects of Pendisplay class. These few lines allow the user to take any Pendisplay (or subclasses from Pendisplay like e.g. Poppen class) and drop it onto another one:

ULONG mDragQuery(struct IClass *cl, Object *obj, struct MUIP_DragQuery *msg)
{
  char *spec;

  /* refuse to be dropped on ourself */
  if(msg->obj == obj)
    return MUIV_DragQuery_Refuse;

  /* if the source object offers the attribute */
  /* we want, show that we would accept it. */
  if(get(msg->obj, MUIA_Pendisplay_Spec, &spec))
    return MUIV_DragQuery_Accept;

  /* refuse otherwise */
  return MUIV_DragQuery_Refuse;
}

ULONG mDragDrop(struct IClass *cl, Object *obj, struct MUIP_DragDrop *msg)
{
  char *spec;

  /* copy the attribute from the source object */
  get(msg->obj, MUIA_Pendisplay_Spec, &spec);
  set(obj, MUIA_Pendisplay_Spec, spec);

  return 0;
}

INPUTS

Object *obj
the source object being dragged.

SEE ALSO

MUIM_DragBegin, MUIM_DragFinish, MUIM_DragReport, MUIM_DragDrop

MUIM_DragReport

NAME

MUIM_DragReport — V11, 0x8042edad

SYNOPSIS

DoMethod(obj, MUIM_DragReport, Object *obj, LONG x, LONG y, LONG update, ULONG qualifier);

FUNCTION

Interim messages from MOUSEMOVEs and INTUITICKs sent as long as an object is active destination of a drag&drop action.

INPUTS

Object *obj
the source object being dragged.
LONG x
the current mouse X position.
LONG y
the current mouse Y position.
LONG update
a flag indicating whether this method is called again due to e previous call returning MUIV_DragReport_Refresh.
ULONG qualifier
the currently active input qualifiers.

SEE ALSO

MUIM_DragQuery, MUIM_DragFinish, MUIM_DragBegin, MUIM_DragDrop

MUIM_Draw

NAME

MUIM_Draw — V4, 0x80426f3f [For use within custom classes only]

SYNOPSIS

DoMethod(obj, MUIM_Draw, ULONG flags);

FUNCTION

see developer documentation.

INPUTS

ULONG flags
define how the object is to be redrawn. Can be one of
  • MADF_DRAWOBJECT draw the full object
  • MADF_DRAWUPDATE do a possibly partitial redraw only



MUIM_DrawBackground

NAME

MUIM_DrawBackground — V11, 0x804238ca

SYNOPSIS

DoMethod(obj, MUIM_DrawBackground, LONG left, LONG top, LONG width, LONG height, LONG xoffset, LONG yoffset, LONG flags);

FUNCTION

If you decided to use MUIA_FillArea, FALSE for your custom class, i.e. if you care about background rendering yourself, you can use this method to draw a specific part of your objects background with the defined MUIA_Background.

INPUTS

LONG left
left coordinate of the rectangle to be drawn, make sure to add your object's _mleft coordinates.
LONG top
top coordinate of the rectangle to be drawn, make sure to add your object's _mtop coordinates.
LONG width
width of the rectangle to be drawn.
LONG height
height of the rectangle to be drawn.
LONG xoffset
offset to use when background is a pattern.
LONG yoffset
offset to use when background is a pattern.
LONG flags
none defined yet, set to 0 for now.

RESULT

The result value of this method is currently undefined.

SEE ALSO

MUIA_Background

MUIM_DrawBackgroundParent

NAME

MUIM_DrawBackgroundParent — V20, 0x804240e7

SYNOPSIS

DoMethod(obj, MUIM_DrawBackgroundParent, LONG left, LONG top, LONG width, LONG height, LONG brightness, LONG xoffset, LONG yoffset, LONG flags);

FUNCTION

Just like MUIM_DrawBackground to fill the object's background with the defined background image this method will do same except that the parent object's background image will be used instead. This allows to modify the brightness of the parent object's background image.

INPUTS

LONG left
left coordinate of the rectangle to be drawn, make sure to add your object's _mleft coordinates.
LONG top
top coordinate of the rectangle to be drawn, make sure to add your object's _mtop coordinates.
LONG width
width of the rectangle to be drawn.
LONG height
height of the rectangle to be drawn.
LONG brightness
adjust the parent object background's brightness by the given percentage (-100%…+100%).
LONG xoffset
offset to use when background is a pattern.
LONG yoffset
offset to use when background is a pattern.
LONG flags
none defined yet, set to 0 for now.

RESULT

The result value of this method is currently undefined.

SEE ALSO

MUIM_DrawBackground

MUIM_HandleEvent

NAME

MUIM_HandleEvent — V16, 0x80426d66 [For use within custom classes only]

SYNOPSIS

DoMethod(obj, MUIM_HandleEvent, struct IntuiMessage *imsg, LONG muikey, struct MUI_EventHandlerNode *ehn);

FUNCTION

This method is invoked whenever one of an event handlers trigger signals arrives. It's described in Area class context but does not really belong here.

INPUTS

struct IntuiMessage *imsg
pointer to a struct IntuiMessage that caused the event. Note well that this may be NULL in which case you simply not parse imsg.
LONG muikey
if the imsg translates to a predefined keystroke, this parameter holds the corresponding MUIKEY_XXXX value. Otherwise it will be MUIKEY_NONE.
struct MUI_EventHandlerNode *ehn
a pointer to the MUI_EventHandlerNode which caused this method to be called.

NOTES

You must not rely on imsg being non-NULL, regardless whether muikey is set or unset.

RESULT

The result is a bitfield. Currently, only one bit is defined:

  • MUI_EventHandlerRC_Eat Set this if this event was for you and you want MUI to stop calling other event handlers in the chain.

All other bits are reserved for future use and must be zero!

SEE ALSO

MUIM_Window_AddEventHandler

MUIM_HandleInput

NAME

MUIM_HandleInput — V4, 0x80422a1a [For use within custom classes only]

SYNOPSIS

DoMethod(obj, MUIM_HandleInput, struct IntuiMessage *imsg, LONG muikey);

FUNCTION

see developer documentation.

INPUTS

struct IntuiMessage *imsg
pointer to a struct IntuiMessage that caused the event. Note well that this may be NULL in which case you simply not parse imsg.
LONG muikey
if the imsg translates to a predefined keystroke, this parameter holds the corresponding MUIKEY_XXXX value. Otherwise it will be MUIKEY_NONE.



MUIM_Hide

NAME

MUIM_Hide — V4, 0x8042f20f [For use within custom classes only]

SYNOPSIS

DoMethod(obj, MUIM_Hide);

FUNCTION

see developer documentation.

MUIM_Layout

NAME

MUIM_Layout — V4, 0x8042845b

SYNOPSIS

DoMethod(obj, MUIM_Layout, LONG left, LONG top, LONG width, LONG height, ULONG flags);

FUNCTION

Since version 11 of muimaster.library, you have the ability to customize the way objects are placed in a group. Altough MUI features a very powerful builtin layout algorithm which serves well for almost all GUI related purposes, it might sometimes become handy to override this with custom code.

Imagine you want to build a multimedia document viewer which contains text objects, bitmap objects and buttons. An easy way for doing this is to simply create a subclass of group class which contains all the documents elements as MUI objects and which specifies a custom layout hook for the parent group. This hook is then responsible for placing the objects within the bounds of the parent group.

Implementing MUIM_Layout is basically the same as specifying a layout hook for groups, but also works for decendants of Area.mui. Your class is expected to let the superclass first do its layout stuff and afterwards place your own children in the rectangle _mleft(obj)/_mtop(obj)/ _mright(obj)/_mbottom(obj) using MUI_Layout().

INPUTS

LONG left
final left coordinate of the object.
LONG top
final top coordinate of the object.
LONG width
final width of the object.
LONG height
final height of the object.
ULONG flags
none defined yet, set to 0.

EXAMPLE

see MUI demo program Layout.c

SEE ALSO

muimaster.library/MUI_Layout(), MUIA_Group_LayoutHook

MUIM_Relayout

NAME

MUIM_Relayout — V21, 0x8042b377

SYNOPSIS

DoMethod(obj, MUIM_Relayout, ULONG flags);

FUNCTION

Perform a full relayout of the object in case it is visible. Actually the object will be completely hidden and shown again to trigger a full redraw as well.

INPUTS

ULONG flags
none defined yet, set to 0.

RESULT

A boolean value indicating whether the relayout succeeded or not.

SEE ALSO

MUIM_Cleanup, MUIM_Hide, MUIM_Setup, MUIM_Show

MUIM_Setup

NAME

MUIM_Setup — V4, 0x80428354 [For use within custom classes only]

SYNOPSIS

DoMethod(obj, MUIM_Setup, struct MUI_RenderInfo *RenderInfo);

FUNCTION

see developer documentation.

INPUTS

struct MUI_RenderInfo *RenderInfo
a pointer to the object's MUI_RenderInfo structure.



MUIM_Show

NAME

MUIM_Show — V4, 0x8042cc84 [For use within custom classes only]

SYNOPSIS

DoMethod(obj, MUIM_Show, struct LongRect *clip);

FUNCTION

see developer documentation.

INPUTS

struct LongRect *clip
the rectangle which contains the area to be shown.



MUIM_Text

NAME

MUIM_Text — V20, 0x8042ee70

SYNOPSIS

DoMethod(obj, MUIM_Text, LONG left, LONG top, LONG width, LONG height, CONST_STRPTR text, LONG len, CONST_STRPTR preparse, LONG ulchar);

FUNCTION

This function is a preferred way to render text inside the object. It uses the object's font and it's color (if not specified in the string itself).

INPUTS

LONG left
rectangle to render the text into.
LONG top
rectangle to render the text into.
LONG width
rectangle to render the text into.
LONG height
rectangle to render the text into.
CONST_STRPTR text
the text to be rendered.
LONG len
the number of characters to be respected, pass -1 to render the full string.
CONST_STRPTR preparse
an optional preparse string, may be NULL.
LONG ulchar
character to be underlined (i.e. as shortcut), pass 0 for no underlining.

NOTES

All facilities of MUI's text engine are allowed for both the text and the preparse string. Refer to MUIA_Text_Contents for all possible sequences.

Make sure to specify a rectangle which resides in the object's area, otherwise the object's frame might be overdrawn.

It is recommended to calculate the text's dimensions via MUIM_TextDim, i.e. during MUIM_AskMinMax, to ensure that the text is fully visible and will not be drawn beyond the object's area.

EXAMPLE

/* show "foo bar" centered in a 150x20 rectangle at x=10, y=10 within the */
/* object's area */
/* the 'b' of 'bar' will be underlined */
DoMethod(obj, MUIM_Text, _mleft(obj)+10, _mtop(obj)+10, 150, 20,
         "foo bar", -1, "\033c", 'b');

SEE ALSO

MUIM_TextDim, MUIA_Text_Contents, MUIA_Text_PreParse

MUIM_TextDim

NAME

MUIM_TextDim — V20, 0x80422ad7

SYNOPSIS

DoMethod(obj, MUIM_TextDim, CONST_STRPTR text, LONG len, CONST_STRPTR preparse, ULONG flags);

FUNCTION

Use this function to measure the area which will be required to render a text of the given length.

All facilities of MUI's text engine are allowed for both the text and the preparse string. Refer to MUIA_Text_Contents for all possible sequences.

INPUTS

CONST_STRPTR text
the text to be measured.
LONG len
the number of characters to be respected, pass -1 to measure the full string.
CONST_STRPTR preparse
an optional preparse string, may be NULL.
ULONG flags
currently unused, pass 0.

RESULT

A 32bit value combined of the calculated width and height of the text string. Use the DIM2WIDTH() and DIM2HEIGHT() macros to extract the width and height values.

SEE ALSO

MUIM_Text, MUIA_Text_Contents, MUIA_Text_PreParse

MUIM_UpdateConfig

NAME

MUIM_UpdateConfig — V20, 0x8042b0a9

SYNOPSIS

DoMethod(obj, MUIM_UpdateConfig, ULONG cfgid, LONG redrawcount, Object *redrawobj[64], UBYTE redrawflags[64]);

FUNCTION

This is the central method of MUI's real time prefs. This method will be called whenever the user changed a configuration item in MUI's prefs application. It is your task to react accordingly to this change to give a visual feedback about the change (i.e. redraw yourself). See Animals demo for details.

INPUTS

ULONG cfgid
ID of the modified configuration item.



MUIM_WhichPointerType

NAME

MUIM_WhichPointerType — V20, 0x8042e212

SYNOPSIS

DoMethod(obj, MUIM_WhichPointerType, LONG mx, LONG my);

FUNCTION

Return a mouse pointer type for complex objects depending on the current mouse position.

INPUTS

LONG mx
current x position of mouse.
LONG my
current y position of mouse.

RESULT

Return the value of the mouse pointer type to be used at the given coordinates. You may return all possible types including custom pointer images created by pointerclass.

EXAMPLE

A detailed example can be found in the source code of the Pointers demo application.

SEE ALSO

MUIA_PointerType


Copyright © 1992-2006 by Stefan Stuntz
Copyright © 2006-2017 by Thore Böckelmann, Jens Maus

MUI for AmigaOS - MUI-Autodocs

Updated: 13-Jul-2017

Last modified 5 months ago Last modified on Mar 27, 2017, 3:50:26 PM