No-Code Workspace — Block Reference

TouchBlock usage recipe

Multi Gesture (MULTI_GESTURE)

Pinch, rotate, and custom multi-finger gestures

Documented for app version 1.0.50Updated: October 2, 2026

Multi Gesture (MULTI_GESTURE) block card

What Does It Do?

Used for true multi-finger gestures involving two or more pointers. It lets the builder create pinch-in, pinch-out, rotate, and custom gestures for richer touch automation.

Pro note: think about gesture timing as a synchronized move

MULTI_GESTURE is more than increasing finger count. Center, duration, and motion type form one synchronized move, so design pinch, zoom, and two-finger drags as a single gesture recipe first.

When to Use?

Use it when you need:

Pinch or zoom gestures in maps, galleries, or games

Two-finger rotate interactions

Multi-pointer choreography that would be awkward with plain TOUCH blocks

How to Use?

Add MULTI_GESTURE

Choose the Gesture Type: Pinch In (pinch_in), Pinch Out (pinch_out), Rotate (rotate), Custom (custom)

Configure Finger Count (2–10), the centre point, Distance (px, at least 10) and Duration (ms, at least 50)

Validate the effect afterward with IMAGE or COMPARE when needed

Parameters

Gesture Type

Pinch In (pinch_in), Pinch Out (pinch_out), Rotate (rotate, ~90°) or Custom (custom: all fingers held together at the centre)

Finger Count

Number of fingers used simultaneously (2–10)

Center / Distance / Duration

Gesture centre, finger distance from the centre (px) and completion time (ms)

Continuous gestureComing soonv1.0.51

Pinch In, Pinch Out and Rotate play as one continuous gesture in exactly the set time and can join held background fingers

Parameter	Description
Gesture Type	Pinch In (pinch_in), Pinch Out (pinch_out), Rotate (rotate, ~90°) or Custom (custom: all fingers held together at the centre)
Finger Count	Number of fingers used simultaneously (2–10)
Center / Distance / Duration	Gesture centre, finger distance from the centre (px) and completion time (ms)
Continuous gestureComing soonv1.0.51	Pinch In, Pinch Out and Rotate play as one continuous gesture in exactly the set time and can join held background fingers

Example Usage

Scenario: Two-finger zoom out on a map

MULTI_GESTURE → Gesture Type: Pinch In (pinch_in, fingers move toward the centre)

Finger Count = 2

Center = map center

Tune distance and duration (e.g. 200 px, 500 ms)

Validate the result with IMAGE

Combinations / Used With

COMBINATIONS:

MULTI_GESTURE + IMAGE: verify the screen after the gesture

MULTI_GESTURE + WAIT: let the animation settle

MULTI_GESTURE + PANEL_CONTROL: move the overlay out of the way

Tip

The center point matters as much as the gesture type. A wrong center makes even a correct pinch feel wrong.

Warnings / Cautions

WARNING:

Multi-finger gestures are more device- and app-sensitive than simple taps

Wrong finger count, duration, or center point quickly degrades the result

Step-by-Step Mastery: Basic → Advanced → Pro

The same block at three levels: a quick start, the real options, and professional techniques.

Basic

MULTI_GESTURE builds TRULY simultaneous gestures with two or more fingers. The simplest use is choosing a gesture type: pinch_in (zoom out), pinch_out (zoom in), or rotate. The builder turns the centre (gestureX/gestureY), finger count and duration into a truly simultaneous multi-finger gesture for you.

Advanced

gestureType takes four values: pinch_in, pinch_out, rotate, custom. The centre (gestureX, gestureY) matters as much as the gesture — a wrong centre makes even a correct pinch feel wrong. Fingers are spread EVENLY around the centre at 360/finger-count degrees apart. gestureDistance sets how far from the centre the fingers start/end (pixels, min 10); it controls pinch depth and rotate radius. gestureDuration is the completion time (min 50ms). gestureFingers is the number of simultaneous fingers (2-10). Mode BEHAVIOUR: pinch_in moves fingers from the distance toward the centre (zoom out); pinch_out opens from the centre out to the distance (zoom in); rotate starts fingers at the distance and turns them ~90° around the centre; custom presses ALL fingers AT ONCE exactly at the centre and holds them for the duration, then releases (a simultaneous multi-finger tap-hold — NOT a free point layout).

