GUI and Interaction Messages Manual

About

Communication between different parts of the Cinema 4D GUI happens through multiple messages. These messages are sent to GeDialog and GeUserArea elements:

Messages are represented by BaseContainer objects that store the parameters of the message. The ID of the message is typically the ID of the BaseContainer (BaseContainer::GetId()). See BaseContainer Manual.

For details on GeDialog and GeUserArea see GeDialog Manual and GeUserArea Manual.

// This example catches a message to set the cursor when the mouse is over the user area.
Int32 Message(const BaseContainer& msg, BaseContainer& result)
{
// messages are identified by the BaseContainer ID
switch (msg.GetId())
{
{
result.SetString(RESULT_BUBBLEHELP, "This is an example GeUserArea"_s);
return true;
}
}
return GeUserArea::Message(msg, result);
}

Message Redirection

All message are first sent to the object's "Message" function (GeDialog::Message(), GeUserArea::Message()). If the messages are not handled in the implementation of the "Message" function they will be also handled in the base-class. Certain messages are re-directed to dedicated functions.

GeDialog

Several messages sent to a GeDialog will invoke these member functions:

MessageFunction
BFM_INITGeDialog::CreateLayout()
BFM_DESTROYGeDialog::DestroyWindow()
BFM_INITVALUESGeDialog::InitValues()
BFM_SYNC_MESSAGEGeDialog::CoreMessage()
BFM_CORE_MESSAGEGeDialog::CoreMessage()
BFM_ACTIONGeDialog::Command()
BFM_CHECKCLOSEGeDialog::AskClose()
BFM_TIMER_MESSAGEGeDialog::Timer()

GeUserArea

Several messages sent to a GeUserArea will invoke these member functions:

MessageFunction
BFM_INITGeUserArea::Init()
BFM_INITVALUESGeUserArea::InitValues()
BFM_CALCSIZEGeUserArea::GetMinSize()
BFM_SIZEDGeUserArea::Sized()
BFM_DRAWGeUserArea::DrawMsg()
BFM_INPUTGeUserArea::InputEvent()
BFM_TIMER_MESSAGEGeUserArea::Timer()
BFM_SYNC_MESSAGEGeUserArea::CoreMessage()
BFM_CORE_MESSAGEGeUserArea::CoreMessage()

Return Values

Messages can be sent to receive information from the target element. In some cases the message must explicitly state that it requests a result.

// This example in a GeDialog requests the cursor position from a text edit field.
// prepare message
message.SetBool(BFM_REQUIRESRESULT, true);
// send message
const GeData res = this->SendMessage(3000, message);
// get position
const Int32 pos = res.GetInt32();
ApplicationOutput("Cursor Pos.: " + String::IntToString(pos));

User Interaction

Cursor

When the mouse cursor is moved over a GeDialog or GeUserArea a message is sent to these elements. The reaction to this message allows to define the cursor and some help text.

  • BFM_GETCURSORINFO: Message is sent to a GUI element when the cursor is moved over it.

The parameters of the message are:

Note
The message BFM_GETCURSORINFO also contains BFM_DRAG_SCREENX and BFM_DRAG_SCREENY.
// This example sets the cursor when the mouse is over the current GUI element.
{
result.SetString(RESULT_BUBBLEHELP_TITLE, "Bubblehelp Title"_s);
result.SetString(RESULT_BUBBLEHELP, "This is the bubble help text."_s);
return true;
}

Compare also ToolData::GetCursorInfo(), SceneHookData::GetCursorInfo(), etc.

The message BFM_CURSORINFO_REMOVE can be sent by a custom callback function to inform a user area that the cursor has left the area:

// This example user area registers a callback function with RemoveLastCursorInfo().
// This function is called when the cursor leaves the user area. It is used to send the
// message BFM_CURSORINFO_REMOVE back to the user area to inform it about the event.
// declarations
static void RemoveCursorInfo();
class RemoveCursorUserArea;
static RemoveCursorUserArea* g_userArea = nullptr; // static variable storing pointer to a user area
// user area will display a different color depending if the cursor is over the area or not
class RemoveCursorUserArea : public GeUserArea
{
public:
RemoveCursorUserArea()
{
if (g_userArea == this)
g_userArea = nullptr;
};
~RemoveCursorUserArea() { };
{
// messages are identified by the BaseContainer ID
switch (msg.GetId())
{
{
// register RemoveCursorInfo() callback
g_userArea = this;
RemoveLastCursorInfo(RemoveCursorInfo);
_cursorInside = true;
Redraw();
return true;
}
{
// message "BFM_CURSORINFO_REMOVE" sent by RemoveCursorInfo()
_cursorInside = false;
Redraw();
break;
}
}
return GeUserArea::Message(msg, result);
}
void DrawMsg(Int32 x1, Int32 y1, Int32 x2, Int32 y2, const BaseContainer& msg)
{
SetClippingRegion(x1, y1, x2, y2);
// gadget color is controlled by the cursor position
if (_cursorInside)
DrawSetPen(Vector(1.0, 0.0, 0.0));
else
DrawSetPen(Vector(0.0, 1.0, 0.0));
DrawRectangle(x1, y1, x2, y2);
}
private:
Bool _cursorInside = false; // set to true if the cursor is over the user area
};
// function will be called by the user area when the cursor left its area
static void RemoveCursorInfo()
{
if (g_userArea == nullptr)
return;
// send message to the user area
g_userArea->Message(BaseContainer(BFM_CURSORINFO_REMOVE), bc);
}

