import os

import sys

from platform_methods import detect_arch, detect_mvk

from typing import TYPE_CHECKING

# Validate arch.

supported_arches = ["x86_64", "arm64"]

if env["arch"] not in supported_arches:

'Unsupported CPU architecture "%s" for macOS. Supported architectures are: %s.'

% (env["arch"], ", ".join(supported_arches))

)

## Build type

if mvk_path != "":

env.Append(LINKFLAGS=["-L" + mvk_path])

else:

"MoltenVK SDK installation directory not found, use 'vulkan_sdk_path' SCons parameter to specify SDK path."

)

sys.exit(255)

NSImage *_convert_to_nsimg(Ref<Image> &p_image) const;

Point2i _get_screens_origin() const;

void send_event(NSEvent *p_event);

void send_window_event(const WindowData &p_wd, WindowEvent p_event);

void release_pressed_events();

virtual void force_process_and_drop_events() override;

virtual void release_rendering_thread() override;

virtual void swap_buffers() override;

virtual void set_native_icon(const String &p_filename) override;

Rect2i srect = screen_get_usable_rect(rq_screen);

Point2i wpos = p_rect.position;

if (srect != Rect2i()) {

}

// macOS native y-coordinate relative to _get_screens_origin() is negative,

// Godot passes a positive value.

displays_arrangement_dirty = false;

}

Point2i DisplayServerMacOS::_get_screens_origin() const {

// Returns the native top-left screen coordinate of the smallest rectangle

// that encompasses all screens. Needed in get_screen_position(),

}

void DisplayServerMacOS::_dispatch_input_event(const Ref<InputEvent> &p_event) {

if (!in_dispatch_input_event) {

in_dispatch_input_event = true;

case FEATURE_CURSOR_SHAPE:

case FEATURE_CUSTOM_CURSOR_SHAPE:

case FEATURE_NATIVE_DIALOG:

case FEATURE_IME:

case FEATURE_WINDOW_TRANSPARENCY:

case FEATURE_HIDPI:

button_pressed = int64_t(2 + (ret - NSAlertThirdButtonReturn));

}

Variant ret;

Callable::CallError ce;

const Variant *args[1] = { &button_pressed };

String url;

url.parse_utf8([[[panel URL] path] UTF8String]);

files.push_back(url);

if (p_options_in_cb) {

Variant v_result = true;

Variant v_files = files;

}

}

} else {

if (p_options_in_cb) {

Variant v_result = false;

Variant v_files = Vector<String>();

url.parse_utf8([[[urls objectAtIndex:i] path] UTF8String]);

files.push_back(url);

}

if (p_options_in_cb) {

Variant v_result = true;

Variant v_files = files;

}

}

} else {

if (p_options_in_cb) {

Variant v_result = false;

Variant v_files = Vector<String>();

String ret;

ret.parse_utf8([[input stringValue] UTF8String]);

Variant v_result = ret;

Variant ret;

Callable::CallError ce;

Size2i wsize = window_get_size(p_window);

wpos += srect.position;

window_set_position(wpos, p_window);

if (was_fullscreen) {

ERR_FAIL_COND(!windows.has(p_window));

WindowData &wd = windows[p_window];

return;

}

}

void DisplayServerMacOS::update_presentation_mode() {

for (const KeyValue<WindowID, WindowData> &wd : windows) {

}

}

}

void DisplayServerMacOS::window_set_min_size(const Size2i p_size, WindowID p_window) {

WindowData &wd = windows[p_window];

float scale = screen_get_max_scale();

wd.wb_offset = p_offset / scale;

if (wd.window_button_view) {

[wd.window_button_view setOffset:NSMakePoint(wd.wb_offset.x, wd.wb_offset.y)];

}

}

void DisplayServerMacOS::process_events() {

while (true) {

NSEvent *event = [NSApp

if (!drop_events) {

_process_key_events();

Input::get_singleton()->flush_buffered_events();

}

for (KeyValue<WindowID, WindowData> &E : windows) {

}

}

}

}

void DisplayServerMacOS::force_process_and_drop_events() {

}

void DisplayServerMacOS::release_rendering_thread() {

}

void DisplayServerMacOS::swap_buffers() {

<members>

<member name="application/additional_plist_content" type="String" setter="" getter="">

Additional data added to the root [code]&lt;dict&gt;[/code] section of the [url=https://developer.apple.com/documentation/bundleresources/information_property_list]Info.plist[/url] file. The value should be an XML section with pairs of key-value elements, e.g.:

&lt;key&gt;key_name&lt;/key&gt;

&lt;string&gt;value&lt;/string&gt;

[/codeblock]

return false;

}

}

return true;

}

return OK;

}

int codesign_tool = p_preset->get("codesign/codesign");