Pro

The generated code drives every finger in one simultaneous gesture and releases them all at the end; this is far more robust than hand-rolling TOUCH pointer choreography. Compute the centre from screen ratios across resolutions: screen width × ratio (e.g. 0.5 = middle). Multi-finger gestures are more device- and app-sensitive than TOUCH/CLICK: verify the result afterward with IMAGE/COMPARE, and add WAIT so the animation settles. For precise zoom levels, calibrate gestureDistance + gestureDuration together (small distance = little zoom, longer duration = smoother). custom mode helps when you need a simultaneous multi-point press (e.g. a control that expects two regions touched at once); if you need a free path/angle, hand-choreograph the fingers with TOUCH on separate pointers.

Real-World Scenarios — Step-by-Step Recipes

Small, reproducible examples that combine several blocks — build them straight into your own macro.

Two-finger zoom out on a map

1Add MULTI_GESTURE
2gestureType = pinch_in (fingers move to centre = zoom out)
3gestureFingers = 2
4gestureX/gestureY = map centre, gestureDistance = 200, gestureDuration = 500ms
5Validate the zoom level afterward with IMAGE

Two-finger rotate an image

1Add MULTI_GESTURE, gestureType = rotate
2gestureFingers = 2
3Centre = middle of the content to turn (gestureX/gestureY)
4gestureDistance = radius (e.g. 150), gestureDuration = 600ms
5Fingers turn ~90° around the centre; verify with IMAGE

Compute the centre from screen ratio (resolution-independent)

1First get screen width/height variables (e.g. CUSTOM_CODE or DIALOG)
2Compute centerX = width × 0.5, centerY = height × 0.5 (MATH)
3Add MULTI_GESTURE
4Bind gestureX/gestureY to these variables via {x}
5The same macro targets the true centre on every resolution

Which Blocks to Pair With — Pro Combinations

This block is useful on its own — but it shines when paired with the right partners.

+ IMAGE / COMPARE

To verify the screen actually changed (did the zoom apply) after the gesture; verification matters because multi-finger gestures are sensitive.

+ WAIT

Add a short WAIT after the gesture so the pinch/rotate animation and momentum settle.

+ PANEL_CONTROL

If the overlay panel covers the gesture area, move it aside with PANEL_CONTROL so the fingers reach the target.

+ TOUCH

If a single-finger hold suffices, TOUCH is simpler; reserve MULTI_GESTURE for true simultaneous multi-finger.

Common Mistakes and Fixes

Choosing the wrong centre makes even a correct pinch meaningless; place the centre at the true middle of the target content.

Leaving gestureDistance or duration at extremes (too short / too small) makes the gesture unrecognizable. Calibrate on the device.

Writing a fixed pixel centre for one resolution shifts on another screen. Compute the centre (gestureX/gestureY) from screen ratio.

gestureFingers can't go below 2 or above 10 (it's clamped to 2-10); gestureDistance is at least 10 and gestureDuration at least 50ms. Be aware of these bounds.

Assuming custom is a "free point layout": custom presses ALL fingers at the centre at once and holds them for the duration. For fingers going to different points use the TOUCH block with separate pointers.

Pro Tips

pinch_in = fingers move toward the centre (usually zoom out), pinch_out = move apart (zoom in); test and confirm the direction per app.

For anything needing true concurrency (combo, pinch, rotate) use MULTI_GESTURE over hand-rolled TOUCH pointer choreography; the codegen already gets the dispatch/up order right.

For precise zoom, keeping gestureDistance small and repeating it several times can be more predictable than one big gesture.

Coming soonv1.0.51Pinch In (pinch_in), Pinch Out (pinch_out) and Rotate (rotate) play as one continuous multi-finger gesture in exactly the configured time; Rotate follows the arc around the centre in short segments. These three can join held background fingers in the same gesture. Custom (custom) presses its fingers separately and is refused while background fingers are held; add Touch Break first.

rotate always turns ~90°; for more rotation repeat the block back-to-back. Since fingers spread evenly around the centre, gestureDistance is the radius and gestureFingers is the number of contact points.

This Block's Code (Editor View)

Lua