Focus

A GeDialog or GeUserArea is informed when it receives or looses the focus:

// This example catches focus related messages in GeDialog::Message().
// Depending on the focus, a gadget is enabled or disabled.
{
Enable(1000, true);
break;
}
{
Enable(1000, false);
break;
}

Close Dialog

A GeDialog is informed when it is about to be closed. One has to return false if it is safe to close the dialog.

GeDialog Gadget Interaction

A GeDialog is informed when any kind of interaction with some hosted gadget starts or ends:

Note
These messages are useful to stop threads that work on the scene or to create undo steps. See Undo System Manual.
// This example catches two messages in GeDialog::Message()
// to check if any interaction with a gadget started or ended.
{
ApplicationOutput("Interaction start"_s);
break;
}
{
ApplicationOutput("Interaction end"_s);
break;
}

When a gadget or custom GUI element is changed by the user it sends the message BFM_ACTION to the parent dialog.

The parameters of the message are:

// This example sends the BFM_ACTION message from a GeUserArea to the parent GUI element.
// This message can be caught in GeDialog::Message() or GeDialog::Command().
action.SetInt32(BFM_ACTION_ID, GetId());
SendParentMessage(action);
// This example sends a message from a GeDialog (iCustomGui)
// to the parent GeDialog to inform about change of stored value.
// construct the message
message.SetInt32(BFM_ACTION_ID, GetId());
message.SetData(BFM_ACTION_VALUE, _value);
// send the message
SendParentMessage(message);
// This example catches an interaction with an edit number field in GeDialog::Command().
// If the user clicked with the right mouse button on the number field's arrows,
// the value BFM_ACTION_RESET is set.
if (id == ID_EDIT_NUMBER)
{
{
// right click on the number field's arrows
// set the value to a pre-defined default value
const Float defaultValue = 0.5;
SetPercent(ID_EDIT_NUMBER, defaultValue, 0.0, 100.0, 1.0);
}
else
{
// just pass through the given value
const Float value = msg.GetFloat(BFM_ACTION_VALUE);
SetPercent(ID_EDIT_NUMBER, value, 0.0, 100.0, 1.0);
}
}

Mouse and Keyboard Interaction

Both GeDialog and GeUserArea are informed on keyboard and mouse user interaction events.

The parameters of the message are:

// This example checks in GeUserArea::InputEvent() if the right mouse button was pressed.
const Int32 device = msg.GetInt32(BFM_INPUT_DEVICE);
const Int32 channel = msg.GetInt32(BFM_INPUT_CHANNEL);
// check if this is a mouse event triggered by the right mouse button
const Bool deviceIsMouse = device == BFM_INPUT_MOUSE;
const Bool channelIsRight = channel == BFM_INPUT_MOUSERIGHT;
if (deviceIsMouse && channelIsRight)
{
ApplicationOutput("Right mouse button pressed.");
const Int32 qualifier = msg.GetInt32(BFM_INPUT_QUALIFIER);
if (qualifier & QCTRL)
ApplicationOutput("Right mouse button with CTRL pressed.");
return true;
}

The input from keyboard interactions is either a character or some special key:

// This example catches keyboard events in GeUserArea::InputEvent().
const Int32 device = msg.GetInt32(BFM_INPUT_DEVICE);
if (device == BFM_INPUT_KEYBOARD)
{
const Int32 channel = msg.GetInt32(BFM_INPUT_CHANNEL);
if (channel == KEY_ENTER)
ApplicationOutput("Enter!");
const String key = msg.GetString(BFM_INPUT_ASC);
// check if the String contains any content
if (key.IsPopulated())
ApplicationOutput("Key: " + key);
return true;
}

Further details on the event are stored in these parameters:

// This example handles some mouse interaction in GeUserArea::InputEvent().
// get device and channel
const Int32 device = msg.GetInt32(BFM_INPUT_DEVICE);
const Int32 channel = msg.GetInt32(BFM_INPUT_CHANNEL);
// check if this is a mouse event triggered by the left mouse button
const Bool deviceIsMouse = device == BFM_INPUT_MOUSE;
const Bool channelIsLeft = channel == BFM_INPUT_MOUSELEFT;
if (deviceIsMouse && channelIsLeft)
{
// check if double click
{
// get the cursor position
Global2Local(&mx, &my);
ApplicationOutput("Double click at " + String::IntToString(mx) + " - " + String::IntToString(my));
return true;
}
}

