GeUserArea Manual

Table of Contents

• About
• Allocation
• GeUserArea Based Classes
• Read-Only Properties
• Timer
• User Interaction
  • Drag and Drop
  • Parent Message
• Drawing
  • Drawing Basics
  • Drawing Operations
  • Clipping
  • Miscellaneous
• Coordinate Transformation
• Further Reading

About

GeUserArea is the base class for all gadgets that can be displayed in a GeDialog. A new gadget is created by implementing a subclass of GeUserArea. Such a gadget manages user interaction and draws the gadget interface in the GUI.

Note

GeUserArea based classes can only be used with a GeDialog or GeDialog based classes. To create a custom GUI element that can be used in the Attribute Manager one must implement a CustomGuiData / iCustomGui based plugin.

Allocation

An instance of a GeUserArea based class is typically stored as a member of the parent GeDialog. It is added to the dialog layout using:

• GeDialog::AddUserArea(): Adds a user area to the dialog layout.
• GeDialog::AttachUserArea(): Connects the user area gadget with the actual user area instance.

See GeDialog Manual.

 // This example adds the given user area "userarea" to the GeDialog layout.
 
private:
 MyUserArea _geUserArea;
 
public:
 Bool CreateLayout()
 {
 SetTitle("GeUserArea Dialog"_s);
 
 C4DGadget* const userAreaGadget = this->AddUserArea(100, BFH_LEFT, 400, 100);
 if (userAreaGadget)
 this->AttachUserArea(_geUserArea, userAreaGadget);
 

The parent dialog is accessible with:

• GeUserArea::GetDialog(): Returns the parent GeDialog.

GeUserArea Based Classes

A custom user area is created by implementing a subclass of GeUserArea. This subclass can implement different virtual functions that define the behaviour of the gadget.

The user area is initiated with:

• GeUserArea::Init(): Called once when the user area is initialized.
• GeUserArea::InitValues(): Initiates the values displayed with the user area.

 // This example initializes the GeUserArea and sets the timer.
 
 Bool Init()
 {
 this->SetTimer(500); // value in ms
 return true;
 }

The size of the user area is handled with:

• GeUserArea::GetMinSize(): Defines the minimum size of the user area.
• GeUserArea::Sized(): Called when the user area is resized.

 // This example defines the minimum size of this GeUserArea.
 
 Bool GetMinSize(Int32& w, Int32& h)
 {
 w = 400;
 h = 100;
 
 return true;
 }
 
 // This example stores the width and height after the GeUserArea was resized.
 
 void Sized(Int32 w, Int32 h)
 {
 _width = w;
 _height = h;
 }

Different messages are sent to a user area:

• GeUserArea::Message(): Receives various GUI and interaction messages, see GUI and Interaction Messages Manual.
• GeUserArea::CoreMessage(): Receives core messages, see Core Messages Manual.
• GeUserArea::Timer(): Called in intervals set with GeUserArea::SetTimer().

 // 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())
 {
 case BFM_GETCURSORINFO:
 {
 result.SetId(BFM_GETCURSORINFO);
 result.SetInt32(RESULT_CURSOR, MOUSE_POINT_HAND);
 result.SetString(RESULT_BUBBLEHELP, "This is an example GeUserArea"_s);
 
 return true;
 }
 }
 
 return GeUserArea::Message(msg, result);
 }

The primary purpose of a user area is to draw the actual user interface:

• GeUserArea::DrawMsg(): Called to draw the user area.

 // This example draws a white rectangle in the given region.
 
 void DrawMsg(Int32 x1, Int32 y1, Int32 x2, Int32 y2, const BaseContainer& msg)
 {
 OffScreenOn();
 SetClippingRegion(x1, y1, x2, y2);
 
 DrawSetPen(Vector(1, 1, 1));
 DrawRectangle(x1, y1, x2, y2);
 }

Note

To optimize the drawing call skip the redraw if only the focus has changed, see BFM_DRAW_REASON in Draw.

A user area can catch user interaction events:

• GeUserArea::InputEvent(): Called when an input event (keyboard, mouse) is received.

 // This example checks if the input device is the mouse.
 // If so, the mouse coordinates are transferred into local coordinates.
 
 Bool InputEvent(const BaseContainer& msg)
 {
 // check the input device
 switch (msg.GetInt32(BFM_INPUT_DEVICE))
 {
 // some mouse interaction
 case BFM_INPUT_MOUSE:
 {
 // get the cursor position
 Int32 mx = msg.GetInt32(BFM_INPUT_X);
 Int32 my = msg.GetInt32(BFM_INPUT_Y);
 
 Global2Local(&mx, &my);
 ApplicationOutput("Mouse Event at " + String::IntToString(mx) + " - " + String::IntToString(my));
 
 return true;
 }
 }
 
 return false;
 }