The Lua below is what the Code Editor generates for this block with sample settings. Adding cases, branches, actions or loops, or changing settings, extends the generated code accordingly. Study it to see what the block does under the hood, to learn Lua, or to copy and adapt it. Use the Copy button (top-right) to paste it into the Code Editor, or “Try in Editor →” to run it in the live editor.

lua

Try in Editor →

local _cx1, _cy1 = 540, 960
local _dist1 = 200
local _dur1 = 500
local _mgb1 = MultiGestureBuilder()
local _mgn1 = 2
for _finger1 = 0, _mgn1 - 1 do
 local _angle1 = (360 / _mgn1) * _finger1
 local _path1 = { GesturePoint(Point(_cx1 + math.floor(_dist1 * math.cos(math.rad(_angle1))), _cy1 + math.floor(_dist1 * math.sin(math.rad(_angle1)))), 0, 0), GesturePoint(Point(_cx1, _cy1), 0, _dur1) }
 _mgb1:add(_path1)
end
if _mgb1:build():go() ~= true then error("MULTI_GESTURE go failed") end

Note: generated code can evolve across versions; helper names (e.g. _reg1, m1) and internal optimizations may change. The logic and the called APIs reflect the block’s behavior.

Block ↔ Lua Mapping →

Shared Controls for This Block Family

The guidance below is not identical for every block. It summarizes the professional controls that most often repeat in the selected block family.

👆Finger Identity

TOUCH and MULTI_GESTURE flows should make it explicit when each finger goes down and when it releases.

🎯Center and Path

Center point, waypoints, and duration determine how the gesture is perceived.

⏳Background Hold

Letting the builder continue while a hold is active is powerful but risky; plan the release step deliberately.

📱Device Variance

The same gesture can feel different across DPI and aspect ratios; explicit gesture recipes are often more durable than replaying raw captures.

Builder vs Lua Boundary

Raw touch pointer lifecycle stays code-first

TOUCH and TOUCH_BREAK cover recipe-style touch flows. Raw pointer choreography such as Touch.down, Touch.move, Touch.up, Touch.dispatch, Touch.reset, Touch.breakAll, and Touch.releaseAfter is not exposed as a first-class builder block.

Touch.downTouch.moveTouch.upTouch.dispatchTouch.resetTouch.breakAllTouch.releaseAfter

Bounded dialog design is builder-backed; freer composition stays code-first

The DIALOG block and dialog designer cover a bounded field set in the builder: Info Text, Text Input, Checkbox, Description, Radio Group, Dropdown, Multi Select, Tab Group, Date Time, Number Range, Slider, Image Picker, Color Picker, File Picker, Recorder Picker, Tag, Signature, and Spacer. The buttons are designed too: the Positive button and Negative button tabs set each button’s text, background, and border color, corner radius, and minimum height next to a preview. Freer Setting.builder composition, multi-step wizard flows, and mixed HUD/dialog choreography still do not map 1:1 into the builder.

Coming soonv1.0.51Two more fields: Agent Detect references (agent_detect_editor) lets the user pick a saved reference set or add and edit references, and Save confirms the selection; Navigation setup editor (navigation_editor) edits a saved map, marker and route from the Dialog and returns the setup and route selection without moving the character.

Setting.builderDialogHudTextViewAgentDetectEditorNavigationEditor

Advanced HTTP request chaining stays code-first

HTTP_GET, HTTP_POST, and HTTP_PUT cover common fixed-method flows; HTTP_REQUEST covers one bounded request with method, header lines, body, content type, query parameters (GET and DELETE), timeout, and a bounded retry. These blocks never throw; they write the status code (-1 on a network failure). Cookie handling, chained request objects, and lower-level client flows still need the code editor.

Request()Request.setCookieRequest.getCookiesCUSTOM_CODE

General programming surfaces stay code-first

The MAP, LIST, JSON_PARSE, REGEX_MATCH, and METRICS blocks cover the everyday cases: map actions, a static list, reading a value from a JSON path, regex match, find, replace, and split, and metrics actions. The rest of the Map, Array, JSON, Regex, and Metrics APIs (for example Array sort, filter, and map) is broader than the builder recipe model and stays on the CUSTOM_CODE and code editor side.

MapArrayJSONRegexMetrics

Low-level runtime and Lua composition stays code-first

Runtime helpers, raw Request objects, Lua built-ins such as print/pcall/xpcall, and free-form object chaining patterns are represented through CUSTOM_CODE or the code editor.