Drag and Drop

Both GeDialog and GeUserArea are informed on drag and drop operations onto their area:

The parameters of the message are:

Different types of elements can be dragged:

See also Drag and Drop and Drag and Drop.

// This example receives a drag & drop message in GeUserArea::Message().
// If the dragged element is a command (from the "Customize Commands" dialog),
// the command is executed.
{
// check drag area
if (!CheckDropArea(msg, true, true))
break;
Int32 type;
void* data = nullptr;
// get the drag data
if (!GetDragObject(msg, &type, &data))
return false;
if (type == DRAGTYPE_COMMAND)
{
// check if the drag has finished
{
// end of drag
// get command ID and execute the command
const Int32 ID = msg.GetInt32(BFM_DRAG_DATA_NEW);
return true;
}
else
{
// while in drag show cursor with question mark
return SetDragDestination(MOUSE_QUESTION);
}
}
return false;
}

Description Notifications

A custom GUI element can be used to display a parameter of a NodeData based plugin the in the Attribute Manager. It is possible to send a message from the custom GUI to that NodeData based plugin. This can be used to inform the plugin on what internal data specificity was changed.

See also Attribute Manager Interaction.

// This example shows some part of a custom GUI that has a color picker that defines
// the color of some of it's elements. When this color is changed a message is sent
// to the host NodeData based plugin (assuming that the custom GUI is used by the
// Attribute Manager to display a parameter).
// Update GUI
this->InitValues();
// get the current color
Vector color;
Float brightness;
GetColorField(COLOR_ID, color, brightness);
// store message data
BaseContainer messageContent;
messageContent.SetVector(MSG_DESCRIPTION_COLORSTRING_COLOR, color);
// prepare message
message.SetInt32(BFM_ACTION_ID, GetId());
message.SetInt32(BFM_ACTION_VALUE, MSG_DESCRIPTION_COLORSTRING_COLORCHANGE);
message.SetInt32(MSG_DESCRIPTION_CUSTOMGUI_NOTIFICATION_ID, ID_CUSTOMGUI_COLORSTRING);
// send message
SendParentMessage(message);

Layout Messages

Layout Change

A GeUserArea can inform the parent dialog when it changed its size:

A GeDialog can be part of a layout and is created when that layout is loaded. To restore a given state of that GeDialog, internal data of that dialog must be stored with the layout. This internal data is received and reset using these messages:

Note
Typically the group weights are stored here. See Weights.
// This example catches two layout messages in GeDialog::Message().
// The messages are sent when the layout is saved to a file or when it is loaded from a file.
{
// store custom data
result = BaseContainer(0);
result.SetInt32(1000, 123);
return true;
}
{
if (bc)
{
const Int32 custom = bc->GetInt32(1000);
ApplicationOutput("Got custom data: " + String::IntToString(custom));
return true;
}
break;
}

Weights

A GeDialog defines its layout using groups with multiple columns/rows. The weights of a group define the relative scale of these columns/rows. When the user changes the scale a message is sent to the GeDialog:

  • BFM_WEIGHTS_CHANGED: Sent when group weights changed. The group ID is stored with this message ID.

See also GeDialog Groups.

// This example catches in GeDialog::Message() the event when the weights
// of a group are changed. The current weights are stored in a BaseContainer.
// When the layout is saved the weights are stored as custom layout data.
// save the weights
{
GroupWeightsSave(WEIGHT_GROUP, _weights);
break;
}
// store the weights
{
result = BaseContainer(0);
result.SetContainer(10000, _weights);
return true;
}
// restore the weights
{
if (bc)
{
// access the sub-container with the ID 10000
const BaseContainer* const weightsContainer = bc->GetContainerInstance(10000);
if (weightsContainer)
_weights = *weightsContainer;
GroupWeightsLoad(WEIGHT_GROUP, _weights);
return true;
}
break;
}

Fading

A GeUserArea can support a dynamic fading effect. After GeUserArea::ActivateFading() was called, Cinema 4D sends the BFM_FADE message to the user area for the duration of the fading operation.

See Drawing Operations.