switch (codesign_tool) {

case 1: { // built-in ad-hoc

args.push_back("--code-signature-flags");

args.push_back("runtime");

args.push_back("-v"); /* provide some more feedback */

args.push_back(p_path);

args.push_back(p_preset->get("codesign/identity"));

}

args.push_back("-v"); /* provide some more feedback */

args.push_back("-f");

}

Error EditorExportPlatformMacOS::_code_sign_directory(const Ref<EditorExportPreset> &p_preset, const String &p_path,

static Vector<String> extensions_to_sign;

if (extensions_to_sign.is_empty()) {

}

if (extensions_to_sign.find(current_file.get_extension()) > -1) {

if (code_sign_error != OK) {

return code_sign_error;

}

FileAccess::set_unix_permissions(current_file_path, 0755);

}

} else if (dir_access->current_is_dir()) {

if (code_sign_error != OK) {

return code_sign_error;

}

Error EditorExportPlatformMacOS::_copy_and_sign_files(Ref<DirAccess> &dir_access, const String &p_src_path,

const String &p_in_app_path, bool p_sign_enabled,

const Ref<EditorExportPreset> &p_preset, const String &p_ent_path,

bool p_should_error_on_non_code_sign) {

static Vector<String> extensions_to_sign;

if (err == OK && p_sign_enabled) {

if (dir_access->dir_exists(p_src_path) && p_src_path.get_extension().is_empty()) {

// If it is a directory, find and sign all dynamic libraries.

} else {

if (extensions_to_sign.find(p_in_app_path.get_extension()) > -1) {

}

if (dir_access->file_exists(p_in_app_path) && is_executable(p_in_app_path)) {

// chmod with 0755 if the file is executable.

Error EditorExportPlatformMacOS::_export_macos_plugins_for(Ref<EditorExportPlugin> p_editor_export_plugin,

const String &p_app_path_name, Ref<DirAccess> &dir_access,

bool p_sign_enabled, const Ref<EditorExportPreset> &p_preset,

Error error{ OK };

const Vector<String> &macos_plugins{ p_editor_export_plugin->get_macos_plugin_files() };

for (int i = 0; i < macos_plugins.size(); ++i) {

String src_path{ ProjectSettings::get_singleton()->globalize_path(macos_plugins[i]) };

String path_in_app{ p_app_path_name + "/Contents/PlugIns/" + src_path.get_file() };

if (error != OK) {

break;

}

String pack_path = tmp_app_path_name + "/Contents/Resources/" + pkg_name + ".pck";

Vector<SharedObject> shared_objects;

bool lib_validation = p_preset->get("codesign/entitlements/disable_library_validation");

if (!shared_objects.is_empty() && sign_enabled && ad_hoc && !lib_validation) {

add_message(EXPORT_MESSAGE_ERROR, TTR("Code Signing"), TTR("'rcodesign' doesn't support signing applications with embedded dynamic libraries."));

}

String ent_path = p_preset->get("codesign/entitlements/custom_file");

if (sign_enabled && (ent_path.is_empty())) {

ent_path = EditorPaths::get_singleton()->get_cache_dir().path_join(pkg_name + ".entitlements");

err = ERR_CANT_CREATE;

}

ent_f = FileAccess::open(hlp_ent_path, FileAccess::WRITE);

if (ent_f.is_valid()) {

ent_f->store_line("<?xml version=\"1.0\" encoding=\"UTF-8\"?>");

String hlp_path = helpers[i];

err = da->copy(hlp_path, tmp_app_path_name + "/Contents/Helpers/" + hlp_path.get_file());

if (err == OK && sign_enabled) {

}

FileAccess::set_unix_permissions(tmp_app_path_name + "/Contents/Helpers/" + hlp_path.get_file(), 0755);

}

String src_path = ProjectSettings::get_singleton()->globalize_path(shared_objects[i].path);

if (shared_objects[i].target.is_empty()) {

String path_in_app = tmp_app_path_name + "/Contents/Frameworks/" + src_path.get_file();

} else {

String path_in_app = tmp_app_path_name.path_join(shared_objects[i].target);

tmp_app_dir->make_dir_recursive(path_in_app);

}

if (err != OK) {

break;

Vector<Ref<EditorExportPlugin>> export_plugins{ EditorExport::get_singleton()->get_export_plugins() };

for (int i = 0; i < export_plugins.size(); ++i) {

if (err != OK) {

break;

}

if (ep.step(TTR("Code signing bundle"), 2)) {

return ERR_SKIP;

}

}

String noto_path = p_path;

if (ep.step(TTR("Code signing DMG"), 3)) {

return ERR_SKIP;

}

}

} else if (export_format == "pkg") {

// Create a Installer.

void _make_icon(const Ref<EditorExportPreset> &p_preset, const Ref<Image> &p_icon, Vector<uint8_t> &p_data);

Error _notarize(const Ref<EditorExportPreset> &p_preset, const String &p_path);

Error _copy_and_sign_files(Ref<DirAccess> &dir_access, const String &p_src_path, const String &p_in_app_path,

bool p_should_error_on_non_code_sign);

Error _export_macos_plugins_for(Ref<EditorExportPlugin> p_editor_export_plugin, const String &p_app_path_name,

Ref<DirAccess> &dir_access, bool p_sign_enabled, const Ref<EditorExportPreset> &p_preset,

Error _create_dmg(const String &p_dmg_path, const String &p_pkg_name, const String &p_app_path_name);

Error _create_pkg(const Ref<EditorExportPreset> &p_preset, const String &p_pkg_path, const String &p_app_path_name);

Error _export_debug_script(const Ref<EditorExportPreset> &p_preset, const String &p_app_name, const String &p_pkg_name, const String &p_path);

return (magic == 0xcefaedfe || magic == 0xfeedface || magic == 0xcffaedfe || magic == 0xfeedfacf);

}

bool MachO::open_file(const String &p_path) {

fa = FileAccess::open(p_path, FileAccess::READ_WRITE);

ERR_FAIL_COND_V_MSG(fa.is_null(), false, vformat("MachO: Can't open file: \"%s\".", p_path));

public:

static bool is_macho(const String &p_path);

bool open_file(const String &p_path);

void window_resize(DisplayServer::WindowID p_window_id, int p_width, int p_height);

void release_current();

void swap_buffers();

void window_make_current(DisplayServer::WindowID p_window_id);

}

[NSOpenGLContext clearCurrentContext];

}

void GLManagerLegacy_MacOS::window_make_current(DisplayServer::WindowID p_window_id) {

current_window = p_window_id;

}

void GLManagerLegacy_MacOS::swap_buffers() {

GLWindow &win = windows[current_window];

[win.context flushBuffer];

}

DisplayServerMacOS::WindowData &wd = ds->get_window(window_id);

Vector<String> files;

NSPasteboard *pboard = [sender draggingPasteboard];

err = Main::setup(argv[0], argc - first_arg, &argv[first_arg]);

}

}

@autoreleasepool {

}

}

@autoreleasepool {

if ([new_allowed_types count] > 0) {

NSMutableArray *type_filters = [new_allowed_types objectAtIndex:0];

if (type_filters && [type_filters count] == 1 && [[type_filters objectAtIndex:0] isEqualToString:@"*"]) {

[p_panel setAllowsOtherFileTypes:true];

} else {

[p_panel setAllowsOtherFileTypes:false];

[p_panel setAllowedFileTypes:type_filters];

}

} else {

[p_panel setAllowsOtherFileTypes:true];

}

}

if (allowed_types && index < [allowed_types count]) {

NSMutableArray *type_filters = [allowed_types objectAtIndex:index];

if (type_filters && [type_filters count] == 1 && [[type_filters objectAtIndex:0] isEqualToString:@"*"]) {

[dialog setAllowsOtherFileTypes:true];

} else {

[dialog setAllowsOtherFileTypes:false];

}

cur_index = index;

} else {

[dialog setAllowsOtherFileTypes:true];

cur_index = -1;

}

ds->window_resize(window_id, wd.size.width, wd.size.height);

wd.rect_changed_callback.call(Rect2i(ds->window_get_position(window_id), ds->window_get_size(window_id)));

}

}

DisplayServerMacOS::WindowData &wd = ds->get_window(window_id);

ds->release_pressed_events();

wd.rect_changed_callback.call(Rect2i(ds->window_get_position(window_id), ds->window_get_size(window_id)));

}

}

#include "core/templates/hash_map.h"

#include "core/templates/rid_owner.h"

#import <AppKit/AppKit.h>

#import <ApplicationServices/ApplicationServices.h>

RID NativeMenuMacOS::create_menu() {

MenuData *md = memnew(MenuData);

md->menu = [[NSMenu alloc] initWithTitle:@""];

RID rid = menus.make_rid(md);

menu_lookup[md->menu] = rid;

return rid;

virtual void alert(const String &p_alert, const String &p_title = "ALERT!") override;

virtual MainLoop *get_main_loop() const override;

return p_path;

}

String path = get_framework_executable(p_path);

if (!FileAccess::exists(path)) {

p_library_handle = dlopen(path.utf8().get_data(), RTLD_NOW);

ERR_FAIL_NULL_V_MSG(p_library_handle, ERR_CANT_OPEN, vformat("Can't open dynamic library: %s. Error: %s.", p_path, dlerror()));

}

return OK;