RuntimeRequestprintpcallxpcallCUSTOM_CODE

Debug Mode and Breakpoints

Each block card now exposes an independent breakpoint toggle. When enabled, the breakpoint preference is stored with the block.

Breakpoints are only emitted into runtime code when Debug Mode is enabled from Visual Builder settings. When Debug Mode is off, breakpoints stay saved but do not pause execution.

Use ASSERT for fail-fast validation, and use breakpoints for step-by-step tracing and controlled pauses in the same flow.

Variable Scope

Variables defined with SET_VARIABLE are accessible throughout the macro (global scope). All blocks can read/write the same variable.

However, a variable defined inside a GROUP will be 'nil' (undefined) until the GROUP executes. Blocks outside the GROUP using this variable may produce unexpected results.

FOR_EACH loop variables (item and index) only carry valid values inside the loop body. Outside the loop they are outside local scope and should not be used.

TRY_CATCH error variable is only valid within the catch block. If the try block succeeds, the catch branch is not entered and the error variable remains undefined.

TIP: Before using a variable inside a GROUP, assign a default value with SET_VARIABLE outside the GROUP. This way the variable won't be nil even if the GROUP has not run.

Inline Expressions

You can embed variable values and calculations into text fields using {{ expression }} syntax. Expressions inside double curly braces are evaluated as Lua code and the result is inserted into the text.

Syntax

{{ expression }}

Examples

Skor: {{ score + 1 }} → "Skor: " .. tostring(score + 1)

{{ name }} kazandı! → tostring(name) .. " kazandı!"

X:{{ x }} Y:{{ y }} → "X:" .. tostring(x) .. " Y:" .. tostring(y)

Supported Blocks

SET_VARIABLELOGCOMPARECLIPBOARD_WRITENOTIFY_TOASTKV_SET

Security Note

Expressions are checked by the sandbox policy. Security-sensitive calls like loadstring, require, debug are automatically blocked.

General Tips

Keep scan regions as small as possible — improves speed, reduces false matches.

Always add an exit condition when using infinite loops (BREAK, timeout, or conditional exit).

Use network operations and error-prone steps inside TRY_CATCH.

If you need global error handling, use the Error Handler (ERROR_HANDLER) block as a singleton in the project.

Small coordinate offsets (CLICK/SWIPE) improve tap accuracy across different DPI and screen scales.

Customize macros with Dialog block — different parameters each run.

Define repeating steps once with GROUP_CALL, call from many places.

Cross-macro local library

Local Shared Macro Area

The Local Shared Macro Area moves blocks, variables, dialog fields, gallery assets, and imported media dependencies between macros on the same device. It is device-local, not cloud sync, not Firebase sharing, and not a replacement for public macro sharing.

Professional usage model: put a reusable login flow, common scan region, shared dialog form, variable group, template image, color profile, replay recording, or imported PLAY_SOUND media file into the shared area from one macro, then import it from the relevant + menu in another macro.

VISUAL_BLOCKSVARIABLESDIALOG_FIELDSTEMPLATE_IMAGECOLOR_SWATCHREPLAY_RECORDMEDIA_FILE

Send to the shared area

When one item or a multi-selection is active, the shared-area button can copy the selected part from the workspace, group, true/false action branch, dialog, and variables surfaces into the device-local library.

Import into another macro

The shared-area entry under the + menu imports the selected item into the surface that opened it. Main workspace, group, action branch, dialog, and variables each receive the compatible item type.

Share gallery assets

Gallery items include template images, color swatches, replay records, and imported audio/media files. They can move between macros on the same device so repeated templates, colors, recordings, and PLAY_SOUND media assets do not need to be captured again.

Keep it clean

The shared area is not a permanent dumping ground. Delete stale shared items from the shared-library panel; imports create a copy in the target macro and do not rewrite the source macro flow.

Checkpoint: after importing, review block names, linked template/image/color/record/media assets, and variable names in the target macro. The shared area creates a copy; delete stale shared items from the shared-library panel to keep the library clean.

AI assistant

Build a block chain with MH AI in natural language

Tell MH AI what you want in plain language; it proposes the right block sequence and lands it in the workspace after you approve. In the current release it works with cloud providers such as Gemini, Claude, and OpenAI; on-device local models are on the roadmap.

Learn more →