// This example shows a GeUserArea that is "fading".
// When the cursor is over the user area the fading is activated.
// Cinema 4D will then send the message BFM_FADE to the user area so
// it can interpolate a color and use this color to redraw itself.
class FadingUserArea : public GeUserArea
{
public:
FadingUserArea() { };
~FadingUserArea() { };
{
// messages are identified by the BaseContainer ID
switch (msg.GetId())
{
{
// cursor is over the user area
// start fading
return true;
}
case BFM_FADE:
{
// receive fade message and update the COLOR_BG used in DrawMsg()
const Float percentage = msg.GetFloat(BFM_FADE);
// redraw using the updated COLOR_BG
Redraw();
return true;
}
}
return GeUserArea::Message(msg, result);
}
void DrawMsg(Int32 x1, Int32 y1, Int32 x2, Int32 y2, const BaseContainer& msg)
{
SetClippingRegion(x1, y1, x2, y2);
// draw background with COLOR_BG
DrawRectangle(x1, y1, x2, y2);
// draw text
DrawText("User Area"_s, 0, 0, DRAWTEXT_HALIGN_LEFT);
}
};

Draw

The message BFM_DRAW is sent to a GeUserArea to draw into the Cinema 4D GUI. The message will call GeUserArea::DrawMsg().

The clipping dimensions are stored in these parameters:

The draw reason is also stored:

// This example in GeUserArea::DrawMsg() skips the redraw if only the focus has changed.
const Int32 reason = msg.GetInt32(BFM_DRAW_REASON);
// check if DrawMsg() was called because the focus changed
const Bool reasonGotFocus = reason == BFM_GOTFOCUS;
const Bool reasonLostFocurs = reason == BFM_LOSTFOCUS;
if (reasonGotFocus || reasonLostFocurs)
return;

Visibility

Dialogs and user areas are informed when they become visible:

  • BFM_VISIBLE_ON: Sent when the element comes to front after tabbing invisible.
  • BFM_VISIBLE_OFF: Sent when the element went back (another tab becomes visible).

Specific GUI Elements

Some messages can only be sent to specific elements or are only sent by specific elements.

Text Edit Fields

Text edit field messages:

// This example sets the string of a text edit gadget that is part of a GeDialog.
// Then a message is sent to the gadget to set the cursor position.
// set the text of the edit field.
const String text { "Hello World" };
SetString(ID_TEXTEDIT, text);
// sets the cursor to the end of the new text
bc.SetInt32(1, (Int32)text.GetLength());
SendMessage(ID_TEXTEDIT, bc);
// set focus
Activate(ID_TEXTEDIT);

Multi-line edit fields messages:

Messages to access the internally stored undo stack of a multi-line edit field:

It is also possible to send messages from the IDM list to the multi-line edit field.

// This example GeDialog includes a multi-line edit field and two buttons.
// The two buttons can be used to send "Undo" and "Redo" commands to the
// multi-line field. The buttons are enabled or disabled depending on the
// undo stack of the field.
Bool CreateLayout()
{
SetTitle("Simple Script Manager"_s);
// add a multi line text field
AddMultiLineEditText(ID_MULTILINE_EDIT, BFH_SCALEFIT, 0, 200, style);
// set some python code
SetString(ID_MULTILINE_EDIT, "import c4d\n\nprint(\"hello world\")\n"_s);
// add two buttons for "Undo" and "Redo"
AddButton(ID_UNDO_BUTTON, BFH_SCALEFIT, 0, 10, "Undo"_s);
AddButton(ID_REDO_BUTTON, BFH_SCALEFIT, 0, 10, "Redo"_s);
// use a timer to check the undo stack of the text field
this->SetTimer(250);
return true;
}
Bool Command(Int32 id, const BaseContainer& msg)
{
if (id == ID_UNDO_BUTTON)
{
// when "Undo" button was pressed, send IDM_UNDO
// to the multi line text field
SendMessage(ID_MULTILINE_EDIT, BaseContainer(IDM_UNDO));
CheckUndoState();
}
if (id == ID_REDO_BUTTON)
{
// when "Redo" button was pressed, send IDM_REDO
// to the multi line text field
SendMessage(ID_MULTILINE_EDIT, BaseContainer(IDM_REDO));
CheckUndoState();
}
return GeDialog::Command(id, msg);
}
void Timer(const BaseContainer& msg)
{
CheckUndoState();
}
// ----------------------------------------------------------------------------------------
// Checks the current undo stack of the multi-line edit text.
// Depending on the stack the "Undo" and "Redo" buttons are enabled.
// ----------------------------------------------------------------------------------------
void CheckUndoState()
{
// send message to get data
getUndoLevelMsg.SetBool(BFM_REQUIRESRESULT, true);
const GeData res = SendMessage(ID_MULTILINE_EDIT, getUndoLevelMsg);
// check if the message result is a BaseContainer
if (res.GetType() == DA_CONTAINER)
{
BaseContainer* stat = res.GetContainer();
if (stat)
{
// get undo stack size and current level
const Int32 undoStackCount = stat->GetInt32(BFM_EDITFIELD_UNDOSTAT_COUNT);
const Int32 currentLevel = stat->GetInt32(BFM_EDITFIELD_UNDOSTAT_UNDOLEVEL);
// enable and disable buttons accordingly
if (currentLevel > 0)
Enable(ID_UNDO_BUTTON, true);
else
Enable(ID_UNDO_BUTTON, false);
// check if the current level is not the latest undo-level
if (currentLevel < (undoStackCount - 1))
Enable(ID_REDO_BUTTON, true);
else
Enable(ID_REDO_BUTTON, false);
}
}
}

