+ Specifies how the Play window is launched relative to the Android editor.

+ - [b]Auto (based on screen size)[/b] (default) will automatically choose how to launch the Play window based on the device and screen metrics. Defaults to [b]Same as Editor[/b] on phones and [b]Side-by-side with Editor[/b] on tablets.

+ - [b]Same as Editor[/b] will launch the Play window in the same window as the Editor.

+ - [b]Side-by-side with Editor[/b] will launch the Play window side-by-side with the Editor window.

+ [b]Note:[/b] Only available in the Android editor.

+ </member>

+ <member name="run/window_placement/play_window_pip_mode" type="int" setter="" getter="">

+ Specifies the picture-in-picture (PiP) mode for the Play window.

+ - [b]Disabled:[/b] PiP is disabled for the Play window.

+ - [b]Enabled:[/b] If the device supports it, PiP is always enabled for the Play window. The Play window will contain a button to enter PiP mode.

+ - [b]Enabled when Play window is same as Editor[/b] (default for Android editor): If the device supports it, PiP is enabled when the Play window is the same as the Editor. The Play window will contain a button to enter PiP mode.

+ Line fill alignment rules. See [enum TextServer.JustificationFlag] for more information.

+ Line fill alignment rules. See [enum TextServer.JustificationFlag] for more information.

+ <member name="debug/gdscript/warnings/missing_tool" type="int" setter="" getter="" default="1">

+ When set to [code]warn[/code] or [code]error[/code], produces a warning or an error respectively when the base class script has the [code]@tool[/code] annotation, but the current class script does not have it.

+ </member>

+ <member name="horizontal_alignment" type="int" setter="set_horizontal_alignment" getter="get_horizontal_alignment" enum="HorizontalAlignment" default="0">

+ Controls the text's horizontal alignment. Supports left, center, right, and fill, or justify. Set it to one of the [enum HorizontalAlignment] constants.

+ </member>

+ <member name="justification_flags" type="int" setter="set_justification_flags" getter="get_justification_flags" enum="TextServer.JustificationFlag" is_bitfield="true" default="163">

+ Line fill alignment rules. See [enum TextServer.JustificationFlag] for more information.

+ </member>

+ <member name="tab_stops" type="PackedFloat32Array" setter="set_tab_stops" getter="get_tab_stops" default="PackedFloat32Array()">

+ Aligns text to the given tab-stops.

+ </member>

+ Line fill alignment rules. See [enum TextServer.JustificationFlag] for more information.

+ Line fill alignment rules. See [enum TextServer.JustificationFlag] for more information.

+#include "core/os/os.h"

+ String r_path = DirAccess::fix_path(p_path.trim_prefix(R"(\\?\)").replace("\\", "/"));

+

+ if (r_path.is_relative_path()) {

+ r_path = current_dir.trim_prefix(R"(\\?\)").replace("\\", "/").path_join(r_path);

+ } else if (r_path == ".") {

+ r_path = current_dir.trim_prefix(R"(\\?\)").replace("\\", "/");

+ }

+ r_path = r_path.simplify_path();

+ r_path = r_path.replace("/", "\\");