See also GeDialog Gadget Interaction.

Read-Only Properties

These properties can be read from a user area:

• GeUserArea::GetId(): Returns the ID of the user area.
• GeUserArea::GetWidth(): Returns the width of the user area.
• GeUserArea::GetHeight(): Returns the height of the user area.
• GeUserArea::IsEnabled(): Returns true if the user area is enabled.
• GeUserArea::IsR2L(): Returns true if the user area should be drawn in right-to-left layout mode (Arabic interface).
• GeUserArea::HasFocus(): Returns true if the user area has the focus.

 // 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().
 
 BaseContainer action(BFM_ACTION);
 action.SetInt32(BFM_ACTION_ID, GetId());
 SendParentMessage(action);

 // This example changes the color of the user area depending on the focus.
 
 void DrawMsg(Int32 x1, Int32 y1, Int32 x2, Int32 y2, const BaseContainer& msg)
 {
 OffScreenOn();
 SetClippingRegion(x1, y1, x2, y2);
 
 // check if the user area has the focus
 if (this->HasFocus())
 DrawSetPen(Vector(0.0, 0.0, 1.0));
 else
 DrawSetPen(Vector(0.0, 0.2, 0.8));
 
 DrawRectangle(x1, y1, x2, y2);
 }

Timer

A user area can use an internal timer that calls GeUserArea::Timer() periodically.

• GeUserArea::SetTimer(): Initializes the timer clock.

 // This example initializes the GeUserArea and sets the timer.
 
 Bool Init()
 {
 this->SetTimer(500); // value in ms
 return true;
 }

 // This example implements GeUserArea::Timer().
 // The function is called in the interval defined with GeUserArea::SetTimer().
 
 void Timer(const BaseContainer& msg)
 {
 ApplicationOutput("Timer tick");
 }

User Interaction

A user area can handle user interaction events by implementing GeUserArea::InputEvent(). The following functions are used to get more detailed information on the current event:

• GeUserArea::GetInputState(): Gets the current state of the given input device.
• GeUserArea::GetInputEvent(): Gets the next input event for the given device from the event queue.
• GeUserArea::KillEvents(): Flushes all events from the window message queue.
• GeUserArea::IsHotkeyDown(): Returns true if the given hotkey is pressed. see HOTKEYFLAGS.

A special operation is a mouse drag event inside the user area. Such a mouse drag is initiated in reaction to certain user interaction using these functions:

• GeUserArea::MouseDragStart(): Starts the mouse drag operation.
• GeUserArea::MouseDrag(): Polls the mouse during a drag.
• GeUserArea::MouseDragEnd(): Ends a mouse drag operation.

 // This example handles a mouse drag event of the left mouse button.
 
 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
 if (device == BFM_INPUT_MOUSE && channel == BFM_INPUT_MOUSELEFT)
 {
 BaseContainer channels;
 BaseContainer state;
 Int32 startX = msg.GetInt32(BFM_INPUT_X);
 Int32 startY = msg.GetInt32(BFM_INPUT_Y);
 Float deltaX = 0.0f;
 Float deltaY = 0.0f;
 
 Global2Local(&startX, &startY);
 
 // start mouse drag
 MouseDragStart(BFM_INPUT_MOUSELEFT, (Float)startX, (Float)startY, MOUSEDRAGFLAGS::DONTHIDEMOUSE);
 
 // handle mouse drag
 while (MouseDrag(&deltaX, &deltaY, &channels) == MOUSEDRAGRESULT::CONTINUE)
 {
 // get state of the left mouse button
 if (!GetInputState(BFM_INPUT_MOUSE, BFM_INPUT_MOUSELEFT, state))
 break;
 
 // check if the mouse button is not pressed
 if (state.GetInt32(BFM_INPUT_VALUE) == 0)
 break;
 
 // print something if the mouse has moved
 if (deltaX != 0.0 || deltaY != 0.0)
 ApplicationOutput("Mouse Drag");
 }
 
 MouseDragEnd();
 
 return true;
 }

Drag and Drop

The user can drag and drop various elements onto a user area. The user area is informed about this event through messages sent to GeUserArea::Message(). These functions are used to react to those messages:

• GeUserArea::CheckDropArea(): Returns true if the drag event is over the user area.
• GeUserArea::GetDragPosition(): Gets the coordinates of the drag event.
• GeUserArea::GetDragObject(): Gets the object that is dragged.
• GeUserArea::SetDragDestination(): Sets the cursor that should be displayed. See MOUSE.