Status Bar

The message BFM_SETSTATUSBAR can be sent to edit the status bar of a scroll group or a progress bar custom GUI element:

The parameters of this message are:

// This example sends a message to a CUSTOMGUI_PROGRESSBAR gadget to update the status bar.
m.SetBool(BFM_STATUSBAR_PROGRESSON, true);
m.SetFloat(BFM_STATUSBAR_PROGRESS, _progress);
m.SetData(BFM_STATUSBAR_TINT_COLOR, Vector(1.0 - _progress, _progress, 0.0));
SendMessage(ID_STATUSBAR, m);
// This example sends a message to a scroll group to set the text of its status bar.
bc.SetData(BFM_STATUSBAR_TXT, "Some Text");
bc.SetData(BFM_STATUSBAR_HELP, "More Text");
SendMessage(ID_SCROLLGROUP, bc);

Pop Up

A message is sent from a popup button:

// This example adds a pop up button to the layout in GeDialog::CreateLayout().
AddPopupButton(ID_POPUP, BFH_LEFT, 10, 10);
AddChild(ID_POPUP, 1, "Child 0"_s);
AddChild(ID_POPUP, 2, "Child 1"_s);
// This example catches a message in GeDialog::Message() after the pop up button was pressed
// (but before the pop up menu is created).
{
const Int32 ID = msg.GetInt32(BFM_ACTION_ID);
if (ID == ID_POPUP)
{
ApplicationOutput("The pop up button was pressed"_s);
}
break;
}
// This example catches the result in GeDialog::Command() after
// something was selected in the pop up button's pop up menu.
if (id == ID_POPUP)
{
const Int32 selectedItem = msg.GetInt32(BFM_ACTION_VALUE);
ApplicationOutput("The item " + String::IntToString(selectedItem) + " was selected");
}

Scroll Group

A scroll group informs the parent dialog when it was scrolled:

Custom GUI Elements

The base class for custom GUI elements (used to display NodeData parameters in the Attribute Manager) is iCustomGui which is based on GeDialog. Such custom GUI elements receive these messages when the used "User Interface" is changed in the Attribute Manager. The custom GUI can then store the ID of the currently active gadget:

// This example stores the ID of the gadget currently in focus.
{
result.SetInt32(0, _activeID); // store ID of active gadget
return true;
}
{
const Int32 ID = msg.GetInt32(0);
Activate(ID); // active stored ID
return true;
}

Core Messages

Both GeDialog and GeUserArea receive core messages. These messages call GeDialog::CoreMessage() or GeUserArea::CoreMessage().

See the Core Messages Manual.

// This example catches EVMSG_ASYNCEDITORMOVE in a GeDialog.
{
// check if this core message is new
if (CheckCoreMessage(bc))
{
const Int movement = (Int)bc.GetVoid(BFM_CORE_PAR1);
switch (movement)
{
case MOVE_START: { ApplicationOutput("Start Movement"); break; }
case MOVE_CONTINUE: { ApplicationOutput("Continue Movement"); break; }
case MOVE_END: { ApplicationOutput("End Movement"); break; }
}
}
break;
}

Further Reading