+ if (!r_path.is_network_share_path() && !r_path.begins_with(R"(\\?\)")) {

+ r_path = R"(\\?\)" + r_path;

+ String dir = fix_path(p_dir);

+ Char16String real_current_dir_name;

+ size_t str_len = GetCurrentDirectoryW(0, nullptr);

+ real_current_dir_name.resize(str_len + 1);

+ GetCurrentDirectoryW(real_current_dir_name.size(), (LPWSTR)real_current_dir_name.ptrw());

+ String prev_dir = String::utf16((const char16_t *)real_current_dir_name.get_data());

+ bool worked = (SetCurrentDirectoryW((LPCWSTR)(dir.utf16().get_data())) != 0);

+ str_len = GetCurrentDirectoryW(0, nullptr);

+ real_current_dir_name.resize(str_len + 1);

+ GetCurrentDirectoryW(real_current_dir_name.size(), (LPWSTR)real_current_dir_name.ptrw());

+ String new_dir = String::utf16((const char16_t *)real_current_dir_name.get_data()).trim_prefix(R"(\\?\)").replace("\\", "/");

+ str_len = GetCurrentDirectoryW(0, nullptr);

+ real_current_dir_name.resize(str_len + 1);

+ GetCurrentDirectoryW(real_current_dir_name.size(), (LPWSTR)real_current_dir_name.ptrw());

+ current_dir = String::utf16((const char16_t *)real_current_dir_name.get_data());

+ String dir = fix_path(p_dir);

+ success = CreateDirectoryW((LPCWSTR)(dir.utf16().get_data()), nullptr);

+ String cdir = current_dir.trim_prefix(R"(\\?\)").replace("\\", "/");

+ String bd = cdir.replace_first(base, "");

+ return cdir;

+ int pos = cdir.find(":");

+ return cdir.substr(pos + 1);

+ return cdir;

+ String file = fix_path(p_file);

+ fileAttr = GetFileAttributesW((LPCWSTR)(file.utf16().get_data()));

+ String dir = fix_path(p_dir);

+ fileAttr = GetFileAttributesW((LPCWSTR)(dir.utf16().get_data()));

+ String path = fix_path(p_path);

+ String new_path = fix_path(p_new_path);

+ if (path.to_lower() == new_path.to_lower()) {

+ if (dir_exists(path)) {

+ return MoveFileW((LPCWSTR)(path.utf16().get_data()), (LPCWSTR)(new_path.utf16().get_data())) != 0 ? OK : FAILED;

+ // Note: do not use GetTempFileNameW, it's not long path aware!

+ Char16String tmpfile_utf16;

+ uint64_t id = OS::get_singleton()->get_ticks_usec();

+ while (true) {

+ tmpfile_utf16 = (path + itos(id++) + ".tmp").utf16();

+ HANDLE handle = CreateFileW((LPCWSTR)tmpfile_utf16.get_data(), GENERIC_WRITE, 0, NULL, CREATE_NEW, FILE_ATTRIBUTE_NORMAL, 0);

+ if (handle != INVALID_HANDLE_VALUE) {

+ CloseHandle(handle);

+ break;

+ }

+ if (GetLastError() != ERROR_FILE_EXISTS && GetLastError() != ERROR_SHARING_VIOLATION) {

+ return FAILED;

+ }

+ if (!::ReplaceFileW((LPCWSTR)tmpfile_utf16.get_data(), (LPCWSTR)(path.utf16().get_data()), nullptr, 0, nullptr, nullptr)) {

+ DeleteFileW((LPCWSTR)tmpfile_utf16.get_data());

+ return MoveFileW((LPCWSTR)tmpfile_utf16.get_data(), (LPCWSTR)(new_path.utf16().get_data())) != 0 ? OK : FAILED;

+ if (file_exists(new_path)) {

+ if (remove(new_path) != OK) {

+ return MoveFileW((LPCWSTR)(path.utf16().get_data()), (LPCWSTR)(p_new_path.utf16().get_data())) != 0 ? OK : FAILED;

+ String path = fix_path(p_path);

+ const Char16String &path_utf16 = path.utf16();

+ fileAttr = GetFileAttributesW((LPCWSTR)(path_utf16.get_data()));

+ return RemoveDirectoryW((LPCWSTR)(path_utf16.get_data())) != 0 ? OK : FAILED;

+ return DeleteFileW((LPCWSTR)(path_utf16.get_data())) != 0 ? OK : FAILED;

+ String path = current_dir.trim_prefix(R"(\\?\)");

+ int unit_end = path.find(":");

+ ERR_FAIL_COND_V(unit_end == -1, String());

+ String unit = path.substr(0, unit_end + 1) + "\\";

+

+ String f = fix_path(p_path);

+ String f = fix_path(p_file);

+ String f = fix_path(p_file);

+ return String::utf16((const char16_t *)cs.ptr(), ret).trim_prefix(R"(\\?\)").replace("\\", "/");

+ String source = fix_path(p_source);

+ String target = fix_path(p_target);

+ DWORD file_attr = GetFileAttributesW((LPCWSTR)(source.utf16().get_data()));

+ if (CreateSymbolicLinkW((LPCWSTR)target.utf16().get_data(), (LPCWSTR)source.utf16().get_data(), flags) != 0) {

+

+ Char16String real_current_dir_name;

+ size_t str_len = GetCurrentDirectoryW(0, nullptr);

+ real_current_dir_name.resize(str_len + 1);

+ GetCurrentDirectoryW(real_current_dir_name.size(), (LPWSTR)real_current_dir_name.ptrw());

+ current_dir = String::utf16((const char16_t *)real_current_dir_name.get_data());

+

+ if (r_path.is_relative_path()) {

+ Char16String current_dir_name;

+ size_t str_len = GetCurrentDirectoryW(0, nullptr);

+ current_dir_name.resize(str_len + 1);

+ GetCurrentDirectoryW(current_dir_name.size(), (LPWSTR)current_dir_name.ptrw());

+ r_path = String::utf16((const char16_t *)current_dir_name.get_data()).trim_prefix(R"(\\?\)").replace("\\", "/").path_join(r_path);

+ }

+ r_path = r_path.simplify_path();

+ r_path = r_path.replace("/", "\\");

+ if (!r_path.is_network_share_path() && !r_path.begins_with(R"(\\?\)")) {

+ r_path = R"(\\?\)" + r_path;

+ String base_path = p_path;

+ working_path = fix_path(working_path);

+ Vector<String> parts = base_path.simplify_path().split("/");

+ working_path = working_path + "\\" + part;

+ // Note: do not use GetTempFileNameW, it's not long path aware!

+ String tmpfile;

+ uint64_t id = OS::get_singleton()->get_ticks_usec();

+ while (true) {

+ tmpfile = path + itos(id++) + ".tmp";

+ HANDLE handle = CreateFileW((LPCWSTR)tmpfile.utf16().get_data(), GENERIC_WRITE, 0, NULL, CREATE_NEW, FILE_ATTRIBUTE_NORMAL, 0);

+ if (handle != INVALID_HANDLE_VALUE) {

+ CloseHandle(handle);

+ break;

+ }

+ if (GetLastError() != ERROR_FILE_EXISTS && GetLastError() != ERROR_SHARING_VIOLATION) {

+ last_error = ERR_FILE_CANT_WRITE;

+ return FAILED;

+ }

+ path = tmpfile;

+ rename_error = MoveFileW((LPCWSTR)(path_utf16.get_data()), (LPCWSTR)(save_path_utf16.get_data())) == 0;

+ return path.trim_prefix(R"(\\?\)").replace("\\", "/");

+ String file = p_file;

+ file = fix_path(file);

+ const Char16String &file_utf16 = file.utf16();

+ DWORD attrib = GetFileAttributesW((LPCWSTR)file_utf16.get_data());

+ ok = SetFileAttributesW((LPCWSTR)file_utf16.get_data(), attrib | FILE_ATTRIBUTE_HIDDEN);

+ ok = SetFileAttributesW((LPCWSTR)file_utf16.get_data(), attrib & ~FILE_ATTRIBUTE_HIDDEN);

+ const Char16String &file_utf16 = file.utf16();

+ DWORD attrib = GetFileAttributesW((LPCWSTR)file_utf16.get_data());

+ ok = SetFileAttributesW((LPCWSTR)file_utf16.get_data(), attrib | FILE_ATTRIBUTE_READONLY);

+ ok = SetFileAttributesW((LPCWSTR)file_utf16.get_data(), attrib & ~FILE_ATTRIBUTE_READONLY);

+ ep->step(efd->files[index]->file, step_count++, false);

+ // The method reimport_files runs on the main thread, and if VSync is enabled

+ // or Update Continuously is disabled, Main::Iteration takes longer each frame.

+ // Each EditorProgress::step can trigger a redraw, and when there are many files to import,

+ // this could lead to a slow import process, especially when the editor is unfocused.

+ // Temporarily disabling VSync and low_processor_usage_mode while reimporting fixes this.

+ const bool old_low_processor_usage_mode = OS::get_singleton()->is_in_low_processor_usage_mode();

+ const DisplayServer::VSyncMode old_vsync_mode = DisplayServer::get_singleton()->window_get_vsync_mode(DisplayServer::MAIN_WINDOW_ID);

+ OS::get_singleton()->set_low_processor_usage_mode(false);

+ DisplayServer::get_singleton()->window_set_vsync_mode(DisplayServer::VSyncMode::VSYNC_DISABLED);

+

+ ep->step(TTR("Finalizing Asset Import..."), p_files.size());

+

+ // Revert to previous values to restore editor settings for VSync and Update Continuously.

+ OS::get_singleton()->set_low_processor_usage_mode(old_low_processor_usage_mode);

+ DisplayServer::get_singleton()->window_set_vsync_mode(old_vsync_mode);

+

+ change_type->add_icon_item(get_editor_theme_icon(SNAME("Remove")), TTR("Remove Item"), Variant::VARIANT_MAX);

+ change_type->add_separator();

+ change_type->add_icon_item(get_editor_theme_icon(SNAME("Remove")), TTR("Remove Item"), Variant::VARIANT_MAX);

+ change_type->add_separator();

+ int default_play_window_pip_mode = 0;

+#ifdef ANDROID_ENABLED

+ default_play_window_pip_mode = 2;

+#endif

+ EDITOR_SETTING(Variant::INT, PROPERTY_HINT_ENUM, "run/window_placement/play_window_pip_mode", default_play_window_pip_mode, "Disabled:0,Enabled:1,Enabled when Play window is same as Editor:2")

+

+ qoa_desc desc = {};

+ void *encoded = qoa_encode((short *)pcm_data.ptr(), &desc, &qoa_len);

+ if (encoded) {

+ dst_data.resize(qoa_len);

+ memcpy(dst_data.ptrw(), encoded, qoa_len);

+ QOA_FREE(encoded);

+ }

+ if (p_allow_locked || (selected != nullptr && !_is_node_locked(selected))) {

+ if (p_state.has("transform_gizmo")) {

+ bool transform_gizmo = p_state["transform_gizmo"];

+

+ int idx = view_menu->get_popup()->get_item_index(VIEW_TRANSFORM_GIZMO);

+ if (view_menu->get_popup()->is_item_checked(idx) != transform_gizmo) {

+ _menu_option(VIEW_TRANSFORM_GIZMO);

+ }

+ }

+ d["transform_gizmo"] = view_menu->get_popup()->is_item_checked(view_menu->get_popup()->get_item_index(VIEW_TRANSFORM_GIZMO));

+ Task &t = tasks[p_task];

+ if (tus - t.last_progress_tick < 200000) { //200ms

+ t.last_progress_tick = OS::get_singleton()->get_ticks_usec();

+ uint64_t last_progress_tick = 0;

+ <application xmlns="urn:schemas-microsoft-com:asm.v3">

+ <windowsSettings xmlns:ws2="http://schemas.microsoft.com/SMI/2016/WindowsSettings">

+ <ws2:longPathAware>true</ws2:longPathAware>

+ </windowsSettings>

+ </application>

+ elif len(err) > 0 and not err.isspace():

+ print(err)

+#ifdef DEBUG_ENABLED

+ if (!parser->_is_tool && ext_parser->get_parser()->_is_tool) {

+ parser->push_warning(p_class, GDScriptWarning::MISSING_TOOL);

+ }

+#endif

+

+

+#ifdef DEBUG_ENABLED

+ if (!parser->_is_tool && base_parser->get_parser()->_is_tool) {

+ parser->push_warning(p_class, GDScriptWarning::MISSING_TOOL);

+ }

+#endif

+

+

+#ifdef DEBUG_ENABLED

+ if (!parser->_is_tool && info_parser->get_parser()->_is_tool) {

+ parser->push_warning(p_class, GDScriptWarning::MISSING_TOOL);

+ }

+#endif

+

+ case MISSING_TOOL:

+ return R"(The base class script has the "@tool" annotation, but this script does not have it.)";

+ "MISSING_TOOL",

+ MISSING_TOOL, // The base class script has the "@tool" annotation, but this script does not have it.

+ WARN, // MISSING_TOOL

+extends "./non_tool_extends_tool.notest.gd"

+

+class InnerClass extends "./non_tool_extends_tool.notest.gd":

+ pass

+

+func test():

+ pass

+@tool

+GDTEST_OK

+>> WARNING

+>> Line: 1

+>> MISSING_TOOL

+>> The base class script has the "@tool" annotation, but this script does not have it.

+>> WARNING

+>> Line: 3

+>> MISSING_TOOL

+>> The base class script has the "@tool" annotation, but this script does not have it.

+@warning_ignore("missing_tool")

+extends "./non_tool_extends_tool.notest.gd"

+

+@warning_ignore("missing_tool")

+class InnerClass extends "./non_tool_extends_tool.notest.gd":

+ pass

+

+func test():

+ pass

+GDTEST_OK

+ android:icon="@mipmap/icon"

+ android:icon="@mipmap/ic_play_window"

+ android:label="@string/godot_game_activity_name"

+ android:supportsPictureInPicture="true"

+/**************************************************************************/

+/* EditorMessageDispatcher.kt */

+/**************************************************************************/

+/* This file is part of: */

+/* GODOT ENGINE */

+/* https://godotengine.org */

+/**************************************************************************/

+/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */

+/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */

+/* */

+/* Permission is hereby granted, free of charge, to any person obtaining */

+/* a copy of this software and associated documentation files (the */

+/* "Software"), to deal in the Software without restriction, including */

+/* without limitation the rights to use, copy, modify, merge, publish, */

+/* distribute, sublicense, and/or sell copies of the Software, and to */

+/* permit persons to whom the Software is furnished to do so, subject to */

+/* the following conditions: */

+/* */

+/* The above copyright notice and this permission notice shall be */

+/* included in all copies or substantial portions of the Software. */

+/* */

+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */

+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */

+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */

+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */

+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */

+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */

+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */

+/**************************************************************************/

+

+package org.godotengine.editor

+

+import android.annotation.SuppressLint

+import android.content.Intent

+import android.content.pm.PackageManager

+import android.os.Bundle

+import android.os.Handler

+import android.os.Message

+import android.os.Messenger

+import android.os.RemoteException

+import android.util.Log

+import java.util.concurrent.ConcurrentHashMap

+

+/**

+ * Used by the [GodotEditor] classes to dispatch messages across processes.

+ */

+internal class EditorMessageDispatcher(private val editor: GodotEditor) {

+

+ companion object {

+ private val TAG = EditorMessageDispatcher::class.java.simpleName

+

+ /**

+ * Extra used to pass the message dispatcher payload through an [Intent]

+ */

+ const val EXTRA_MSG_DISPATCHER_PAYLOAD = "message_dispatcher_payload"

+

+ /**

+ * Key used to pass the editor id through a [Bundle]

+ */

+ private const val KEY_EDITOR_ID = "editor_id"

+

+ /**

+ * Key used to pass the editor messenger through a [Bundle]

+ */

+ private const val KEY_EDITOR_MESSENGER = "editor_messenger"

+

+ /**

+ * Requests the recipient to quit right away.

+ */

+ private const val MSG_FORCE_QUIT = 0

+

+ /**

+ * Requests the recipient to store the passed [android.os.Messenger] instance.

+ */

+ private const val MSG_REGISTER_MESSENGER = 1

+ }

+

+ private val recipientsMessengers = ConcurrentHashMap<Int, Messenger>()

+

+ @SuppressLint("HandlerLeak")

+ private val dispatcherHandler = object : Handler() {

+ override fun handleMessage(msg: Message) {

+ when (msg.what) {

+ MSG_FORCE_QUIT -> editor.finish()

+

+ MSG_REGISTER_MESSENGER -> {

+ val editorId = msg.arg1

+ val messenger = msg.replyTo

+ registerMessenger(editorId, messenger)

+ }

+

+ else -> super.handleMessage(msg)

+ }

+ }

+ }

+

+ /**

+ * Request the window with the given [editorId] to force quit.

+ */

+ fun requestForceQuit(editorId: Int): Boolean {

+ val messenger = recipientsMessengers[editorId] ?: return false

+ return try {

+ Log.v(TAG, "Requesting 'forceQuit' for $editorId")

+ val msg = Message.obtain(null, MSG_FORCE_QUIT)

+ messenger.send(msg)

+ true

+ } catch (e: RemoteException) {

+ Log.e(TAG, "Error requesting 'forceQuit' to $editorId", e)

+ recipientsMessengers.remove(editorId)

+ false

+ }

+ }

+

+ /**

+ * Utility method to register a receiver messenger.

+ */

+ private fun registerMessenger(editorId: Int, messenger: Messenger?, messengerDeathCallback: Runnable? = null) {

+ try {

+ if (messenger == null) {

+ Log.w(TAG, "Invalid 'replyTo' payload")

+ } else if (messenger.binder.isBinderAlive) {

+ messenger.binder.linkToDeath({

+ Log.v(TAG, "Removing messenger for $editorId")

+ recipientsMessengers.remove(editorId)

+ messengerDeathCallback?.run()

+ }, 0)

+ recipientsMessengers[editorId] = messenger

+ }

+ } catch (e: RemoteException) {

+ Log.e(TAG, "Unable to register messenger from $editorId", e)

+ recipientsMessengers.remove(editorId)

+ }

+ }

+

+ /**

+ * Utility method to register a [Messenger] attached to this handler with a host.

+ *

+ * This is done so that the host can send request to the editor instance attached to this handle.

+ *

+ * Note that this is only done when the editor instance is internal (not exported) to prevent

+ * arbitrary apps from having the ability to send requests.

+ */

+ private fun registerSelfTo(pm: PackageManager, host: Messenger?, selfId: Int) {

+ try {

+ if (host == null || !host.binder.isBinderAlive) {

+ Log.v(TAG, "Host is unavailable")

+ return

+ }

+

+ val activityInfo = pm.getActivityInfo(editor.componentName, 0)

+ if (activityInfo.exported) {

+ Log.v(TAG, "Not registering self to host as we're exported")

+ return

+ }

+

+ Log.v(TAG, "Registering self $selfId to host")

+ val msg = Message.obtain(null, MSG_REGISTER_MESSENGER)

+ msg.arg1 = selfId

+ msg.replyTo = Messenger(dispatcherHandler)

+ host.send(msg)

+ } catch (e: RemoteException) {

+ Log.e(TAG, "Unable to register self with host", e)

+ }

+ }

+

+ /**

+ * Parses the starting intent and retrieve an editor messenger if available

+ */

+ fun parseStartIntent(pm: PackageManager, intent: Intent) {

+ val messengerBundle = intent.getBundleExtra(EXTRA_MSG_DISPATCHER_PAYLOAD) ?: return

+

+ // Retrieve the sender messenger payload and store it. This can be used to communicate back

+ // to the sender.

+ val senderId = messengerBundle.getInt(KEY_EDITOR_ID)

+ val senderMessenger: Messenger? = messengerBundle.getParcelable(KEY_EDITOR_MESSENGER)

+ registerMessenger(senderId, senderMessenger)

+

+ // Register ourselves to the sender so that it can communicate with us.

+ registerSelfTo(pm, senderMessenger, editor.getEditorId())

+ }

+

+ /**

+ * Returns the payload used by the [EditorMessageDispatcher] class to establish an IPC bridge

+ * across editor instances.

+ */

+ fun getMessageDispatcherPayload(): Bundle {

+ return Bundle().apply {

+ putInt(KEY_EDITOR_ID, editor.getEditorId())

+ putParcelable(KEY_EDITOR_MESSENGER, Messenger(dispatcherHandler))

+ }

+ }

+}

+ * Specifies the policy for launches.

+enum class LaunchPolicy {

+ * Launch policy is determined by the editor settings or based on the device and screen metrics.

+ AUTO,

+

+ * Launches happen in the same window.

+ SAME,

+ ADJACENT

+ val launchPolicy: LaunchPolicy = LaunchPolicy.SAME,

+ val supportsPiPMode: Boolean = false

+ launchPolicy: LaunchPolicy = LaunchPolicy.SAME,

+ supportsPiPMode: Boolean = false

+ ) : this(windowClass.name, windowId, processNameSuffix, launchPolicy, supportsPiPMode)

+import android.app.ActivityOptions

+ @JvmStatic

+ protected val EXTRA_COMMAND_LINE_PARAMS = "command_line_params"

+ @JvmStatic

+ protected val EXTRA_PIP_AVAILABLE = "pip_available"

+ @JvmStatic

+ protected val EXTRA_LAUNCH_IN_PIP = "launch_in_pip_requested"

+ private const val BREAKPOINTS_ARG = "--breakpoints"

+ private const val BREAKPOINTS_ARG_SHORT = "-b"

+ internal val RUN_GAME_INFO = EditorWindowInfo(GodotGame::class.java, 667, ":GodotGame", LaunchPolicy.AUTO, true)

+

+ /**

+ * Sets of constants to specify the Play window PiP mode.

+ *

+ * Should match the values in `editor/editor_settings.cpp'` for the

+ * 'run/window_placement/play_window_pip_mode' setting.

+ */

+ private const val PLAY_WINDOW_PIP_DISABLED = 0

+ private const val PLAY_WINDOW_PIP_ENABLED = 1

+ private const val PLAY_WINDOW_PIP_ENABLED_FOR_SAME_AS_EDITOR = 2

+ private val editorMessageDispatcher = EditorMessageDispatcher(this)

+ internal open fun getEditorId() = EDITOR_MAIN_INFO.windowId

+

+ editorMessageDispatcher.parseStartIntent(packageManager, intent)

+

+ protected fun getNewGodotInstanceIntent(editorWindowInfo: EditorWindowInfo, args: Array<String>): Intent {

+

+ val launchPolicy = resolveLaunchPolicyIfNeeded(editorWindowInfo.launchPolicy)

+ val isPiPAvailable = if (editorWindowInfo.supportsPiPMode && hasPiPSystemFeature()) {

+ val pipMode = getPlayWindowPiPMode()

+ pipMode == PLAY_WINDOW_PIP_ENABLED ||

+ (pipMode == PLAY_WINDOW_PIP_ENABLED_FOR_SAME_AS_EDITOR && launchPolicy == LaunchPolicy.SAME)

+ } else {

+ false

+ }

+ newInstance.putExtra(EXTRA_PIP_AVAILABLE, isPiPAvailable)

+

+ if (launchPolicy == LaunchPolicy.ADJACENT) {

+ if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {

+ } else if (launchPolicy == LaunchPolicy.SAME) {

+ if (isPiPAvailable &&

+ (args.contains(BREAKPOINTS_ARG) || args.contains(BREAKPOINTS_ARG_SHORT))) {

+ Log.v(TAG, "Launching in PiP mode because of breakpoints")

+ newInstance.putExtra(EXTRA_LAUNCH_IN_PIP, true)

+ }

+

+ return newInstance

+ }

+

+ override fun onNewGodotInstanceRequested(args: Array<String>): Int {

+ val editorWindowInfo = getEditorWindowInfo(args)

+

+ // Launch a new activity

+ val sourceView = godotFragment?.view

+ val activityOptions = if (sourceView == null) {

+ null

+ } else {

+ val startX = sourceView.width / 2

+ val startY = sourceView.height / 2

+ ActivityOptions.makeScaleUpAnimation(sourceView, startX, startY, 0, 0)

+ }

+

+ val newInstance = getNewGodotInstanceIntent(editorWindowInfo, args)

+ ProcessPhoenix.triggerRebirth(this, activityOptions?.toBundle(), newInstance)

+ ProcessPhoenix.triggerRebirth(this, activityOptions?.toBundle(), newInstance)

+ .putExtra(EditorMessageDispatcher.EXTRA_MSG_DISPATCHER_PAYLOAD, editorMessageDispatcher.getMessageDispatcherPayload())

+ startActivity(newInstance, activityOptions?.toBundle())

+ // Send an inter-process message to request the target editor window to force quit.

+ if (editorMessageDispatcher.requestForceQuit(editorWindowInfo.windowId)) {

+ return true

+ }

+

+ // Fallback to killing the target process.

+ * Retrieves the play window pip mode editor setting.

+ */

+ private fun getPlayWindowPiPMode(): Int {

+ return try {

+ Integer.parseInt(GodotLib.getEditorSetting("run/window_placement/play_window_pip_mode"))

+ } catch (e: NumberFormatException) {

+ PLAY_WINDOW_PIP_ENABLED_FOR_SAME_AS_EDITOR

+ }

+ }

+

+ /**

+ * If the launch policy is [LaunchPolicy.AUTO], resolve it into a specific policy based on the

+ * editor setting or device and screen metrics.

+ *

+ * If the launch policy is [LaunchPolicy.PIP] but PIP is not supported, fallback to the default

+ * launch policy.

+ private fun resolveLaunchPolicyIfNeeded(policy: LaunchPolicy): LaunchPolicy {

+ val inMultiWindowMode = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {

+ isInMultiWindowMode

+ } else {

+ false

+ }

+ val defaultLaunchPolicy = if (inMultiWindowMode || isLargeScreen) {

+ LaunchPolicy.ADJACENT

+ } else {

+ LaunchPolicy.SAME

+ }

+

+ return when (policy) {

+ LaunchPolicy.AUTO -> {

+ try {

+ when (Integer.parseInt(GodotLib.getEditorSetting("run/window_placement/android_window"))) {

+ ANDROID_WINDOW_SAME_AS_EDITOR -> LaunchPolicy.SAME

+ ANDROID_WINDOW_SIDE_BY_SIDE_WITH_EDITOR -> LaunchPolicy.ADJACENT

+ else -> {

+ // ANDROID_WINDOW_AUTO

+ defaultLaunchPolicy

+ }

+ } catch (e: NumberFormatException) {

+ Log.w(TAG, "Error parsing the Android window placement editor setting", e)

+ // Fall-back to the default launch policy

+ defaultLaunchPolicy

+

+ else -> {

+ policy

+ }

+ /**

+ * Returns true the if the device supports picture-in-picture (PiP)

+ */

+ protected open fun hasPiPSystemFeature() = Build.VERSION.SDK_INT >= Build.VERSION_CODES.N &&

+ packageManager.hasSystemFeature(PackageManager.FEATURE_PICTURE_IN_PICTURE)

+

+import android.annotation.SuppressLint

+import android.app.PictureInPictureParams

+import android.content.Intent

+import android.graphics.Rect

+import android.os.Build

+import android.os.Bundle

+import android.util.Log

+import android.view.View

+ companion object {

+ private val TAG = GodotGame::class.java.simpleName

+ }

+

+ private val gameViewSourceRectHint = Rect()

+ private val pipButton: View? by lazy {

+ findViewById(R.id.godot_pip_button)

+ }

+

+ private var pipAvailable = false

+

+ @SuppressLint("ClickableViewAccessibility")

+ override fun onCreate(savedInstanceState: Bundle?) {

+ super.onCreate(savedInstanceState)

+

+ if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {

+ val gameView = findViewById<View>(R.id.godot_fragment_container)

+ gameView?.addOnLayoutChangeListener { v, left, top, right, bottom, oldLeft, oldTop, oldRight, oldBottom ->

+ gameView.getGlobalVisibleRect(gameViewSourceRectHint)

+ }

+ }

+

+ pipButton?.setOnClickListener { enterPiPMode() }

+

+ handleStartIntent(intent)

+ }

+

+ override fun onNewIntent(newIntent: Intent) {

+ super.onNewIntent(newIntent)

+ handleStartIntent(newIntent)

+ }

+

+ private fun handleStartIntent(intent: Intent) {

+ pipAvailable = intent.getBooleanExtra(EXTRA_PIP_AVAILABLE, pipAvailable)

+ updatePiPButtonVisibility()

+

+ val pipLaunchRequested = intent.getBooleanExtra(EXTRA_LAUNCH_IN_PIP, false)

+ if (pipLaunchRequested) {

+ enterPiPMode()

+ }

+ }

+

+ private fun updatePiPButtonVisibility() {

+ pipButton?.visibility = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N && pipAvailable && !isInPictureInPictureMode) {

+ View.VISIBLE

+ } else {

+ View.GONE

+ }

+ }

+

+ private fun enterPiPMode() {

+ if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N && pipAvailable) {

+ if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {

+ val builder = PictureInPictureParams.Builder().setSourceRectHint(gameViewSourceRectHint)

+ if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {

+ builder.setSeamlessResizeEnabled(false)

+ }

+ setPictureInPictureParams(builder.build())

+ }

+

+ Log.v(TAG, "Entering PiP mode")

+ enterPictureInPictureMode()

+ }

+ }

+

+ override fun onPictureInPictureModeChanged(isInPictureInPictureMode: Boolean) {

+ super.onPictureInPictureModeChanged(isInPictureInPictureMode)

+ Log.v(TAG, "onPictureInPictureModeChanged: $isInPictureInPictureMode")

+ updatePiPButtonVisibility()

+ }

+

+ override fun onStop() {

+ super.onStop()

+

+ val isInPiPMode = Build.VERSION.SDK_INT >= Build.VERSION_CODES.N && isInPictureInPictureMode

+ if (isInPiPMode && !isFinishing) {

+ // We get in this state when PiP is closed, so we terminate the activity.

+ finish()

+ }

+ }

+

+ override fun getGodotAppLayout() = R.layout.godot_game_layout

+

+ override fun getEditorId() = RUN_GAME_INFO.windowId

+<vector xmlns:android="http://schemas.android.com/apk/res/android"

+ android:width="108dp"

+ android:height="108dp"

+ android:tint="#FFFFFF"

+ android:viewportWidth="24"

+ android:viewportHeight="24">

+ <group

+ android:scaleX="0.522"

+ android:scaleY="0.522"

+ android:translateX="5.736"

+ android:translateY="5.736">

+ <path

+ android:fillColor="@android:color/white"

+ android:pathData="M21.58,16.09l-1.09,-7.66C20.21,6.46 18.52,5 16.53,5H7.47C5.48,5 3.79,6.46 3.51,8.43l-1.09,7.66C2.2,17.63 3.39,19 4.94,19h0c0.68,0 1.32,-0.27 1.8,-0.75L9,16h6l2.25,2.25c0.48,0.48 1.13,0.75 1.8,0.75h0C20.61,19 21.8,17.63 21.58,16.09zM19.48,16.81C19.4,16.9 19.27,17 19.06,17c-0.15,0 -0.29,-0.06 -0.39,-0.16L15.83,14H8.17l-2.84,2.84C5.23,16.94 5.09,17 4.94,17c-0.21,0 -0.34,-0.1 -0.42,-0.19c-0.08,-0.09 -0.16,-0.23 -0.13,-0.44l1.09,-7.66C5.63,7.74 6.48,7 7.47,7h9.06c0.99,0 1.84,0.74 1.98,1.72l1.09,7.66C19.63,16.58 19.55,16.72 19.48,16.81z" />

+ <path

+ android:fillColor="@android:color/white"

+ android:pathData="M9,8l-1,0l0,2l-2,0l0,1l2,0l0,2l1,0l0,-2l2,0l0,-1l-2,0z" />

+ <path

+ android:fillColor="@android:color/white"

+ android:pathData="M17,12m-1,0a1,1 0,1 1,2 0a1,1 0,1 1,-2 0" />

+ <path

+ android:fillColor="@android:color/white"

+ android:pathData="M15,9m-1,0a1,1 0,1 1,2 0a1,1 0,1 1,-2 0" />

+ </group>

+</vector>

+<vector xmlns:android="http://schemas.android.com/apk/res/android"

+ android:width="48dp"

+ android:height="48dp"

+ android:tint="#FFFFFF"

+ android:viewportWidth="24"

+ android:viewportHeight="24">

+

+ <path

+ android:fillColor="@android:color/white"

+ android:pathData="M5,16h3v3h2v-5L5,14v2zM8,8L5,8v2h5L10,5L8,5v3zM14,19h2v-3h3v-2h-5v5zM16,8L16,5h-2v5h5L19,8h-3z" />

+

+</vector>

+<?xml version="1.0" encoding="utf-8"?>

+<shape xmlns:android="http://schemas.android.com/apk/res/android"

+ android:shape="oval">

+

+ <size

+ android:width="60dp"

+ android:height="60dp" />

+

+ <solid android:color="#44000000" />

+</shape>

+<?xml version="1.0" encoding="utf-8"?>

+<selector xmlns:android="http://schemas.android.com/apk/res/android">

+

+ <item android:drawable="@drawable/pip_button_activated_bg_drawable" android:state_pressed="true" />

+ <item android:drawable="@drawable/pip_button_activated_bg_drawable" android:state_hovered="true" />

+

+ <item android:drawable="@drawable/pip_button_default_bg_drawable" />

+

+</selector>

+<?xml version="1.0" encoding="utf-8"?>

+<shape xmlns:android="http://schemas.android.com/apk/res/android"

+ android:shape="oval">

+

+ <size

+ android:width="60dp"

+ android:height="60dp" />

+

+ <solid android:color="#13000000" />

+</shape>

+<?xml version="1.0" encoding="utf-8"?>

+<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"

+ xmlns:tools="http://schemas.android.com/tools"

+ android:layout_width="match_parent"

+ android:layout_height="match_parent">

+

+ <FrameLayout

+ android:id="@+id/godot_fragment_container"

+ android:layout_width="match_parent"

+ android:layout_height="match_parent"/>

+

+ <ImageView

+ android:id="@+id/godot_pip_button"

+ android:layout_width="wrap_content"

+ android:layout_height="wrap_content"

+ android:layout_margin="36dp"

+ android:contentDescription="@string/pip_button_description"

+ android:background="@drawable/pip_button_bg_drawable"

+ android:scaleType="center"

+ android:src="@drawable/outline_fullscreen_exit_48"

+ android:visibility="gone"

+ android:layout_gravity="end|top"

+ tools:visibility="visible" />

+

+</FrameLayout>

+<?xml version="1.0" encoding="utf-8"?>

+<adaptive-icon xmlns:android="http://schemas.android.com/apk/res/android">

+ <background android:drawable="@mipmap/icon_background"/>

+ <foreground android:drawable="@drawable/ic_play_window_foreground"/>

+</adaptive-icon>

+ <dimen name="editor_default_window_height">640dp</dimen>

+ <string name="godot_game_activity_name">Godot Play window</string>

+ <string name="pip_button_description">Button used to toggle picture-in-picture mode for the Play window</string>

+import android.app.ActivityOptions;

+ // -- GODOT start --

+ private static final String KEY_RESTART_ACTIVITY_OPTIONS = "phoenix_restart_activity_options";

+ // -- GODOT end --

+ // -- GODOT start --

+ triggerRebirth(context, null, nextIntents);

+ }

+

+ /**

+ * Call to restart the application process using the specified intents launched with the given

+ * {@link ActivityOptions}.

+ * <p>

+ * Behavior of the current process after invoking this method is undefined.

+ */

+ public static void triggerRebirth(Context context, Bundle activityOptions, Intent... nextIntents) {

+ if (activityOptions != null) {

+ intent.putExtra(KEY_RESTART_ACTIVITY_OPTIONS, activityOptions);

+ }

+ Intent launchIntent = getIntent();

+ ArrayList<Intent> intents = launchIntent.getParcelableArrayListExtra(KEY_RESTART_INTENTS);

+ Bundle activityOptions = launchIntent.getBundleExtra(KEY_RESTART_ACTIVITY_OPTIONS);

+ startActivities(intents.toArray(new Intent[intents.size()]), activityOptions);

+ forceQuit(this, launchIntent.getIntExtra(KEY_MAIN_PROCESS_PID, -1));

+ if (flt == "*.*") {

+ filter_exts.push_back("*");

+ } else {

+ filter_exts.push_back(flt);

+ }

+ if (flt == "*.*") {

+ filter_exts.push_back("*");

+ filter_names.push_back(RTR("All Files"));

+ } else {

+ filter_exts.push_back(flt);

+ filter_names.push_back(flt);

+ }

+ filter_exts.push_back("*");

+ WCHAR exe_name[32767] = {};

+ if (!GetModuleFileNameW(nullptr, exe_name, 32767)) {

+def try_cmd(test, prefix, arch, check_clang=False):

+ archs = ["x86_64", "x86_32", "arm64", "arm32"]

+ archs = [arch]

+

+ for a in archs:

+ get_mingw_bin_prefix(prefix, a) + test,

+ outs, errs = out.communicate()

+ if check_clang and not outs.startswith(b"clang"):

+ return False

+ if not env["use_llvm"] and try_cmd("gcc --version", env["mingw_prefix"], env["arch"], True):

+ print("Detected GCC to be a wrapper for Clang.")

+ env["use_llvm"] = True

+

+ if env["use_llvm"] and os.name == "nt" and methods._colorize:

+ env.Append(CCFLAGS=["$(-fansi-escape-codes$)", "$(-fcolor-diagnostics$)"])

+

+ env.Append(ARFLAGS=["--thin"])

+

+ String path = String::utf16((const char16_t *)lpw_path).replace("\\", "/").trim_prefix(R"(\\?\)").simplify_path();

+ String dir = ProjectSettings::get_singleton()->globalize_path(fd->current_directory);

+ if (dir == ".") {

+ dir = OS::get_singleton()->get_executable_path().get_base_dir();

+ }

+ if (dir.is_relative_path() || dir == ".") {

+ Char16String current_dir_name;

+ size_t str_len = GetCurrentDirectoryW(0, nullptr);

+ current_dir_name.resize(str_len + 1);

+ GetCurrentDirectoryW(current_dir_name.size(), (LPWSTR)current_dir_name.ptrw());

+ if (dir == ".") {

+ dir = String::utf16((const char16_t *)current_dir_name.get_data()).trim_prefix(R"(\\?\)").replace("\\", "/");

+ } else {

+ dir = String::utf16((const char16_t *)current_dir_name.get_data()).trim_prefix(R"(\\?\)").replace("\\", "/").path_join(dir);

+ }

+ }

+ dir = dir.simplify_path();

+ dir = dir.replace("/", "\\");

+ if (!dir.is_network_share_path() && !dir.begins_with(R"(\\?\)")) {

+ dir = R"(\\?\)" + dir;

+ }

+ file_names.push_back(String::utf16((const char16_t *)file_path).replace("\\", "/").trim_prefix(R"(\\?\)"));

+ file_names.push_back(String::utf16((const char16_t *)file_path).replace("\\", "/").trim_prefix(R"(\\?\)"));

+#ifndef RT_MANIFEST

+#define RT_MANIFEST 24

+#endif

+

+1 RT_MANIFEST "godot.manifest"

+static String fix_path(const String &p_path) {

+ String path = p_path;

+ if (p_path.is_relative_path()) {

+ Char16String current_dir_name;

+ size_t str_len = GetCurrentDirectoryW(0, nullptr);

+ current_dir_name.resize(str_len + 1);

+ GetCurrentDirectoryW(current_dir_name.size(), (LPWSTR)current_dir_name.ptrw());

+ path = String::utf16((const char16_t *)current_dir_name.get_data()).trim_prefix(R"(\\?\)").replace("\\", "/").path_join(path);

+ }

+ path = path.simplify_path();

+ path = path.replace("/", "\\");

+ if (!path.is_network_share_path() && !path.begins_with(R"(\\?\)")) {

+ path = R"(\\?\)" + path;

+ }

+ return path;

+}

+

+void debug_dynamic_library_check_dependencies(const String &p_path, HashSet<String> &r_checked, HashSet<String> &r_missing) {

+ char16_t full_name_wc[32767];

+ } else if (SearchPathW(nullptr, (LPCWSTR)name.utf16().get_data(), nullptr, 32767, (LPWSTR)full_name_wc, nullptr)) {

+ debug_dynamic_library_check_dependencies(String::utf16(full_name_wc), r_checked, r_missing);

+ } else if (SearchPathW((LPCWSTR)(p_path.get_base_dir().utf16().get_data()), (LPCWSTR)name.utf16().get_data(), nullptr, 32767, (LPWSTR)full_name_wc, nullptr)) {

+ debug_dynamic_library_check_dependencies(String::utf16(full_name_wc), r_checked, r_missing);

+ String path = p_path;

+ String dll_dir = ProjectSettings::get_singleton()->globalize_path(load_path.get_base_dir());

+ String wpath = fix_path(dll_dir);

+ cookie = add_dll_directory((LPCWSTR)(wpath.get_base_dir().utf16().get_data()));

+ p_library_handle = (void *)LoadLibraryExW((LPCWSTR)(wpath.utf16().get_data()), nullptr, (p_data != nullptr && p_data->also_set_library_path && has_dll_directory_api) ? LOAD_LIBRARY_SEARCH_DEFAULT_DIRS : 0);

+ debug_dynamic_library_check_dependencies(wpath, checked_libs, missing_libs);

+ String path = p_path.is_absolute_path() ? fix_path(p_path) : p_path;

+ Char16String current_dir_name;

+ size_t str_len = GetCurrentDirectoryW(0, nullptr);

+ current_dir_name.resize(str_len + 1);

+ GetCurrentDirectoryW(current_dir_name.size(), (LPWSTR)current_dir_name.ptrw());

+ if (current_dir_name.size() >= MAX_PATH) {

+ Char16String current_short_dir_name;

+ str_len = GetShortPathNameW((LPCWSTR)current_dir_name.ptr(), nullptr, 0);

+ current_short_dir_name.resize(str_len);

+ GetShortPathNameW((LPCWSTR)current_dir_name.ptr(), (LPWSTR)current_short_dir_name.ptrw(), current_short_dir_name.size());

+ current_dir_name = current_short_dir_name;

+ }

+

+ if (!CreateProcessW(nullptr, (LPWSTR)(command.utf16().ptrw()), nullptr, nullptr, true, creation_flags, nullptr, (LPWSTR)current_dir_name.ptr(), si_w, &pi.pi)) {

+ String path = p_path.is_absolute_path() ? fix_path(p_path) : p_path;

+ Char16String current_dir_name;

+ size_t str_len = GetCurrentDirectoryW(0, nullptr);

+ current_dir_name.resize(str_len + 1);

+ GetCurrentDirectoryW(current_dir_name.size(), (LPWSTR)current_dir_name.ptrw());

+ if (current_dir_name.size() >= MAX_PATH) {

+ Char16String current_short_dir_name;

+ str_len = GetShortPathNameW((LPCWSTR)current_dir_name.ptr(), nullptr, 0);

+ current_short_dir_name.resize(str_len);

+ GetShortPathNameW((LPCWSTR)current_dir_name.ptr(), (LPWSTR)current_short_dir_name.ptrw(), current_short_dir_name.size());

+ current_dir_name = current_short_dir_name;

+ }

+

+ int ret = CreateProcessW(nullptr, (LPWSTR)(command.utf16().ptrw()), nullptr, nullptr, inherit_handles, creation_flags, nullptr, (LPWSTR)current_dir_name.ptr(), si_w, &pi.pi);

+ String path = p_path.is_absolute_path() ? fix_path(p_path) : p_path;

+ Char16String current_dir_name;

+ size_t str_len = GetCurrentDirectoryW(0, nullptr);

+ current_dir_name.resize(str_len + 1);

+ GetCurrentDirectoryW(current_dir_name.size(), (LPWSTR)current_dir_name.ptrw());

+ if (current_dir_name.size() >= MAX_PATH) {

+ Char16String current_short_dir_name;

+ str_len = GetShortPathNameW((LPCWSTR)current_dir_name.ptr(), nullptr, 0);

+ current_short_dir_name.resize(str_len);

+ GetShortPathNameW((LPCWSTR)current_dir_name.ptr(), (LPWSTR)current_short_dir_name.ptrw(), current_short_dir_name.size());

+ current_dir_name = current_short_dir_name;

+ }

+

+ int ret = CreateProcessW(nullptr, (LPWSTR)(command.utf16().ptrw()), nullptr, nullptr, false, creation_flags, nullptr, (LPWSTR)current_dir_name.ptr(), si_w, &pi.pi);

+ WCHAR file_path[32767];

+ hr = loader->GetFilePathFromKey(reference_key, reference_key_size, &file_path[0], 32767);

+ WCHAR file_path[32767];

+ hr = loader->GetFilePathFromKey(reference_key, reference_key_size, &file_path[0], 32767);

+ p_path = fix_path(p_path);

+ // Reset CWD to ensure long path is used.

+ Char16String current_dir_name;

+ size_t str_len = GetCurrentDirectoryW(0, nullptr);

+ current_dir_name.resize(str_len + 1);

+ GetCurrentDirectoryW(current_dir_name.size(), (LPWSTR)current_dir_name.ptrw());

+

+ Char16String new_current_dir_name;

+ str_len = GetLongPathNameW((LPCWSTR)current_dir_name.get_data(), nullptr, 0);

+ new_current_dir_name.resize(str_len + 1);

+ GetLongPathNameW((LPCWSTR)current_dir_name.get_data(), (LPWSTR)new_current_dir_name.ptrw(), new_current_dir_name.size());

+

+ SetCurrentDirectoryW((LPCWSTR)new_current_dir_name.get_data());

+

+ main->first_resized_line.store(0); // Invalidate all lines.

+ main->first_invalid_font_line.store(0); // Invalidate all lines.

+ main->first_invalid_line.store(0); // Invalidate all lines.

+ return default_tab_stops;

+ push_paragraph(HORIZONTAL_ALIGNMENT_CENTER, text_direction, language, st_parser, default_jst_flags, default_tab_stops);

+ push_paragraph(HORIZONTAL_ALIGNMENT_FILL, text_direction, language, st_parser, default_jst_flags, default_tab_stops);

+ push_paragraph(HORIZONTAL_ALIGNMENT_LEFT, text_direction, language, st_parser, default_jst_flags, default_tab_stops);

+ push_paragraph(HORIZONTAL_ALIGNMENT_RIGHT, text_direction, language, st_parser, default_jst_flags, default_tab_stops);

+ String lang = language;

+ PackedFloat32Array tab_stops = default_tab_stops;

+ if (!text.is_empty()) {

+ _apply_translation();

+ } else {

+ main->first_invalid_line.store(0); // Invalidate all lines.

+ _validate_line_caches();

+ }

+ queue_redraw();

+ }

+}

+

+Control::TextDirection RichTextLabel::get_text_direction() const {

+ return text_direction;

+}

+

+void RichTextLabel::set_horizontal_alignment(HorizontalAlignment p_alignment) {

+ ERR_FAIL_INDEX((int)p_alignment, 4);

+ _stop_thread();

+

+ if (default_alignment != p_alignment) {

+ default_alignment = p_alignment;

+ if (!text.is_empty()) {

+ _apply_translation();

+ } else {

+ main->first_invalid_line.store(0); // Invalidate all lines.

+ _validate_line_caches();

+ }

+ queue_redraw();

+ }

+}

+

+HorizontalAlignment RichTextLabel::get_horizontal_alignment() const {

+ return default_alignment;

+}

+

+void RichTextLabel::set_justification_flags(BitField<TextServer::JustificationFlag> p_flags) {

+ _stop_thread();

+

+ if (default_jst_flags != p_flags) {

+ default_jst_flags = p_flags;

+ if (!text.is_empty()) {

+ _apply_translation();

+ } else {

+ main->first_invalid_line.store(0); // Invalidate all lines.

+ _validate_line_caches();

+ }

+BitField<TextServer::JustificationFlag> RichTextLabel::get_justification_flags() const {

+ return default_jst_flags;

+}

+

+void RichTextLabel::set_tab_stops(const PackedFloat32Array &p_tab_stops) {

+ _stop_thread();

+

+ if (default_tab_stops != p_tab_stops) {

+ default_tab_stops = p_tab_stops;

+ if (!text.is_empty()) {

+ _apply_translation();

+ } else {

+ main->first_invalid_line.store(0); // Invalidate all lines.

+ _validate_line_caches();

+ }

+ queue_redraw();

+ }

+}

+

+PackedFloat32Array RichTextLabel::get_tab_stops() const {

+ return default_tab_stops;

+}

+

+ if (!text.is_empty()) {

+ _apply_translation();

+ } else {

+ main->first_invalid_line.store(0); // Invalidate all lines.

+ _validate_line_caches();

+ }

+ main->first_invalid_line.store(0); // Invalidate all lines.

+ if (!text.is_empty()) {

+ _apply_translation();

+ } else {

+ main->first_invalid_line.store(0); // Invalidate all lines.

+ _validate_line_caches();

+ }

+ main->first_invalid_line = 0; // Invalidate all lines.

+ main->first_invalid_line.store(0); // Invalidate all lines..

+ ClassDB::bind_method(D_METHOD("set_horizontal_alignment", "alignment"), &RichTextLabel::set_horizontal_alignment);

+ ClassDB::bind_method(D_METHOD("get_horizontal_alignment"), &RichTextLabel::get_horizontal_alignment);

+ ClassDB::bind_method(D_METHOD("set_justification_flags", "justification_flags"), &RichTextLabel::set_justification_flags);

+ ClassDB::bind_method(D_METHOD("get_justification_flags"), &RichTextLabel::get_justification_flags);

+ ClassDB::bind_method(D_METHOD("set_tab_stops", "tab_stops"), &RichTextLabel::set_tab_stops);

+ ClassDB::bind_method(D_METHOD("get_tab_stops"), &RichTextLabel::get_tab_stops);

+

+ ADD_PROPERTY(PropertyInfo(Variant::INT, "horizontal_alignment", PROPERTY_HINT_ENUM, "Left,Center,Right,Fill"), "set_horizontal_alignment", "get_horizontal_alignment");

+ ADD_PROPERTY(PropertyInfo(Variant::INT, "justification_flags", PROPERTY_HINT_FLAGS, "Kashida Justification:1,Word Justification:2,Justify Only After Last Tab:8,Skip Last Line:32,Skip Last Line With Visible Characters:64,Do Not Skip Single Line:128"), "set_justification_flags", "get_justification_flags");

+ ADD_PROPERTY(PropertyInfo(Variant::PACKED_FLOAT32_ARRAY, "tab_stops"), "set_tab_stops", "get_tab_stops");

+

+ main->first_invalid_line.store(0); // Invalidate all lines.

+ main->first_invalid_line.store(0); // Invalidate all lines.

+ PackedFloat32Array default_tab_stops;

+ void set_horizontal_alignment(HorizontalAlignment p_alignment);

+ HorizontalAlignment get_horizontal_alignment() const;

+

+ void set_justification_flags(BitField<TextServer::JustificationFlag> p_flags);

+ BitField<TextServer::JustificationFlag> get_justification_flags() const;

+

+ void set_tab_stops(const PackedFloat32Array &p_tab_stops);

+ PackedFloat32Array get_tab_stops() const;

+

+ if (parent->last_child == this) {

+ parent->last_child = prev;

+ }

+ ADD_PROPERTY(PropertyInfo(Variant::DICTIONARY, "_bundled", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_STORAGE | PROPERTY_USAGE_INTERNAL), "_set_bundled_scene", "_get_bundled_scene");

+ // https://github.com/godotengine/godot/issues/96205

+ SUBCASE("[Tree] Get last item after removal.") {

+ Tree *tree = memnew(Tree);

+ TreeItem *root = tree->create_item();

+

+ TreeItem *child1 = tree->create_item(root);

+ TreeItem *child2 = tree->create_item(root);

+

+ CHECK_EQ(root->get_child_count(), 2);

+ CHECK_EQ(tree->get_last_item(), child2);

+

+ root->remove_child(child2);

+

+ CHECK_EQ(root->get_child_count(), 1);

+ CHECK_EQ(tree->get_last_item(), child1);

+

+ root->add_child(child2);

+

+ CHECK_EQ(root->get_child_count(), 2);

+ CHECK_EQ(tree->get_last_item(), child2);

+

+ memdelete(tree);

+ }

+

+ * Version: git (e0c69447d4d3945c3c92ac1751e4cdc9803a8303, 2024)

+ * Modifications: Added a few modifiers to comply with C++ nature.

+index cfed266bef..23612bb0bf 100644

+@@ -395,7 +395,7 @@ unsigned int qoa_encode_frame(const short *sample_data, qoa_desc *qoa, unsigned

+ qoa_uint64_t best_slice = 0;

++ qoa_lms_t best_lms = {};

+ int best_scalefactor = 0;

+ qoa_uint64_t best_slice = 0;

+ qoa_lms_t best_lms = {};

+ int best_scalefactor = 0;