See also Drag and Drop.

 // This example handles a drag and drop event in GeUserArea::Message().
 
 case BFM_DRAGRECEIVE:
 {
 // 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;
 
 // check if an C4DAtom was dragged
 if (type != DRAGTYPE_ATOMARRAY)
 return false;
 
 // get content
 const AtomArray* const elements = static_cast<AtomArray*>(data);
 // check content
 if (!elements->GetIndex(0))
 return false;
 
 // check if drag has finished
 if (msg.GetInt32(BFM_DRAG_FINISHED))
 {
 // loop through all elements of the AtomArray
 for (Int32 i = 0; i < elements->GetCount(); ++i)
 {
 const C4DAtom* const atom = elements->GetIndex(i);
 
 // check if the given C4DAtom is a BaseList2D element
 if (atom && atom->IsInstanceOf(Tbaselist2d))
 {
 const BaseList2D* const baselistObject = static_cast<const BaseObject*>(atom);
 ApplicationOutput("Dragged object: " + baselistObject->GetName());
 }
 }
 }
 else
 {
 // if in drag, show different mouse cursor
 return SetDragDestination(MOUSE_POINT_HAND);
 }
 
 return true;
 }

It is also possible to start a drag and drop operation from a user area. This is typically done in reaction to some user interaction.

• GeUserArea::HandleMouseDrag(): Starts a drag and drop operation.

 // This example starts a drag and drop operation.
 
 Bool InputEvent(const BaseContainer& msg)
 {
 const Int32 device = msg.GetInt32(BFM_INPUT_DEVICE);
 const Int32 channel = msg.GetInt32(BFM_INPUT_CHANNEL);
 
 if (device == BFM_INPUT_MOUSE)
 {
 if (channel == BFM_INPUT_MOUSELEFT)
 {
 // drag a color
 Vector red(1.0, 0.0, 0.0);
 
 // start a drag & drop event of dragging a color value
 if (HandleMouseDrag(msg, DRAGTYPE_RGB, &red, 0))
 return true;
 }
 }
 
 return false;
 }

Parent Message

A user area can send messages to its parent GeDialog. This is typically done to inform the dialog that some user interaction occurred and that the managed values changed.

• GeUserArea::SendParentMessage(): Sends a message to the parent dialog.

See GUI and Interaction Messages Manual.

 // 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().
 
 BaseContainer action(BFM_ACTION);
 action.SetInt32(BFM_ACTION_ID, GetId());
 SendParentMessage(action);

Drawing

Drawing Basics

The central task of a user area is to draw something to Cinema 4D's user interface. The drawing operations have to happen inside the GeUserArea::DrawMsg() function.

The drawing operation can be triggered with:

• GeUserArea::Redraw(): Forces the user area to redraw itself.
• GeUserArea::LayoutChanged(): Informs Cinema 4D that the user area has new dimensions. This will result in a redraw.

Drawing Operations

The following functions can be used to draw inside the canvas provided by the user area. For more advanced drawing operations one can use a GeClipMap and GeUserArea::DrawBitmap().

The color and opacity settings are handled with:

• GeUserArea::GetColorRGB(): Gets the color value for the given color ID. See c4d_colors.h.
• GeUserArea::DrawSetPen(): Sets the currently used drawing color.
• GeUserArea::DrawSetOpacity(): Sets the opacity used in the following drawing operations.

 // This example draws a white background and a black text.
 
 // draw a white background
 DrawSetPen(Vector(1.0f));
 DrawRectangle(x1, y1, x2, y2);
 
 // draw some text
 DrawSetTextCol(Vector(0.0f), Vector(1.0f));
 DrawText("Hello World!"_s, 0, 0, DRAWTEXT_HALIGN_LEFT);

Different styles used with various drawing functions are (LINESTYLE):

• LINESTYLE::NORMAL
• LINESTYLE::DOTTED
• LINESTYLE::DASHED
• LINESTYLE::DASHED_INV

These functions draw primitive shapes:

• GeUserArea::DrawLine(): Draws a line.
• GeUserArea::DrawRectangle(): Draws a rectangle.
• GeUserArea::DrawFrame(): Draws a frame.
• GeUserArea::DrawBezierLine(): Draws a Bezier line.
• GeUserArea::DrawBezierFill(): Draws a Bezier line and fills the area.
• GeUserArea::DrawPolyLine(): Draws a poly line.
• GeUserArea::DrawPolyFill(): Draws a poly line and fills the area.
• GeUserArea::DrawEllipseLine(): Draws an ellipse.
• GeUserArea::DrawEllipseFill(): Draws an ellipse and fills the area.

 // This example draws shapes in a GeUserArea.
 
 // draw base
 MAXON_SCOPE
 {
 const maxon::Vector2d center(300, 60);
 const maxon::Vector2d radius(40, 40);
 
 DrawSetPen(Vector(1, 1, 0));
 DrawEllipseFill(center, radius);
 
 DrawSetPen(Vector(0, 0, 0));
 DrawEllipseLine(center, radius);
 }
 
 // draw eyes
 DrawSetPen(Vector(0, 0, 0));
 
 MAXON_SCOPE
 {
 const maxon::Vector2d center(285, 50);
 const maxon::Vector2d radius(3, 3);
 DrawEllipseFill(center, radius);
 }
 MAXON_SCOPE
 {
 const maxon::Vector2d center(315, 50);
 const maxon::Vector2d radius(3, 3);
 DrawEllipseFill(center, radius);
 }
 
 // draw mouth
 MAXON_SCOPE
 {
 BezierPoint p;
 p.c1 = Vector2d(280, 90);
 p.c2 = Vector2d(320, 90);
 p.p = Vector2d(320, 70);
 
 DrawBezierLine(Vector2d(280, 70), maxon::ToSingletonBlock(p), false, 1.0, LINESTYLE::NORMAL);
 }

A BaseBitmap can both be drawn to the canvas and filled with the current pen:

• GeUserArea::DrawBitmap(): Draws a BaseBitmap. For effects see BMP.
• GeUserArea::FillBitmapBackground(): Fills the given BaseBitmap with the current pen color.

See also BaseBitmap Manual.

 // This example fills a GeClipMap and draws the resulting BaseBitmap in the user area.
 
 AutoAlloc<GeClipMap> clipMap;
 if (clipMap)
 {
 // get monospaced font
 BaseContainer font;
 GeClipMap::GetDefaultFont(GE_FONT_DEFAULT_MONOSPACED, &font);
 
 clipMap->Init(200, 50, 32);
 clipMap->BeginDraw();
 
 // fill background
 clipMap->SetColor(255, 255, 255, 255);
 clipMap->FillRect(0, 0, 200, 50);
 
 // draw text
 clipMap->SetFont(&font, 20.0);
 clipMap->SetColor(0, 0, 0, 255);
 clipMap->TextAt(0, clipMap->GetTextHeight(), "This is some text.");
 clipMap->EndDraw();
 
 // get bitmap
 BaseBitmap* const bitmap = clipMap->GetBitmap();
 if (bitmap)
 {
 // draw bitmap
 const Int32 width = bitmap->GetBw();
 const Int32 height = bitmap->GetBh();
 
 DrawBitmap(bitmap, 0, 0, width, height, 0, 0, width, height, BMP_NORMAL);
 }
 }

The border style of the user area is defined with:

• GeUserArea::DrawBorder(): Draws a border with the given style, see BORDER.
• GeUserArea::GetBorderSize(): Gets the space required to draw a border. Typically used with GeUserArea::GetMinSize().

 // This example draws a round border for the GeUserArea.
 
 DrawBorder(BORDER_ROUND, 0, 0, GetWidth(), GetHeight());

Text is drawn with these functions:

• GeUserArea::DrawText(): Draws the given String.
• GeUserArea::DrawSetTextCol(): Sets the text foreground and background color.
• GeUserArea::DrawSetFont(): Sets the text font, see FONT.
• GeUserArea::DrawGetTextWidth(): Returns the width in pixels of the given String.
• GeUserArea::DrawGetFontHeight(): Returns the height in pixels of the given String.
• GeUserArea::DrawGetTextWidth_ListNodeName(): Returns the width in pixels of the name of the given BaseList2D.
• GeUserArea::DrawGetFontBaseLine(): Returns the base line of the current font.
• GeUserArea::DrawSetTextRotation(): Sets the text rotation.

 // This example draws some text and a line under that text.
 
 const String text { "Hello World!" };
 const Int32 left = 100;
 
 // draw text
 DrawSetTextCol(Vector(0.0f), Vector(1.0f));
 DrawSetFont(FONT_MONOSPACED);
 DrawText(text, left, 0, DRAWTEXT_HALIGN_LEFT);
 
 // draw a line
 const Int32 baseline = DrawGetFontBaseLine() + 1;
 const Int32 length = DrawGetTextWidth(text);
 
 DrawSetPen(Vector(0.5f));
 DrawLine(left, baseline, left + length, baseline);

A user area can support a dynamic fading effect that is typically used to change the background color of the gadget after the cursor moved over it:

• GeUserArea::ActivateFading(): Activates the dynamic fading. The message BFM_FADE will be sent to the user area.
• GeUserArea::AdjustColor(): Calculates the new color while fading.

See also Fading.

// 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() { };
 
 Int32 Message(const BaseContainer& msg, BaseContainer& result)
 {
 // messages are identified by the BaseContainer ID
 switch (msg.GetId())
 {
 case BFM_GETCURSORINFO:
 {
 // cursor is over the user area
 // start fading
 ActivateFading(100);
 return true;
 }
 case BFM_FADE:
 {
 // receive fade message and update the COLOR_BG used in DrawMsg()
 const Float percentage = msg.GetFloat(BFM_FADE);
 AdjustColor(COLOR_BG, COLOR_BG_HIGHLIGHT, percentage);
 
 // 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)
 {
 OffScreenOn();
 SetClippingRegion(x1, y1, x2, y2);
 // draw background with COLOR_BG
 DrawSetPen(COLOR_BG);
 DrawRectangle(x1, y1, x2, y2);
 // draw text
 DrawSetTextCol(COLOR_CONSOLE_TEXT, COLOR_TRANS);
 DrawSetFont(FONT_MONOSPACED);
 DrawText("User Area"_s, 0, 0, DRAWTEXT_HALIGN_LEFT);
 }
};

It is also possible to be informed when the cursor leaves the user area:

• RemoveLastCursorInfo(): Registers a callback function that is called when the cursor leaves the user area. The function typically sends the message BFM_CURSORINFO_REMOVE back to the user 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() { };
 
 Int32 Message(const BaseContainer& msg, BaseContainer& result)
 {
 // messages are identified by the BaseContainer ID
 switch (msg.GetId())
 {
 case BFM_GETCURSORINFO:
 {
 // register RemoveCursorInfo() callback
 g_userArea = this;
 RemoveLastCursorInfo(RemoveCursorInfo);
 
 _cursorInside = true;
 Redraw();
 return true;
 }
 case BFM_CURSORINFO_REMOVE:
 {
 // 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)
 {
 OffScreenOn();
 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
 BaseContainer bc;
 g_userArea->Message(BaseContainer(BFM_CURSORINFO_REMOVE), bc);
}

Clipping

Clipping is used to limit drawing operations to certain areas:

• GeUserArea::SetClippingRegion(): Specifies the clipping region for the drawing functions.
• GeUserArea::ClearClippingRegion(): Clears the clipping region set with GeUserArea::SetClippingRegion().
• GeUserArea::OffScreenOn(): Enables double buffering to avoid blinking and flickering effects. Automatically sets the clipping area to the whole user area or the given region.

 // This example draws a white rectangle in the given region.
 
 void DrawMsg(Int32 x1, Int32 y1, Int32 x2, Int32 y2, const BaseContainer& msg)
 {
 OffScreenOn();
 SetClippingRegion(x1, y1, x2, y2);
 
 DrawSetPen(Vector(1, 1, 1));
 DrawRectangle(x1, y1, x2, y2);
 }

Miscellaneous

Miscellaneous functions are:

• GeUserArea::ScrollArea(): Scrolls the user area.
• GeUserArea::GetPixelRatio(): Returns the screen pixel ratio to indicate Retina displays.

Coordinate Transformation

These functions are used to transform coordinates into different spaces:

• GeUserArea::Local2Global(): Transforms local coordinates to global window coordinates.
• GeUserArea::Global2Local(): Transforms global window coordinates to local coordinates.
• GeUserArea::Local2Screen(): Transforms local coordinates to screen coordinates.
• GeUserArea::Screen2Local(): Transforms screen coordinates to local coordinates.

 // This example creates a pop up menu when the right mouse button was pressed.
 
 Bool InputEvent(const BaseContainer& msg)
 {
 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
 if (device == BFM_INPUT_MOUSE && channel == BFM_INPUT_MOUSERIGHT)
 {
 // get the cursor position
 Int32 x = msg.GetInt32(BFM_INPUT_X);
 Int32 y = msg.GetInt32(BFM_INPUT_Y);
 
 Global2Local(&x, &y);
 Local2Screen(&x, &y);
 
 // define pop up menu
 BaseContainer bc;
 bc.InsData(5159, "CMD"); // cube
 bc.InsData(0, String());
 bc.InsData(5160, "CMD"); // sphere
 
 // show pop up menu
 ShowPopupMenu(GetDialog()->Get(), x, y, bc);
 return true;
 }
 return false;
 }

Further Reading

• GeDialog Manual
• GUI and Interaction Messages Manual
• Core Messages Manual
• BaseBitmap Manual