COLOR_BG
@ COLOR_BG
Definition: c4d_colors.h:16
BFM_EDITFIELD_UNDOSTAT_UNDOLEVEL
@ BFM_EDITFIELD_UNDOSTAT_UNDOLEVEL
Int32 The current undo level.
Definition: gui.h:1006
GeUserArea::DrawSetPen
void DrawSetPen(const Vector &color)
DA_CONTAINER
@ DA_CONTAINER
BaseContainer.
Definition: c4d_gedata.h:49
BFM_GOTFOCUS
@ BFM_GOTFOCUS
Item got the focus.
Definition: gui.h:621
BaseContainer::SetData
GeData * SetData(Int32 id, const GeData &n)
Definition: c4d_basecontainer.h:255
BFM_FADE
@ BFM_FADE
Definition: gui.h:984
BFH_LEFT
@ BFH_LEFT
Aligned to the left. 1<<3.
Definition: gui.h:306
BFM_INPUT_MOUSERIGHT
@ BFM_INPUT_MOUSERIGHT
Right mouse button.
Definition: gui.h:693
Int
maxon::Int Int
Definition: ge_sys_math.h:64
BFM_EDITFIELD_UNDOSTAT_COUNT
@ BFM_EDITFIELD_UNDOSTAT_COUNT
Int32 The undo stack size.
Definition: gui.h:1005
GeUserArea::DrawSetFont
void DrawSetFont(Int32 fontid)
BFM_INPUT_QUALIFIER
@ BFM_INPUT_QUALIFIER
Int32 A bit mask with the qualifiers at the time when the event occurred: QUALIFIER
Definition: gui.h:684
MOVE_END
#define MOVE_END
Move ended. par2 == ESC.
Definition: ge_prepass.h:2579
BFM_ACTION_RESET
@ BFM_ACTION_RESET
Bool Reset to default value on right-click of input field arrows.
Definition: gui.h:728
DR_MULTILINE_SYNTAXCOLOR
@ DR_MULTILINE_SYNTAXCOLOR
Python syntax highlighting.
Definition: gui.h:314
DR_MULTILINE_PYTHON
@ DR_MULTILINE_PYTHON
Python line return handling.
Definition: gui.h:320
GeData::GetType
Int32 GetType(void) const
Definition: c4d_gedata.h:407
BaseContainer::SetInt32
void SetInt32(Int32 id, Int32 l)
Definition: c4d_basecontainer.h:505
DR_MULTILINE_STATUSBAR
@ DR_MULTILINE_STATUSBAR
Display a statusbar with the cursor position.
Definition: gui.h:315
BFM_SETSTATUSBAR
@ BFM_SETSTATUSBAR
To set a statusbar (e.g. inside a SCROLLGROUP (dialog element)):
Definition: gui.h:815
BaseContainer::SetVector
void SetVector(Int32 id, const Vector &v)
Definition: c4d_basecontainer.h:555
BaseContainer::SetString
void SetString(Int32 id, const maxon::String &s)
Definition: c4d_basecontainer.h:569
MSG_DESCRIPTION_CUSTOMGUI_NOTIFICATION_ID
#define MSG_DESCRIPTION_CUSTOMGUI_NOTIFICATION_ID
The custom GUI ID in the message container for MSG_DESCRIPTION_CUSTOMGUI_NOTIFICATION.
Definition: c4d_baselist.h:404
BFM_ACTION_VALUE
@ BFM_ACTION_VALUE
GeData Action value.
Definition: gui.h:723
Float
maxon::Float Float
Definition: ge_sys_math.h:66
GeUserArea::DrawText
void DrawText(const maxon::String &txt, Int32 x, Int32 y, Int32 flags=(0|(0<< 4)))
DRAWTEXT_HALIGN_LEFT
#define DRAWTEXT_HALIGN_LEFT
Align to the left.
Definition: c4d_gui.h:188
BFM_INPUT_DOUBLECLICK
@ BFM_INPUT_DOUBLECLICK
Bool Double click.
Definition: gui.h:716
BFM_INPUT_KEYBOARD
@ BFM_INPUT_KEYBOARD
Keyboard.
Definition: gui.h:688
GeUserArea::DrawMsg
virtual void DrawMsg(Int32 x1, Int32 y1, Int32 x2, Int32 y2, const BaseContainer &msg)
BaseContainer::GetContainerInstance
BaseContainer * GetContainerInstance(Int32 id)
Definition: c4d_basecontainer.h:425
BFM_DRAW_REASON
@ BFM_DRAW_REASON
BaseContainer Message which started the redraw.
Definition: gui.h:566
COLOR_BG_HIGHLIGHT
@ COLOR_BG_HIGHLIGHT
Definition: c4d_colors.h:329
BFM_LOSTFOCUS
@ BFM_LOSTFOCUS
Item lost the focus.
Definition: gui.h:622
BFM_DRAGRECEIVE
@ BFM_DRAGRECEIVE
Drag receive. (See DragAndDrop.)
Definition: gui.h:749
GeUserArea::SetClippingRegion
void SetClippingRegion(Int32 x, Int32 y, Int32 w, Int32 h)
BFM_INPUT_X
@ BFM_INPUT_X
Float X value.
Definition: gui.h:703
IDM_UNDO
#define IDM_UNDO
Undo.
Definition: ge_prepass.h:3627
COLOR_TRANS
@ COLOR_TRANS
Definition: c4d_colors.h:14
maxon::String::IsPopulated
Bool IsPopulated() const
Definition: string.h:1405
BFM_LAYOUT_GETDATA
@ BFM_LAYOUT_GETDATA
Definition: gui.h:959
BaseContainer::GetFloat
Float GetFloat(Int32 id, Float preset=0.0) const
Definition: c4d_basecontainer.h:335
BFM_ACTION
@ BFM_ACTION
One of the child elements made any action:
Definition: gui.h:721
BFM_INPUT_DEVICE
@ BFM_INPUT_DEVICE
Int32 Device:
Definition: gui.h:686
BaseContainer::SetBool
void SetBool(Int32 id, Bool b)
Definition: c4d_basecontainer.h:498
QCTRL
@ QCTRL
Definition: gui.h:39
BFM_INTERACTEND
@ BFM_INTERACTEND
Sent when user interaction ends.
Definition: gui.h:920
BFM_STATUSBAR_HELP
@ BFM_STATUSBAR_HELP
String Second text. (Help.)
Definition: gui.h:821
EVMSG_ASYNCEDITORMOVE
#define EVMSG_ASYNCEDITORMOVE
The user moved something in the editor window. Managers should update things like position fields.
Definition: ge_prepass.h:2573
IDM_REDO
#define IDM_REDO
Redo.
Definition: ge_prepass.h:3628
MOUSE_POINT_HAND
static const Int32 MOUSE_POINT_HAND
Point hand cursor.
Definition: ge_prepass.h:2505
BFM_REQUIRESRESULT
@ BFM_REQUIRESRESULT
Set to true in the passed container for GeDialog::SendMessage to return a value from the message.
Definition: gui.h:1008
GeUserArea::DrawSetTextCol
void DrawSetTextCol(Int32 fg, Int32 bg)
MOVE_CONTINUE
#define MOVE_CONTINUE
Move continued.
Definition: ge_prepass.h:2578
BFM_STATUSBAR_TXT
@ BFM_STATUSBAR_TXT
String First text.
Definition: gui.h:818
BaseContainer::GetId
Int32 GetId() const
Definition: c4d_basecontainer.h:131
BFM_LAYOUT_SETDATA
@ BFM_LAYOUT_SETDATA
Receive the container saved with BFM_LAYOUT_GETDATA when loading a layout.
Definition: gui.h:961
BFM_INPUT_MOUSE
@ BFM_INPUT_MOUSE
Mouse.
Definition: gui.h:687
GeUserArea::AdjustColor
void AdjustColor(Int32 colorid, Int32 highlightid, Float percent)
GeUserArea::Message
virtual Int32 Message(const BaseContainer &msg, BaseContainer &result)
BFM_INPUT_MOUSELEFT
@ BFM_INPUT_MOUSELEFT
Left mouse button.
Definition: gui.h:692
String
Definition: c4d_string.h:38
String::IntToString
static String IntToString(Int32 v)
Definition: c4d_string.h:495
BFM_STATUSBAR_PROGRESS
@ BFM_STATUSBAR_PROGRESS
Float Between 0.0 and 1.0.
Definition: gui.h:819
BFH_SCALEFIT
@ BFH_SCALEFIT
Scale fit. BFH_SCALE|BFH_FIT.
Definition: gui.h:310
maxon::Vec3< maxon::Float64, 1 >
BFM_INPUT_ASC
@ BFM_INPUT_ASC
String Contains the Unicode input from keyboard.
Definition: gui.h:689
GeData::GetInt32
Int32 GetInt32(void) const
Definition: c4d_gedata.h:427
StopAllThreads
void StopAllThreads(void)
RemoveLastCursorInfo
Bool RemoveLastCursorInfo(LASTCURSORINFOFUNC func)
CallCommand
void CallCommand(Int32 id, Int32 subid=0)
RESULT_CURSOR
@ RESULT_CURSOR
Int32 Mouse cursor: MOUSE
Definition: gui.h:542
GeUserArea::OffScreenOn
Bool OffScreenOn(void)
GeData
Definition: c4d_gedata.h:82
DR_MULTILINE_MONOSPACED
@ DR_MULTILINE_MONOSPACED
Monospaced font.
Definition: gui.h:313
Int32
maxon::Int32 Int32
Definition: ge_sys_math.h:60
GeDialog::Command
virtual Bool Command(Int32 id, const BaseContainer &msg)
GeUserArea::Redraw
void Redraw(Bool threaded=false)
ApplicationOutput
#define ApplicationOutput(formatString,...)
Definition: debugdiagnostics.h:207
RESULT_BUBBLEHELP
@ RESULT_BUBBLEHELP
String Bubble help text.
Definition: gui.h:543
BaseContainer::SetId
void SetId(Int32 c_id)
Definition: c4d_basecontainer.h:137
DR_MULTILINE_WORDWRAP
@ DR_MULTILINE_WORDWRAP
Word wrap multi-line field.
Definition: gui.h:321
FONT_MONOSPACED
@ FONT_MONOSPACED
Monospaced font.
Definition: gui.h:26
DRAGTYPE_COMMAND
@ DRAGTYPE_COMMAND
Destination drag for command.
Definition: gui.h:756
BaseContainer::GetVoid
void * GetVoid(Int32 id, void *preset=nullptr) const
Definition: c4d_basecontainer.h:343
BaseContainer::GetBool
Bool GetBool(Int32 id, Bool preset=false) const
Definition: c4d_basecontainer.h:295
BFM_INPUT_Y
@ BFM_INPUT_Y
Float Y value.
Definition: gui.h:704
COLOR_CONSOLE_TEXT
@ COLOR_CONSOLE_TEXT
Definition: c4d_colors.h:94
BFM_GETCURSORINFO
@ BFM_GETCURSORINFO
Definition: gui.h:539
BFM_EDITFIELD_GETCURSORPOS
@ BFM_EDITFIELD_GETCURSORPOS
Int32 Return the cursor position in an edit field.
Definition: gui.h:969
BFM_ACTION_ID
@ BFM_ACTION_ID
Int32 ID of the dialog element that triggered the action.
Definition: gui.h:722
Vector
maxon::Vec3< maxon::Float64, 1 > Vector
Definition: ge_math.h:145
BFM_STATUSBAR_PROGRESSON
@ BFM_STATUSBAR_PROGRESSON
Bool Statusbar active.
Definition: gui.h:817
MOVE_START
#define MOVE_START
Move started.
Definition: ge_prepass.h:2577
MSG_DESCRIPTION_CUSTOMGUI_NOTIFICATION
#define MSG_DESCRIPTION_CUSTOMGUI_NOTIFICATION
Sent by a custom GUI to the parent. The corresponding data is DescriptionCustomGuiNotification.
Definition: c4d_baselist.h:403
DR_MULTILINE_HIGHLIGHTLINE
@ DR_MULTILINE_HIGHLIGHTLINE
Highlight lines.
Definition: gui.h:316
BaseContainer::GetString
String GetString(Int32 id, const maxon::String &preset=maxon::String()) const
Definition: c4d_basecontainer.h:387
BaseContainer::SetContainer
void SetContainer(Int32 id, const BaseContainer &s)
Definition: c4d_basecontainer.h:597
BFM_INTERACTSTART
@ BFM_INTERACTSTART
Definition: gui.h:901
BFM_GETFOCUSBEFOREUPDATE
@ BFM_GETFOCUSBEFOREUPDATE
Definition: gui.h:632
BFM_STATUSBAR_TINT_COLOR
@ BFM_STATUSBAR_TINT_COLOR
Int32 Color ID for the status bar, or as RGB value (Vector).
Definition: gui.h:823
BFM_INPUT_CHANNEL
@ BFM_INPUT_CHANNEL
Int32 Contains the key or mouse button. See also KEY.
Definition: gui.h:691
BFM_POPUPNOTIFY
@ BFM_POPUPNOTIFY
Notification of popup before the menu opens.
Definition: gui.h:899
BFM_SETFOCUSAFTERUPDATE
@ BFM_SETFOCUSAFTERUPDATE
Definition: gui.h:670
Bool
maxon::Bool Bool
Definition: ge_sys_math.h:55
MSG_DESCRIPTION_CUSTOMGUI_NOTIFICATION_CONTENT
#define MSG_DESCRIPTION_CUSTOMGUI_NOTIFICATION_CONTENT
The used data in the message container for MSG_DESCRIPTION_CUSTOMGUI_NOTIFICATION.
Definition: c4d_baselist.h:405
BFM_CORE_PAR1
@ BFM_CORE_PAR1
ANY Parameter 1.
Definition: gui.h:878
MOUSE_QUESTION
static const Int32 MOUSE_QUESTION
Question cursor.
Definition: ge_prepass.h:2491
BFM_CURSORINFO_REMOVE
@ BFM_CURSORINFO_REMOVE
Sent when mouse cursor has left a user area.
Definition: gui.h:555
BFM_DRAG_FINISHED
@ BFM_DRAG_FINISHED
Bool Drag finished.
Definition: gui.h:772
GeUserArea::ActivateFading
void ActivateFading(Int32 milliseconds)
BaseContainer::GetInt32
Int32 GetInt32(Int32 id, Int32 preset=0) const
Definition: c4d_basecontainer.h:303
RESULT_BUBBLEHELP_TITLE
@ RESULT_BUBBLEHELP_TITLE
String Bubble help text title. Printed in bold for the bubble help, not visible in the status bar.
Definition: gui.h:553
GeData::GetContainer
BaseContainer * GetContainer(void) const
Definition: c4d_gedata.h:487
KEY_ENTER
@ KEY_ENTER
Definition: gui.h:68
GeUserArea
Definition: c4d_gui.h:170
BFM_DRAG_DATA_NEW
@ BFM_DRAG_DATA_NEW
ANY Internal drag data.
Definition: gui.h:776
BaseContainer
Definition: c4d_basecontainer.h:46
GeUserArea::DrawRectangle
void DrawRectangle(Int32 x1, Int32 y1, Int32 x2, Int32 y2)
BFM_EDITFIELD_SETCURSORPOS
@ BFM_EDITFIELD_SETCURSORPOS
Definition: gui.h:971
BFM_WEIGHTS_CHANGED
@ BFM_WEIGHTS_CHANGED
Group weights changed. The group ID is returned.
Definition: gui.h:965