Add linux_arm64 build

.gitignore

@@ -15,3 +15,6 @@ tests/puppeteer/package.json
 tests/puppeteer/package-lock.json
 scripts/sdkjs_common/jsdoc/node_modules
 scripts/sdkjs_common/jsdoc/package-lock.json
+tools/linux/python3/
+tools/linux/python3.tar.gz
+tools/linux/sysroot/sysroot_ubuntu_1604

Dockerfile

@@ -1,45 +1,20 @@
-FROM ubuntu:24.04
+FROM ubuntu:20.04
 
 ENV TZ=Etc/UTC
-ENV DEBIAN_FRONTEND=noninteractive
-
 RUN ln -snf /usr/share/zoneinfo/$TZ /etc/localtime && echo $TZ > /etc/timezone
 
-RUN echo 'keyboard-configuration keyboard-configuration/layoutcode string us' | debconf-set-selections && \
-    echo 'keyboard-configuration keyboard-configuration/modelcode string pc105' | debconf-set-selections
-
 RUN apt-get -y update && \
-    apt-get -y install sudo \
-                       git \
-                       git-lfs \
-                       curl \
-                       wget \
-                       p7zip-full
+    apt-get -y install tar \
+                       sudo
 
 ADD . /build_tools
 WORKDIR /build_tools
 
-# Install local Python
-RUN cd tools/linux && \
-    ./python.sh
+RUN mkdir -p /opt/python3 && \
+    tar -xzf /build_tools/tools/linux/python3.tar.gz -C /opt/python3 --strip-components=1
 
-# Fetch Qt binaries
-RUN cd tools/linux && \
-    ./python3/bin/python3 ./qt_binary_fetch.py amd64
+ENV PATH="/opt/python3/bin:${PATH}"
 
-# Install system dependencies
-RUN cd tools/linux && \
-    ./python3/bin/python3 ./deps.py
+RUN ln -s /opt/python3/bin/python3.10 /usr/bin/python
 
-# Install CMake
-RUN cd tools/linux && \
-    ./cmake.sh
-
-# Fetch sysroot
-RUN cd tools/linux/sysroot && \
-    ../python3/bin/python3 ./fetch.py amd64
-
-ARG BRANCH=master
-ENV BRANCH=${BRANCH}
-
-CMD ["sh", "-c", "./tools/linux/python3/bin/python3 ./configure.py --sysroot \"1\" --clean \"0\" --update-light \"1\" --branch \"${BRANCH}\" --update \"1\" --module \"desktop server builder\" --qt-dir \"$(pwd)/tools/linux/qt_build/Qt-5.9.9\" && ./tools/linux/python3/bin/python3 ./make.py"]
+CMD ["sh", "-c", "cd tools/linux && python3 ./automate.py"]

README.md

@@ -1,218 +1,221 @@
-<h1>ONLYOFFICE Build Tools</h1>
+# build_tools
 
-Welcome to the ```build_tools``` repository! This powerful toolkit simplifies the process of compiling [ONLYOFFICE](https://github.com/ONLYOFFICE) products from source on Linux.
+## Overview
 
-It automatically fetches all the required dependencies and source code to build the latest versions of:
+**build_tools** allow you to automatically get and install all the components
+necessary for the compilation process, all the dependencies required for the
+**ONLYOFFICE Document Server**, **Document Builder** and **Desktop Editors**
+ correct work, as well as to get the latest version of
+**ONLYOFFICE products** source code and build all their components.
 
-* [Docs (Document Server)](https://www.onlyoffice.com/docs?utm_source=github&utm_medium=cpc&utm_campaign=GitHubBuildTools)  
-* [Desktop Editors](https://www.onlyoffice.com/desktop?utm_source=github&utm_medium=cpc&utm_campaign=GitHubBuildTools)  
-* [Document Builder](https://www.onlyoffice.com/document-builder?utm_source=github&utm_medium=cpc&utm_campaign=GitHubBuildTools)
+**Important!**  We can only guarantee the correct work of the products built
+from the `master` branch.
 
-**A quick note:** For the most stable and reliable builds, we strongly recommend compiling from the ```master``` branch of this repository.
+## How to use - Linux
 
-## **How do I use it on Linux? 🐧**
+**Note**: The solution has been tested on **Ubuntu 16.04**.
 
->This guide has been tested and verified on **Ubuntu 16.04**.
+### Installing dependencies
 
-### **Step 1: Install dependencies**
-
-First, let's make sure you have **Python** installed, as it's needed to run the build scripts.
+You might need to install **Python**, depending on your version of Ubuntu:
 
 ```bash
 sudo apt-get install -y python
 ```
 
-### **Step 2: Build the source code**
+### Building ONLYOFFICE products source code
 
-Now, you're ready to build the ONLYOFFICE products.
+1. Clone the build_tools repository:
 
-1. **Clone the build_tools repository:**  
-
-    This command downloads the build tools to your machine using Git:
-   ```bash
-   git clone https://github.com/ONLYOFFICE/build_tools.git
-   ```
-
-2. **Navigate to the scripts directory:**  
-   ```bash
-   cd build_tools/tools/linux
-   ```
-3. **Run the automation script:**  
-   
-   This is where the magic happens! Running the script without any options will build all three products: Document Server, Document Builder, and Desktop Editors.  
-
-   ```bash
-   ./automate.py
-   ```
-You can also build ONLYOFFICE products separately. Just run the script with the parameter corresponding to the necessary product. For example, to build *Desktop Editors* and *Document Server*
-  ```bash
-   ./automate.py desktop server
-   ```
-
-**Perfect!** Once the script finishes, you will find the compiled products in the ```./out``` directory.
-
-## **Advanced options & different workflows 🚀**
-
-### **How to use Docker**
-
-If you prefer using Docker, you can build all products inside a container. This is a great way to keep your local system clean.
-
-1. **Create an output directory:**  
-
-   ```bash
-   mkdir out
+    ```bash
+    git clone https://github.com/ONLYOFFICE/build_tools.git
     ```
 
-2. **Build the Docker image:**  
+2. Go to the `build_tools/tools/linux` directory:
 
-   ```bash
-   docker build --tag onlyoffice-document-editors-builder .
-   ```
-
-3. **Run the container to start the build:** 
-   
-   This command mounts your local out directory into the container, so the final build files will appear on your machine. 
-
-   ```bash 
-   docker run -v $PWD/out:/build_tools/out onlyoffice-document-editors-builder
+    ```bash
+    cd build_tools/tools/linux
     ```
 
-You've done it! The results will be in the ```./out``` directory you created.
+3. Run the `automate.py` script:
 
-## **How to build and run the products separately ▶️**
+    ```bash
+    ./automate.py
+    ```
 
-Don't need everything? You can save time by building only the products you need. Just add the product name as an argument to the script.
+If you run the script without any parameters this allows to build **ONLYOFFICE
+Document Server**, **Document Builder** and **Desktop Editors**.
 
-### Need just the [Document Builder](https://github.com/ONLYOFFICE/DocumentBuilder)❓
-* How to build
+The result will be available in the `./out` directory.
 
-  ```bash
-  ./automate.py builder
-  ```
-* How to run
-  ```bash
-  cd ../../out/linux_64/onlyoffice/documentbuilder
-  ./docbuilder
-  ```
+To build **ONLYOFFICE** products separately run the script with the parameter
+corresponding to the necessary product.
 
-### Need just the [Desktop Editors](https://github.com/ONLYOFFICE/DesktopEditors)❓
+It’s also possible to build several products at once as shown in the example
+below.
 
-* How to build
-  ```bash
-  ./automate.py desktop
-  ```
-* How to run
-  ```bash
-  cd ../../out/linux_64/onlyoffice/desktopeditors
-  LD_LIBRARY_PATH=./ ./DesktopEditors
-  ```
-
-### Need just the [Docs (Document Server)](https://github.com/ONLYOFFICE/DocumentServer)❓
-* How to build
-  ```bash
-  ./automate.py server
-  ```
-* How to run
-
-  Running the Document Server is a multi-step process because it relies on a few background services. Let's break it down step by step. 
-
-#### **Step 1. Set up dependencies**
-
-The Document Server needs a few things to run correctly:
-
-* **NGINX**: Acts as a web server to handle requests.  
-* **PostgreSQL**: Used as the database to store information.  
-* **RabbitMQ**: A message broker that helps different parts of the server communicate.
-
-Here are the commands to install and configure them.
-
-#### **Install and configure NGINX**
-
-1. Install NGINX  
-```bash
-sudo apt-get install nginx
-```
-2. Disable the default NGINX site
-```bash
-sudo rm -f /etc/nginx/sites-enabled/default
-```
-3. Set up the new website. To do that create the ```/etc/nginx/sites-available/onlyoffice-documentserver``` file with the following contents:
+**Example**: Building **Desktop Editors** and **Document Server**
 
 ```bash
-map $http_host $this_host {
-  "" $host;
-  default $http_host;
-}
-map $http_x_forwarded_proto $the_scheme {
-  default $http_x_forwarded_proto;
-  "" $scheme;
-}
-map $http_x_forwarded_host $the_host {
-  default $http_x_forwarded_host;
-  "" $this_host;
-}
-map $http_upgrade $proxy_connection {
-  default upgrade;
-  "" close;
-}
-proxy_set_header Host $http_host;
-proxy_set_header Upgrade $http_upgrade;
-proxy_set_header Connection $proxy_connection;
-proxy_set_header X-Forwarded-Host $the_host;
-proxy_set_header X-Forwarded-Proto $the_scheme;
-server {
-  listen 0.0.0.0:80;
-  listen [::]:80 default_server;
-  server_tokens off;
-  rewrite ^\/OfficeWeb(\/apps\/.*)$ /web-apps$1 redirect;
-  location / {
-    proxy_pass http://localhost:8000;
-    proxy_http_version 1.1;
-  }
-}
+./automate.py desktop server
 ```
 
-4. Enable the new site by creating a symbolic link  
-```bash
-sudo ln -s /etc/nginx/sites-available/onlyoffice-documentserver /etc/nginx/sites-enabled/onlyoffice-documentserver
-```
-5. Restart NGINX to apply the changes  
-```bash
-sudo nginx -s reload
-```
-#### **Install and configure PostgreSQL**
+### Using Docker
+
+You can also build all **ONLYOFFICE products** at once using Docker.
+Build the `onlyoffice-document-editors-builder` Docker image using the
+provided `Dockerfile` and run the corresponding Docker container.
+
+```bash
+mkdir out
+docker build --tag onlyoffice-document-editors-builder .
+docker run -v $PWD/out:/build_tools/out onlyoffice-document-editors-builder
+```
+
+The result will be available in the `./out` directory.
+
+### Building and running ONLYOFFICE products separately
+
+#### Document Builder
+
+##### Building Document Builder
+
+```bash
+./automate.py builder
+```
+
+##### Running Document Builder
+
+```bash
+cd ../../out/linux_64/onlyoffice/documentbuilder
+./docbuilder
+```
+
+#### Desktop Editors
+
+##### Building Desktop Editors
+
+```bash
+./automate.py desktop
+```
+
+##### Running Desktop Editors
+
+```bash
+cd ../../out/linux_64/onlyoffice/desktopeditors
+LD_LIBRARY_PATH=./ ./DesktopEditors
+```
+
+#### Document Server
+
+##### Building Document Server
+
+```bash
+./automate.py server
+```
+
+##### Installing and configuring Document Server dependencies
+
+**Document Server** uses **NGINX** as a web server and **PostgreSQL** as a database.
+**RabbitMQ** is also required for **Document Server** to work correctly.
+
+###### Installing and configuring NGINX
+
+1. Install NGINX:
+
+    ```bash
+    sudo apt-get install nginx
+    ```
+
+2. Disable the default website:
+
+    ```bash
+    sudo rm -f /etc/nginx/sites-enabled/default
+    ```
+
+3. Set up the new website. To do that create the `/etc/nginx/sites-available/onlyoffice-documentserver`
+   file with the following contents:
+
+    ```bash
+    map $http_host $this_host {
+      "" $host;
+      default $http_host;
+    }
+    map $http_x_forwarded_proto $the_scheme {
+      default $http_x_forwarded_proto;
+      "" $scheme;
+    }
+    map $http_x_forwarded_host $the_host {
+      default $http_x_forwarded_host;
+      "" $this_host;
+    }
+    map $http_upgrade $proxy_connection {
+      default upgrade;
+      "" close;
+    }
+    proxy_set_header Host $http_host;
+    proxy_set_header Upgrade $http_upgrade;
+    proxy_set_header Connection $proxy_connection;
+    proxy_set_header X-Forwarded-Host $the_host;
+    proxy_set_header X-Forwarded-Proto $the_scheme;
+    server {
+      listen 0.0.0.0:80;
+      listen [::]:80 default_server;
+      server_tokens off;
+      rewrite ^\/OfficeWeb(\/apps\/.*)$ /web-apps$1 redirect;
+      location / {
+        proxy_pass http://localhost:8000;
+        proxy_http_version 1.1;
+      }
+    }
+    ```
+
+4. Add the symlink to the newly created website to the
+   `/etc/nginx/sites-available` directory:
+
+    ```bash
+    sudo ln -s /etc/nginx/sites-available/onlyoffice-documentserver /etc/nginx/sites-enabled/onlyoffice-documentserver
+    ```
+
+5. Restart NGINX to apply the changes:
+
+    ```bash
+    sudo nginx -s reload
+    ```
+
+###### Installing and configuring PostgreSQL
+
+1. Install PostgreSQL:
 
-1. Install PostgreSQL  
     ```bash
     sudo apt-get install postgresql
     ```
 
-2. Create a database and user. 
+2. Create the PostgreSQL database and user:
+
+    **Note**: The created database must have **onlyoffice** both for user and password.
 
-    **Note**: The user and password must both be **'onlyoffice'.**  
     ```bash
     sudo -i -u postgres psql -c "CREATE USER onlyoffice WITH PASSWORD 'onlyoffice';"
     sudo -i -u postgres psql -c "CREATE DATABASE onlyoffice OWNER onlyoffice;"
     ```
 
-3. Configure the database:  
+3. Configure the database:
+
     ```bash
     psql -hlocalhost -Uonlyoffice -d onlyoffice -f ../../out/linux_64/onlyoffice/documentserver/server/schema/postgresql/createdb.sql
     ```
 
-Upon that, you will be asked to provide a password for the onlyoffice PostgreSQL user. Please enter the **onlyoffice** password.
+**Note**: Upon that, you will be asked to provide a password for the **onlyoffice**
+PostgreSQL user. Please enter the **onlyoffice** password.
+
+###### Installing RabbitMQ
 
-#### **Install RabbitMQ**
 ```bash
 sudo apt-get install rabbitmq-server
 ```
 
-Now that you have all the dependencies installed, it's time to generate server files. 
-#### **Step 2. Generate server files**
-
-Before running the server, you need to generate font and theme data.
-
-##### **Generate fonts data**
+###### Generate fonts data
 
 ```bash
 cd out/linux_64/onlyoffice/documentserver/
@@ -227,7 +230,8 @@ LD_LIBRARY_PATH=${PWD}/server/FileConverter/bin server/tools/allfontsgen \
   --use-system="true"
 ```
 
-##### **Generate presentation themes**
+###### Generate presentation themes
+
 ```bash
 cd out/linux_64/onlyoffice/documentserver/
 LD_LIBRARY_PATH=${PWD}/server/FileConverter/bin server/tools/allthemesgen \
@@ -236,39 +240,27 @@ LD_LIBRARY_PATH=${PWD}/server/FileConverter/bin server/tools/allthemesgen \
   --output="${PWD}/sdkjs/common/Images"
 ```
 
-#### **Step 3. Run the Document Server services**
+##### Running Document Server
 
-All Document Server components run as foreground processes. Thus you need separate terminal consoles to run them or specific tools which will allow to run foreground processes in background mode.
+**Note**: All **Document Server** components run as foreground processes. Thus
+you need separate terminal consoles to run them or specific tools which will
+allow to run foreground processes in background mode.
 
-* **Start the FileConverter service:**  
-  ```bash
-  cd out/linux_64/onlyoffice/documentserver/server/FileConverter
-  LD_LIBRARY_PATH=$PWD/bin \
-  NODE_ENV=development-linux \
-  NODE_CONFIG_DIR=$PWD/../Common/config \
-  ./converter
-  ```
+1. Start the **FileConverter** service:
 
-* **Start the DocService service:**  
-  ```bash
-  cd out/linux_64/onlyoffice/documentserver/server/DocService
-  NODE_ENV=development-linux \
-  NODE_CONFIG_DIR=$PWD/../Common/config \
-  ./docservice
-  ```
+    ```bash
+    cd out/linux_64/onlyoffice/documentserver/server/FileConverter
+    LD_LIBRARY_PATH=$PWD/bin \
+    NODE_ENV=development-linux \
+    NODE_CONFIG_DIR=$PWD/../Common/config \
+    ./converter
+    ```
 
-## And it's a wrap!  🎉
-Congratulations! You have successfully used the ```build_tools``` to compile your desired ONLYOFFICE products from the latest source code. 
+2. Start the **DocService** service:
 
-Everything is now set up. You can go ahead and run your brand-new, self-compiled ONLYOFFICE applications. 
-
-## Need help or have an idea? 💡
-
-* **🐞 Found a bug?** Please report it by creating an [issue](https://github.com/ONLYOFFICE/build_tools/issues).
-* **❓ Have a question?** Ask our community and developers on the [ONLYOFFICE Forum](https://community.onlyoffice.com).
-* **💡 Want to suggest a feature?** Share your ideas on our [feedback platform](https://feedback.onlyoffice.com/forums/966080-your-voice-matters).
-* **🧑‍💻 Need help for developers?** Check our [API documentation](https://api.onlyoffice.com/?utm_source=github&utm_medium=cpc&utm_campaign=GitHubBuildTools).
-
----
-
-<p align="center"> Made with ❤️ by the ONLYOFFICE Team </p>
+    ```bash
+    cd out/linux_64/onlyoffice/documentserver/server/DocService
+    NODE_ENV=development-linux \
+    NODE_CONFIG_DIR=$PWD/../Common/config \
+    ./docservice
+    ```

configure.py

@@ -42,8 +42,7 @@ parser.add_option("--vs-version", action="store", type="string", dest="vs-versio
 parser.add_option("--vs-path", action="store", type="string", dest="vs-path", default="", help="path to vcvarsall")
 parser.add_option("--siteUrl", action="store", type="string", dest="siteUrl", default="127.0.0.1", help="site url")
 parser.add_option("--multiprocess", action="store", type="string", dest="multiprocess", default="1", help="provides ability to specify single process for make")
-parser.add_option("--sysroot", action="store", type="string", dest="sysroot", default="0", help="provides ability to use sysroot (ubuntu 16.04) to build c++ code. If value is \"1\", then the sysroot from tools/linux/sysroot will be used, and if it is not there, it will download it and unpack it. You can also set value as the path to the your own sysroot (rarely used). Only for linux")
-parser.add_option("--qemu-win-arm64-dir", action="store", type="string", dest="qemu-win-arm64-dir", default="", help="dir to qemu virtual machine for win_arm64 cross build. It should contains start.bat. More info in tools/win/qemu.")
+parser.add_option("--custom-sysroot", action="store", type="string", dest="custom-sysroot", default="0", help="provides ability to use custom sysroot (ubuntu 16.04) to build c++ core. If value is \"1\", then the sysroot from tools/linux/sysroot will be used, and if it is not there, it will download it and unpack it. You can also set value as the path to the your own sysroot (rarely used). Only for linux")
 
 (options, args) = parser.parse_args(arguments)
 configOptions = vars(options)

develop/README.md

@@ -1,11 +1,15 @@
 # Docker
 
-This directory contains instructions for developers,
-who want to change something in sdkjs, web-apps, or the server module,
-but don't want to compile the complicated core product to make those changes.
+This directory containing instruction for developers,
+who want to change something in sdkjs or web-apps or server module,
+but don't want to compile pretty compilcated core product to make those changes.
 
 ## System requirements
 
+**Note**: ARM-based architectures are currently **NOT** supported;
+attempting to run the images on ARM devices may result in startup failures 
+or other runtime issues.
+
 ### Windows
 
 You need the latest
@@ -25,22 +29,22 @@ You need the latest
 [Docker](https://docs.docker.com/engine/install/)
 version installed.
 
-## Create Development Docker Image
+## Create develop Docker Images
 
-To create an image with the ability to include external non-minified sdkjs code,
+To create a image with the ability to include external non-minified sdkjs code,
 use the following commands:
 
-### Clone development environment to the working directory
+### Clone development environment to work dir
 
 ```bash
 git clone https://github.com/ONLYOFFICE/build_tools.git
 ```
 
-### Build Docker Image
+### Modify Docker Images
 
-**Note**: Do not prefix the docker command with sudo.
-[These instructions](https://docs.docker.com/engine/install/linux-postinstall/#manage-docker-as-a-non-root-user)
-show how to use docker without sudo.
+**Note**: Do not prefix docker command with sudo.
+[This](https://docs.docker.com/engine/install/linux-postinstall/#manage-docker-as-a-non-root-user)
+instruction show how to use docker without sudo.
 
 ```bash
 cd build_tools/develop
@@ -50,11 +54,11 @@ docker build --no-cache -t documentserver-develop .
 
 **Note**: The dot at the end is required.
 
-**Note**: Sometimes the build may fail due to network errors. Just restart it.
+**Note**: Sometimes script may fail due to network errors. Just restart it.
 
 ## Clone development modules
 
-Clone development modules to the working directory.
+Clone development modules to the work dir
 
 * `sdkjs` repo is located [here](https://github.com/ONLYOFFICE/sdkjs/)
 * `web-apps` repo is located [here](https://github.com/ONLYOFFICE/web-apps/)
@@ -72,49 +76,43 @@ To mount external folders to the container,
 you need to pass the "-v" parameter
 along with the relative paths to the required folders.  
 The folders `sdkjs` and `web-apps` are required for proper development workflow.
-The folder `server` is optional.
+The folders `server` is optional
 
-**Note**: Run the command with the current working directory
+**Note**: Run command with the current working directory
 containing `sdkjs`, `web-apps`...
 
 **Note**: ONLYOFFICE server uses port 80.
-Look for another application using port 80 and stop it.
+Look for another application using port 80 and stop it
 
-**Note**: Starting the server with `sdkjs` and `web-apps` takes 15 minutes,
-or 20 minutes with `server`.
+**Note**: Server start with `sdkjs` and `web-apps` takes 15 minutes
+and takes 20 minutes with `server`
 
 ### docker run on Windows (PowerShell)
 
 **Note**: Run PowerShell as administrator to fix EACCES error when installing
-node_modules.
+node_modules
 
-Run with `sdkjs` and `web-apps`
+run with `sdkjs` and `web-apps`
 
-```powershell
+```bash
 docker run -i -t -p 80:80 --restart=always -e ALLOW_PRIVATE_IP_ADDRESS=true -v $pwd/sdkjs:/var/www/onlyoffice/documentserver/sdkjs -v $pwd/web-apps:/var/www/onlyoffice/documentserver/web-apps documentserver-develop
 ```
 
-Or run with `sdkjs`, `web-apps`, and `server`
-
-```powershell
-docker run -i -t -p 80:80 --restart=always -e ALLOW_PRIVATE_IP_ADDRESS=true -v $pwd/sdkjs:/var/www/onlyoffice/documentserver/sdkjs -v $pwd/web-apps:/var/www/onlyoffice/documentserver/web-apps -v $pwd/server:/var/www/onlyoffice/documentserver/server documentserver-develop
-```
-
-**Note**: If using Git Bash instead of PowerShell, you may need to quote the paths:
+or run with `sdkjs`, `web-apps` and `server`
 
 ```bash
-docker run -i -t -p 80:80 --restart=always -e ALLOW_PRIVATE_IP_ADDRESS=true -v "$(pwd)/sdkjs":/var/www/onlyoffice/documentserver/sdkjs -v "$(pwd)/web-apps":/var/www/onlyoffice/documentserver/web-apps documentserver-develop
+docker run -i -t -p 80:80 --restart=always -e ALLOW_PRIVATE_IP_ADDRESS=true -v $pwd/sdkjs:/var/www/onlyoffice/documentserver/sdkjs -v $pwd/web-apps:/var/www/onlyoffice/documentserver/web-apps -v $pwd/server:/var/www/onlyoffice/documentserver/server documentserver-develop
 ```
 
 ### docker run on Linux or macOS
 
-Run with `sdkjs` and `web-apps`
+run with `sdkjs` and `web-apps`
 
 ```bash
 docker run -i -t -p 80:80 --restart=always -e ALLOW_PRIVATE_IP_ADDRESS=true -v $(pwd)/sdkjs:/var/www/onlyoffice/documentserver/sdkjs -v $(pwd)/web-apps:/var/www/onlyoffice/documentserver/web-apps documentserver-develop
 ```
 
-Or run with `sdkjs`, `web-apps`, and `server`
+or run with `sdkjs`, `web-apps` and `server`
 
 ```bash
 docker run -i -t -p 80:80 --restart=always -e ALLOW_PRIVATE_IP_ADDRESS=true -v $(pwd)/sdkjs:/var/www/onlyoffice/documentserver/sdkjs -v $(pwd)/web-apps:/var/www/onlyoffice/documentserver/web-apps -v $(pwd)/server:/var/www/onlyoffice/documentserver/server documentserver-develop
@@ -122,99 +120,93 @@ docker run -i -t -p 80:80 --restart=always -e ALLOW_PRIVATE_IP_ADDRESS=true -v $
 
 ## Open editor
 
-After the server starts successfully, you will see Docker log messages like this.
+After the server starts successfully, you will see Docker log messages like this
 
-```text
+```bash
 [Date] [WARN] [localhost] [docId] [userId] nodeJS
 ```
 
 To try the document editor, open a browser tab and type
 [http://localhost/example](http://localhost/example) into the URL bar.
 
-**Note**: Disable **ad blockers** for the localhost page.
-They may block some scripts (like Analytics.js).
+**Note**: Disable **ad blockers** for localhost page.
+It may block some scripts (like Analytics.js)
 
 ## Modify sources
 
-### To change something in `sdkjs`, do the following steps
+### To change something in `sdkjs` do the following steps
 
-1) Edit the source file. Let's insert an image URL into each open document.
-The following command inserts (in case of problems, you can replace the URL)
+1)Edit source file. Let's insert an image url into each open document.  
+Following command inserts (in case of problems, you can replace URL)
 `this.AddImageUrl(['http://localhost/example/images/logo.png']);`  
 after event  
 `this.sendEvent('asc_onDocumentContentReady');`  
 in file  
 `sdkjs/common/apiBase.js`
 
-**Windows (PowerShell):**
-```powershell
-(Get-Content sdkjs/common/apiBase.js) -replace "this\.sendEvent\('asc_onDocumentContentReady'\);", "this.sendEvent('asc_onDocumentContentReady');this.AddImageUrl(['http://localhost/example/images/logo.png']);" | Set-Content sdkjs/common/apiBase.js
+### change sdkjs on Windows (PowerShell)
+
+```bash
+(Get-Content sdkjs/common/apiBase.js) -replace "this\.sendEvent\('asc_onDocumentContentReady'\);", "this.sendEvent('asc_onDocumentContentReady');this.AddImageUrl(['http://localhost/example/images/logo.png']);"  | Set-Content sdkjs/common/apiBase.js
 ```
 
-**Linux:**
+### change sdkjs on Linux or macOS
+
 ```bash
 sed -i "s,this.sendEvent('asc_onDocumentContentReady');,this.sendEvent('asc_onDocumentContentReady');this.AddImageUrl(['http://localhost/example/images/logo.png']);," sdkjs/common/apiBase.js
 ```
 
-**macOS:**
-```bash
-sed -i '' "s,this.sendEvent('asc_onDocumentContentReady');,this.sendEvent('asc_onDocumentContentReady');this.AddImageUrl(['http://localhost/example/images/logo.png']);," sdkjs/common/apiBase.js
-```
+2)Delete browser cache or hard reload the page `Ctrl + Shift + R`
 
-2) Clear the browser cache or hard reload the page (`Ctrl + Shift + R` or `Cmd + Shift + R` on macOS)
+3)Open new file in browser
 
-3) Open a new file in the browser
+### To change something in `server` do the following steps
 
-### To change something in `server`, do the following steps
-
-1) Edit the source file. Let's send a `"Hello World!"`
-chat message every time a document is opened.
-The following command inserts  
+1)Edit source file. Let's send `"Hello World!"`
+chart message every time a document is opened.  
+Following command inserts  
 `yield* onMessage(ctx, conn, {"message": "Hello World!"});`  
 in function  
 `sendAuthInfo`  
 in file  
 `server/DocService/sources/DocsCoServer.js`
 
-**Windows (PowerShell):**
-```powershell
+### change server on Windows (PowerShell)
+
+```bash
 (Get-Content server/DocService/sources/DocsCoServer.js) -replace 'opt_hasForgotten, opt_openedAt\) \{', 'opt_hasForgotten, opt_openedAt) {yield* onMessage(ctx, conn, {"message": "Hello World!"});' | Set-Content server/DocService/sources/DocsCoServer.js
 ```
 
-**Linux:**
+### change server on Linux or macOS
+
 ```bash
 sed -i 's#opt_hasForgotten, opt_openedAt) {#opt_hasForgotten, opt_openedAt) {yield* onMessage(ctx, conn, {"message": "Hello World!"});#' server/DocService/sources/DocsCoServer.js
 ```
 
-**macOS:**
-```bash
-sed -i '' 's#opt_hasForgotten, opt_openedAt) {#opt_hasForgotten, opt_openedAt) {yield* onMessage(ctx, conn, {"message": "Hello World!"});#' server/DocService/sources/DocsCoServer.js
-```
+2)Restart document server process
 
-2) Restart the document server process
-
-**Note**: Look for `CONTAINER_ID` in the result of `docker ps`.
+**Note**: Look for ``CONTAINER_ID`` in the result of ``docker ps``.
 
 ```bash
 docker exec -it CONTAINER_ID supervisorctl restart all
 ```
 
-3) Open a new file in the browser
+3)Open new file in browser
 
-## Start server with additional functionality (addons)
+## Start server with additional functionality(addons)
 
-To get additional functionality and branding, you need to connect a branding folder,
-additional addon folders, and pass command line arguments.
+To get additional functionality and branding you need to connect a branding folder,
+additional addon folders and pass command line arguments
 
-For example, run with `onlyoffice` branding and
-addons: `sdkjs-forms`, `sdkjs-ooxml`, `web-apps-mobile`.
+For example run with `onlyoffice` branding and
+addons:`sdkjs-forms`, `sdkjs-ooxml`, `web-apps-mobile`
 
 ### docker run on Windows (PowerShell) with branding
 
 **Note**: Run PowerShell as administrator to fix EACCES error when installing
-node_modules.
+node_modules
 
-```powershell
+```bash
 docker run -i -t -p 80:80 --restart=always -e ALLOW_PRIVATE_IP_ADDRESS=true `
     -v $pwd/sdkjs:/var/www/onlyoffice/documentserver/sdkjs -v $pwd/web-apps:/var/www/onlyoffice/documentserver/web-apps `
     -v $pwd/onlyoffice:/var/www/onlyoffice/documentserver/onlyoffice -v $pwd/sdkjs-ooxml:/var/www/onlyoffice/documentserver/sdkjs-ooxml -v $pwd/sdkjs-forms:/var/www/onlyoffice/documentserver/sdkjs-forms -v $pwd/web-apps-mobile:/var/www/onlyoffice/documentserver/web-apps-mobile `

linux-start.sh

@@ -1,66 +0,0 @@
-sudo apt-get install git curl wget p7zip-full
-
-sudo apt-get install git-lfs
-# for old system (ubuntu 16)
-#curl -s https://packagecloud.io/install/repositories/github/git-lfs/script.deb.sh | sudo bash
-#sudo apt-get install git-lfs
-
-# save login
-git config --global credential.helper store
-
-# clone build_tools
-git clone https://git.onlyoffice.com/ONLYOFFICE/build_tools.git
-
-# deps =========================================
-
-cd ./build_tools/tools/linux
-
-# python 3.10
-./python.sh
-
-# qt
-#./python3/bin/python3 ./qt_binary_fetch.py amd64
-#./python3/bin/python3 ./qt_binary_fetch.py arm64
-./python3/bin/python3 ./qt_binary_fetch.py all
-
-# deps
-./python3/bin/python3 ./deps.py
-
-# cmake 3.30
-sudo ./cmake.sh
-
-cd ../../
-
-# ==============================================
-
-# sysroots (IF NEEDED) =========================
-
-cd ./build_tools/tools/linux/sysroot
-#./python3/bin/python3 ./fetch.py amd64
-#./python3/bin/python3 ./fetch.py arm64
-./../python3/bin/python3 ./fetch.py all
-cd ../../../
-
-# ==============================================
-
-
-# configure ====================================
-
-./tools/linux/python3/bin/python3 ./configure.py --clean "0" --update-light "1" --update "1" --branch "hotfix/v9.2.1" --module "desktop" --qt-dir "$(pwd)/tools/linux/qt_build/Qt-5.9.9"
-
-# with sysroot: sysroot "1"
-
-# ==============================================
-
-# cross build linux_arm64
-sudo apt install qemu-user qemu-user-static binfmt-support
-sudo update-binfmts --enable qemu-aarch64
-
-# 1) without sysroot
-#sudo apt install gcc-aarch64-linux-gnu g++-aarch64-linux-gnu
-#sudo dpkg --add-architecture arm64
-#sudo apt update
-#... install all dev packages ...
-
-# 2) official supported: with sysroot
-./tools/linux/python3/bin/python3 ./configure.py sysroot "1" #...

make.py

@@ -19,6 +19,8 @@ import make_common
 import develop
 import argparse
 
+base.check_python()
+
 parser = argparse.ArgumentParser(description="options")
 parser.add_argument("--build-only-branding", action="store_true")
 args = parser.parse_args()
@@ -28,7 +30,6 @@ if (args.build_only_branding):
 
 # parse configuration
 config.parse()
-base.check_python()
 
 base_dir = base.get_script_dir(__file__)
 
@@ -91,6 +92,8 @@ if config.check_option("module", "desktop"):
     config.extend_option("config", "updmodule")
     base.set_env("DESKTOP_URL_UPDATES_MAIN_CHANNEL", "https://download.onlyoffice.com/install/desktop/editors/windows/onlyoffice/appcast.json")
     base.set_env("DESKTOP_URL_UPDATES_DEV_CHANNEL", "https://download.onlyoffice.com/install/desktop/editors/windows/onlyoffice/appcastdev.json")
+    base.set_env("DESKTOP_URL_INSTALL_CHANNEL", "https://download.onlyoffice.com/install/desktop/editors/windows/distrib/onlyoffice/<file>")
+    base.set_env("DESKTOP_URL_INSTALL_DEV_CHANNEL", "https://download.onlyoffice.com/install/desktop/editors/windows/onlyoffice/onlineinstallerdev/<file>")
 
 # build
 build_sln.make()

scripts/base.py

@@ -16,7 +16,6 @@ import json
 
 __file__script__path__ = os.path.dirname( os.path.realpath(__file__))
 icu_ver = "74"
-icu_ver_old = "58"  # for win_xp support
 
 # common functions --------------------------------------
 def get_script_dir(file=""):
@@ -37,11 +36,9 @@ def is_os_64bit():
   return platform.machine().endswith('64')
 
 def is_os_arm():
-  if -1 != platform.machine().lower().find('arm'):
-    return True
-  if -1 != platform.machine().lower().find('aarch64'):
-    return True
-  return False
+  if -1 == platform.machine().find('arm'):
+    return False
+  return True
 
 def get_platform():
   return platform.machine().lower()
@@ -256,10 +253,7 @@ def delete_dir(path):
     shutil.rmtree(get_path(path), ignore_errors=True)
   return
 
-def copy_lib(src_folder, dst, name, subdir=""):
-  src = src_folder
-  if subdir != "":
-    src += ("/" + subdir)
+def copy_lib(src, dst, name):
   if (config.check_option("config", "bundle_dylibs")) and is_dir(src + "/" + name + ".framework"):
     copy_dir(src + "/" + name + ".framework", dst + "/" + name + ".framework", symlinks=True)
 
@@ -436,46 +430,11 @@ def cmd_in_dir(directory, prog, args=[], is_no_errors=False):
   return ret
 
 def cmd_in_dir_qemu(platform, directory, prog, args=[], is_no_errors=False):
-  platform_config = {
-    "linux_arm64": {
-      "qemu": "qemu-aarch64",
-      "default_libs": "/usr/aarch64-linux-gnu"
-    },
-    "linux_arm32": {
-      "qemu": "qemu-arm",
-      "default_libs": "/usr/arm-linux-gnueabi"
-    }
-  }
-
-  if platform not in platform_config:
-    return 0
-
-  libs_path = platform_config[platform]["default_libs"]
-  if config.option("sysroot") != "":
-    libs_path = config.option("sysroot_" + platform)
-
-  return cmd_in_dir(directory, platform_config[platform]["qemu"], ["-L", libs_path, prog] + args, is_no_errors)
-
-def create_qemu_wrapper(binary_path, platform):
-  binary_dir = os.path.dirname(binary_path)
-  binary_name = os.path.basename(binary_path)
-  binary_bin = binary_path + '.bin'
-  sysroot = config.option("sysroot_" + platform)
-
-  if os.path.exists(binary_path):
-    os.rename(binary_path, binary_bin)
-
-  wrapper_content = f'''#!/bin/bash
-DIR="$(cd "$(dirname "${{BASH_SOURCE[0]}}")" && pwd)"
-export QEMU_LD_PREFIX={sysroot}
-exec qemu-aarch64 -L {sysroot} "$DIR/{binary_name}.bin" "$@"
-'''
-
-  with open(binary_path, 'w') as f:
-    f.write(wrapper_content)
-
-  os.chmod(binary_path, 0o755)
-  return binary_bin
+  if (platform == "linux_arm64"):
+    return cmd_in_dir(directory, "qemu-aarch64", ["-L", "/usr/aarch64-linux-gnu", prog] + args, is_no_errors)
+  if (platform == "linux_arm32"):
+    return cmd_in_dir(directory, "qemu-arm", ["-L", "/usr/arm-linux-gnueabi", prog] + args, is_no_errors)
+  return 0
 
 def cmd_and_return_cwd(prog, args=[], is_no_errors=False):
   cur_dir = os.getcwd()
@@ -659,7 +618,6 @@ def get_repositories():
     result.update(get_server_addons())
     result["document-server-integration"] = [False, False]
     result["document-templates"] = [False, False]
-    result["document-formats"] = [False, False]
 
   get_branding_repositories(result)
   return result
@@ -730,28 +688,18 @@ def git_dir():
   if ("windows" == host_platform()):
     return run_command("git --info-path")['stdout'] + "/../../.."
 
-def get_compiler_gcc_prefix(platform):
-  directory = "/usr/bin"
-
-  if config.option("sysroot") != "":
-    use_platform = platform
-    if ("linux_arm64" == platform and not is_os_arm()):
-      use_platform = "linux_64"
-    directory = config.option("sysroot_" + use_platform) + "/usr/bin"
-
-  if ("linux_arm64" == platform and not is_os_arm()):
-    return directory + "/aarch64-linux-gnu-"
-
-  return directory + "/"
+def get_prefix_cross_compiler_arm64():
+  cross_compiler_arm64 = config.option("arm64-toolchain-bin")
+  if is_file(cross_compiler_arm64 + "/aarch64-linux-gnu-g++") and is_file(cross_compiler_arm64 + "/aarch64-linux-gnu-gcc"):
+    return "aarch64-linux-gnu-"
+  if is_file(cross_compiler_arm64 + "/aarch64-unknown-linux-gnu-g++") and is_file(cross_compiler_arm64 + "/aarch64-unknown-linux-gnu-gcc"):
+    return "aarch64-unknown-linux-gnu-"
+  return ""
 
 def get_gcc_version():
-  # if use sysroot - fix gcc version
-  if config.option("sysroot") != "":
-    return 5004
-  gcc_path = "gcc"
   gcc_version_major = 4
   gcc_version_minor = 0
-  gcc_version_str = run_command(gcc_path + " -dumpfullversion -dumpversion")['stdout']
+  gcc_version_str = run_command("gcc -dumpfullversion -dumpversion")['stdout']
   if (gcc_version_str != ""):
     try:
       gcc_ver = gcc_version_str.split(".")
@@ -798,6 +746,13 @@ def qt_setup(platform):
       set_env("QT_QMAKE_ADDON", "-spec win32-arm64-msvc2017")
 
   set_env("QT_DEPLOY", qt_dir + "/bin")
+
+  if ("linux_arm64" == platform):
+    cross_compiler_arm64 = config.option("arm64-toolchain-bin")
+    if ("" != cross_compiler_arm64):
+      set_env("ARM64_TOOLCHAIN_BIN", cross_compiler_arm64)
+      set_env("ARM64_TOOLCHAIN_BIN_PREFIX", get_prefix_cross_compiler_arm64())
+
   return qt_dir
 
 def qt_version():
@@ -938,40 +893,20 @@ def qt_copy_lib(lib, dir):
 def _check_icu_common(dir, out):
   isExist = False
   for file in glob.glob(dir + "/libicu*"):
-    # Skip static libraries
-    if not file.endswith('.a'):
-      isExist = True
-      break
+    isExist = True
+    break
+
   if isExist:
-    # Copy only shared libraries (skip .a files)
-    for pattern in ["/libicui18n*", "/libicuuc*", "/libicudata*"]:
-      for file in glob.glob(dir + pattern):
-        if not file.endswith('.a'):
-          copy_file(file, out)
+    copy_files(dir + "/libicui18n*", out)
+    copy_files(dir + "/libicuuc*", out)
+    copy_files(dir + "/libicudata*", out)
+
   return isExist
 
-def qt_copy_icu(out, platform):
-  tests = [get_env("QT_DEPLOY") + "/../lib"]
-  prefix = ""
-  postfixes = [""]
-
-  if config.option("sysroot_" + platform) != "":
-    prefix = config.option("sysroot_" + platform)
-  else:
-    prefix = ""
-
-  if ("linux_64" == platform):
-    postfixes += ["/x86_64-linux-gnu"]
-  elif ("linux_arm64" == platform):
-    postfixes += ["/aarch64-linux-gnu"]
-  elif ("linux_32" == platform):
-    postfixes += ["/i386-linux-gnu"]
-
-  for postfix in postfixes:
-    tests += [prefix + "/lib" + postfix]
-    tests += [prefix + "/lib64" + postfix]
-    tests += [prefix + "/usr/lib" + postfix]
-    tests += [prefix + "/usr/lib64" + postfix]
+def qt_copy_icu(out):
+  tests = [get_env("QT_DEPLOY") + "/../lib", "/lib", "/lib/x86_64-linux-gnu", "/lib64", "/lib64/x86_64-linux-gnu"]
+  tests += ["/usr/lib", "/usr/lib/x86_64-linux-gnu", "/usr/lib64", "/usr/lib64/x86_64-linux-gnu"]
+  tests += ["/lib/i386-linux-gnu", "/usr/lib/i386-linux-gnu"]
 
   for test in tests:
     if (_check_icu_common(test, out)):
@@ -1060,7 +995,7 @@ def generate_doctrenderer_config(path, root, product, vendor = "", dictionaries
   file.close()
   return
 
-def generate_plist(file, platform):
+def generate_plist_framework_folder(file, platform):
   bundle_id_url = "com.onlyoffice."
   if ("" != get_env("PUBLISHER_BUNDLE_ID")):
     bundle_id_url = get_env("PUBLISHER_BUNDLE_ID")
@@ -1111,29 +1046,7 @@ def generate_plist(file, platform):
   fileInfo.close()
   return
 
-def generate_xcprivacy(file, platform):
-  content = \
-"""<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-<plist version="1.0">
-<dict>
-\t<key>NSPrivacyTracking</key>
-\t<false/>
-\t<key>NSPrivacyCollectedDataTypes</key>
-\t<array/>
-\t<key>NSPrivacyTrackingDomains</key>
-\t<array/>
-\t<key>NSPrivacyAccessedAPITypes</key>
-\t<array/>
-</dict>
-</plist>"""
-  fileDst = os.path.join(file, "PrivacyInfo.xcprivacy")
-  fileInfo = codecs.open(fileDst, "w", "utf-8")
-  fileInfo.write(content)
-  fileInfo.close()
-  return
-
-def for_each_framework(path, platform, callbacks, max_depth=512):
+def generate_plist(path, platform, max_depth=512):
   if not config.check_option("config", "bundle_dylibs"):
     return
   if max_depth == 0:
@@ -1145,10 +1058,9 @@ def for_each_framework(path, platform, callbacks, max_depth=512):
   for file in glob.glob(src_folder):
     if (is_dir(file)):
       if file.endswith(".framework"):
-        for callback in callbacks:
-          callback(file, platform)
+        generate_plist_framework_folder(file, platform)
       else:
-        for_each_framework(file, platform, callbacks, max_depth - 1)
+        generate_plist(file, platform, max_depth - 1)
   return
 
 def correct_bundle_identifier(bundle_identifier):
@@ -1365,10 +1277,7 @@ def mac_change_rpath_library(lib_name, old, new):
 
 def mac_correct_rpath_binary(path, libs):
   # if framework are built, instead of correcting lib paths add `@loader_path` to rpaths with `mac_add_loader_path_to_rpath()`
-  try:
-    if config.check_option("config", "bundle_dylibs"):
-      return
-  except:
+  if config.check_option("config", "bundle_dylibs"):
     return
 
   for lib in libs:
@@ -1398,27 +1307,26 @@ def mac_correct_rpath_x2t(dir):
   mac_correct_rpath_library("OFDFile", ["UnicodeConverter", "kernel", "graphics", "PdfFile"])
   mac_correct_rpath_library("DocxRenderer", ["UnicodeConverter", "kernel", "graphics"])
   mac_correct_rpath_library("IWorkFile", ["UnicodeConverter", "kernel"])
-  mac_correct_rpath_library("HWPFile", ["UnicodeConverter", "kernel", "graphics", "StarMathConverter"])
-  mac_correct_rpath_library("StarMathConverter", ["kernel"])
-  mac_correct_rpath_library("ooxmlsignature", ["kernel"])
-
-  def correct_core_executable(name, libs):
-    cmd("chmod", ["-v", "+x", name])
-    cmd("install_name_tool", ["-add_rpath", "@executable_path", name], True)
-    mac_correct_rpath_binary(name, mac_icu_libs + libs)
-    return
-
-  correct_core_executable("x2t", ["UnicodeConverter", "kernel", "kernel_network", "graphics", "PdfFile", "XpsFile", "OFDFile", "DjVuFile", "HtmlFile2", "Fb2File", "EpubFile", "doctrenderer", "DocxRenderer", "IWorkFile", "HWPFile", "StarMathConverter", "ooxmlsignature"])
+  mac_correct_rpath_library("HWPFile", ["UnicodeConverter", "kernel", "graphics"])
+  cmd("chmod", ["-v", "+x", "./x2t"])
+  cmd("install_name_tool", ["-add_rpath", "@executable_path", "./x2t"], True)
+  mac_correct_rpath_binary("./x2t", mac_icu_libs + ["UnicodeConverter", "kernel", "kernel_network", "graphics", "PdfFile", "XpsFile", "OFDFile", "DjVuFile", "HtmlFile2", "Fb2File", "EpubFile", "doctrenderer", "DocxRenderer", "IWorkFile", "HWPFile"])
   if is_file("./allfontsgen"):
-    correct_core_executable("allfontsgen", ["UnicodeConverter", "kernel", "graphics"])
+    cmd("chmod", ["-v", "+x", "./allfontsgen"])
+    cmd("install_name_tool", ["-add_rpath", "@executable_path", "./allfontsgen"], True)
+    mac_correct_rpath_binary("./allfontsgen", mac_icu_libs + ["UnicodeConverter", "kernel", "graphics"])
   if is_file("./allthemesgen"):
-    correct_core_executable("allthemesgen", ["UnicodeConverter", "kernel", "graphics", "kernel_network", "doctrenderer", "PdfFile", "XpsFile", "OFDFile", "DjVuFile", "DocxRenderer"])
+    cmd("chmod", ["-v", "+x", "./allthemesgen"])
+    cmd("install_name_tool", ["-add_rpath", "@executable_path", "./allthemesgen"], True)
+    mac_correct_rpath_binary("./allthemesgen", mac_icu_libs + ["UnicodeConverter", "kernel", "graphics", "kernel_network", "doctrenderer", "PdfFile", "XpsFile", "OFDFile", "DjVuFile", "DocxRenderer"])
   if is_file("./pluginsmanager"):
-    correct_core_executable("pluginsmanager", ["UnicodeConverter", "kernel", "kernel_network"])
+    cmd("chmod", ["-v", "+x", "./pluginsmanager"])
+    cmd("install_name_tool", ["-add_rpath", "@executable_path", "./pluginsmanager"], True)
+    mac_correct_rpath_binary("./pluginsmanager", mac_icu_libs + ["UnicodeConverter", "kernel", "kernel_network"])
   if is_file("./vboxtester"):
-    correct_core_executable("vboxtester", ["UnicodeConverter", "kernel", "kernel_network"])
-  if is_file("./x2ttester"):
-    correct_core_executable("x2ttester", ["UnicodeConverter", "kernel", "graphics"])
+    cmd("chmod", ["-v", "+x", "./vboxtester"])
+    cmd("install_name_tool", ["-add_rpath", "@executable_path", "./vboxtester"], True)
+    mac_correct_rpath_binary("./vboxtester", mac_icu_libs + ["UnicodeConverter", "kernel", "kernel_network"])
   os.chdir(cur_dir)
   return
 
@@ -1641,12 +1549,6 @@ def hack_xcode_ios():
     file.write(filedata)
   return
 
-def find_ios_sdk(sdk_name):
-  return run_command("xcrun --sdk " + sdk_name + " --show-sdk-path")['stdout']
-
-def find_xcode_toolchain(sdk_name):
-  return run_command("xcrun --sdk " + sdk_name + " --show-toolchain-path")['stdout']
-
 def find_mac_sdk_version():
   sdk_dir = run_command("xcode-select -print-path")['stdout']
   sdk_dir = os.path.join(sdk_dir, "Platforms/MacOSX.platform/Developer/SDKs")
@@ -1721,9 +1623,6 @@ def replaceFileLicence(path, license):
 def copy_v8_files(core_dir, deploy_dir, platform, is_xp=False):
   if (-1 != config.option("config").find("use_javascript_core")):
     return
-  if (0 == platform.find("mac")) and not (config.check_option("config", "use_v8")):
-    return
-
   directory_v8 = core_dir + "/Common/3dParty"
 
   if is_xp:
@@ -1947,38 +1846,6 @@ def check_module_version(actual_version, clear_func):
   clear_func()
   return
 
-def set_sysroot_env(platform):
-  global ENV_BEFORE_SYSROOT
-  ENV_BEFORE_SYSROOT = dict(os.environ)
-
-  if "linux" != host_platform():
-    return
-  if config.option("sysroot") == "":
-    return
-
-  path = config.option("sysroot_" + platform)
-  sysroot_path_bin = config.get_custom_sysroot_bin(platform)
-  compiler_gcc_prefix = get_compiler_gcc_prefix(platform)
-
-  os.environ['PATH'] = sysroot_path_bin + ":" + get_env("PATH")
-  os.environ['LD_LIBRARY_PATH'] = config.get_custom_sysroot_lib(platform)
-
-  os.environ['CC'] = compiler_gcc_prefix + "gcc"
-  os.environ['CXX'] = compiler_gcc_prefix + "g++"
-  os.environ['AR'] = compiler_gcc_prefix + "ar"
-  os.environ['RANLIB'] = compiler_gcc_prefix + "ranlib"
-
-  os.environ['CFLAGS'] = "--sysroot=" + path
-  os.environ['CXXFLAGS'] = "--sysroot=" + path
-  os.environ['LDFLAGS'] = "--sysroot=" + path
-
-  check_python()
-  return
-
-def restore_sysroot_env():
-  os.environ.clear()
-  os.environ.update(ENV_BEFORE_SYSROOT)
-
 def check_python():
   if ("linux" != host_platform()):
     return
@@ -1987,9 +1854,8 @@ def check_python():
 
   if not is_dir(directory + "/python3"):
     download('https://github.com/ONLYOFFICE-data/build_tools_data/raw/refs/heads/master/python/python3.tar.gz', directory + "/python3.tar.gz")
-    download('https://github.com/ONLYOFFICE-data/build_tools_data/raw/refs/heads/master/python/extract.sh', directory + "/extract.sh")
-    cmd_in_dir(directory, "chmod", ["+x", "./extract.sh"])
-    cmd_in_dir(directory, "./extract.sh")
+    cmd("tar", ["xfz", directory + "/python3.tar.gz", "-C", directory])
+    cmd("ln", ["-s", directory_bin + "/python3", directory_bin + "/python"])
   directory_bin = directory_bin.replace(" ", "\\ ")
   os.environ["PATH"] = directory_bin + os.pathsep + os.environ["PATH"]
   return
@@ -2046,36 +1912,6 @@ def get_autobuild_version(product, platform="", branch="", build=""):
   download_addon = download_branch + "/" + download_build + "/" + product + "-" + download_platform + ".7z"
   return "http://repo-doc-onlyoffice-com.s3.amazonaws.com/archive/" + download_addon
 
-def is_use_create_artifacts_qemu_any_platform():
-  if config.check_option("platform", "win_arm64") and not is_os_arm():
-    return True
-  return False
-
-def is_use_create_artifacts_qemu(platform):
-  if platform == "win_arm64" and not is_os_arm():
-    return True
-  return False
-
-def create_artifacts_qemu_any_platform():
-  if not is_use_create_artifacts_qemu_any_platform():
-    return
-  if config.check_option("platform", "win_arm64"):
-    create_artifacts_qemu_win_arm()
-  return;
-
-def create_artifacts_qemu_win_arm():
-  if config.option("qemu-win-arm64-dir") == "":
-    print("For deploying win_arm64 on non arm host you should provide qemu-win-arm64-dir. More info in tools/win/qemu/README.md")
-    return
-
-  old_curr_dir = os.path.abspath(os.curdir)
-  qemu_dir = os.path.abspath(config.option("qemu-win-arm64-dir"))
-
-  os.chdir(qemu_dir)
-  start_qemu_bat_path = f"start.bat"
-  cmd(start_qemu_bat_path, [])
-  os.chdir(old_curr_dir)
-
 def create_x2t_js_cache(dir, product, platform):
   # mac
   if is_file(dir + "/libdoctrenderer.dylib") or is_dir(dir + "/doctrenderer.framework"):
@@ -2087,6 +1923,9 @@ def create_x2t_js_cache(dir, product, platform):
     cmd_in_dir_qemu(platform, dir, "./x2t", ["-create-js-snapshots"], True)
     return
 
+  if platform == "win_arm64": # copying sdkjs later
+    return
+
   cmd_in_dir(dir, "./x2t", ["-create-js-snapshots"], True)
   return
 
@@ -2101,19 +1940,11 @@ def deploy_icu(core_dir, dst_dir, platform):
     copy_file(src_dir + "/icudt" + icu_ver + "l.dat", dst_dir + "/icudt" + icu_ver + "l.dat")
     return
 
-  isXp = False
-  if platform.endswith("xp"):
-    isXp = True
-    platform = platform[0:-3]
   src_dir = core_dir + "/Common/3dParty/icu/" + platform + "/build"
 
   if (0 == platform.find("win")):
-    icu_ver_win = icu_ver
-    if isXp:
-      icu_ver_win = icu_ver_old
-      src_dir += "/xp"
-    copy_file(src_dir + "/icudt" + icu_ver_win + ".dll", dst_dir + "/icudt" + icu_ver_win + ".dll")
-    copy_file(src_dir + "/icuuc" + icu_ver_win + ".dll", dst_dir + "/icuuc" + icu_ver_win + ".dll")
+    copy_file(src_dir + "/icudt" + icu_ver + ".dll", dst_dir + "/icudt" + icu_ver + ".dll")
+    copy_file(src_dir + "/icuuc" + icu_ver + ".dll", dst_dir + "/icuuc" + icu_ver + ".dll")
 
   if (0 == platform.find("linux")):
     copy_file(src_dir + "/libicudata.so." + icu_ver, dst_dir + "/libicudata.so." + icu_ver)

scripts/build_server.py

@@ -11,7 +11,6 @@ def make():
 
   git_dir = base.get_script_dir() + "/../.."
   server_dir = base.get_script_dir() + "/../../server"
-  server_admin_panel_dir = base.get_script_dir() + "/../../server-admin-panel"
   branding_dir = server_dir + "/branding"
 
   if("" != config.option("branding")):
@@ -50,11 +49,9 @@ def make():
   if ("windows" == base.host_platform()):
     pkg_target += "-win"
 
-  base.cmd_in_dir(server_dir + "/DocService", "pkg", [".", "-t", pkg_target, "--options", "max_old_space_size=6144", "-o", "docservice"])
+  base.cmd_in_dir(server_dir + "/DocService", "pkg", [".", "-t", pkg_target, "--options", "max_old_space_size=4096", "-o", "docservice"])
   base.cmd_in_dir(server_dir + "/FileConverter", "pkg", [".", "-t", pkg_target, "-o", "converter"])
   base.cmd_in_dir(server_dir + "/Metrics", "pkg", [".", "-t", pkg_target, "-o", "metrics"])
-  if "server-admin-panel" in base.get_server_addons() and base.is_exist(server_admin_panel_dir):
-    base.cmd_in_dir(server_admin_panel_dir + "/server", "pkg", [".", "-t", pkg_target, "-o", "adminpanel"])
 
   example_dir = base.get_script_dir() + "/../../document-server-integration/web/documentserver-example/nodejs"
   base.delete_dir(example_dir  + "/node_modules")
@@ -68,10 +65,8 @@ def build_server_with_addons():
   for addon in addons:
     if (addon):
       addon_dir = base.get_script_dir() + "/../../" + addon
-      if (base.is_exist(addon_dir + "/package.json")):
-        base.print_info("npm ci: " + addon)
+      if (base.is_exist(addon_dir)):
         base.cmd_in_dir(addon_dir, "npm", ["ci"])
-        base.print_info("npm run build: " + addon)
         base.cmd_in_dir(addon_dir, "npm", ["run", "build"])
 
 def build_server_develop():

scripts/config.py

@@ -56,12 +56,16 @@ def parse():
   if ("mac" == host_platform) and check_option("platform", "mac_arm64") and not base.is_os_arm():
     if not check_option("platform", "mac_64"):
       options["platform"] = "mac_64 " + options["platform"]
+      
+  if ("windows" == host_platform) and check_option("platform", "win_arm64") and not base.is_os_arm():
+    if not check_option("platform", "win_64"):
+      options["platform"] = "win_64 " + options["platform"]
 
-  if (False):
-    # use qemu on deploy for emulation 
-    if ("windows" == host_platform) and check_option("platform", "win_arm64") and not base.is_os_arm():
-      if not check_option("platform", "win_64"):
-        options["platform"] = "win_64 " + options["platform"]
+  if ("linux" == host_platform) and check_option("platform", "linux_arm64") and not base.is_os_arm():
+    if not check_option("platform", "linux_64"):
+      # linux_64 binaries need only for desktop
+      if check_option("module", "desktop"):
+        options["platform"] = "linux_64 " + options["platform"]
 
   if check_option("platform", "xp") and ("windows" == host_platform):
     options["platform"] += " win_64_xp win_32_xp"
@@ -77,27 +81,6 @@ def parse():
 
   if ("windows" == host_platform) and ("2019" == option("vs-version")):
       extend_option("config", "vs2019")
-      
-  # sysroot setup
-  if "linux" != host_platform and "sysroot" in options:
-    options["sysroot"] = ""
-
-  if "linux" == host_platform and "sysroot" in options:
-    if options["sysroot"] == "0":
-      options["sysroot"] = ""
-    elif options["sysroot"] == "1":
-      dst_dir = os.path.abspath(base.get_script_dir(__file__) + '/../tools/linux/sysroot')
-      dst_dir_amd64 = dst_dir + "/ubuntu16-amd64-sysroot"
-      dst_dir_arm64 = dst_dir + "/ubuntu16-arm64-sysroot"
-      if not base.is_dir(dst_dir_amd64) or not base.is_dir(dst_dir_arm64):
-        base.cmd_in_dir(dst_dir, "python3", ["./fetch.py", "all"])
-      options["sysroot_linux_64"] = dst_dir_amd64
-      options["sysroot_linux_arm64"] = dst_dir_arm64
-    else:
-      # specific sysroot => one platform for build!
-      options["sysroot"] = "1"
-      options["sysroot_linux_64"] = options["sysroot"]
-      options["sysroot_linux_arm64"] = options["sysroot"]
 
   if is_cef_107():
     extend_option("config", "cef_version_107")
@@ -125,6 +108,33 @@ def parse():
   if not "sdkjs-plugin-server" in options:
     options["sdkjs-plugin-server"] = "default"
 
+  # custom-sysroot setup
+  if "linux" != host_platform and "custom-sysroot" in options:
+    options["custom-sysroot"] = ""
+
+  if "linux" == host_platform and "custom-sysroot" in options:
+    if options["custom-sysroot"] == "0":
+      options["custom-sysroot"] = ""
+    elif options["custom-sysroot"] == "1":
+      dst_dir = os.path.abspath(base.get_script_dir(__file__) + '/../tools/linux/sysroot')
+      custom_sysroot = dst_dir + '/sysroot_ubuntu_1604'
+      options["custom-sysroot"] = custom_sysroot
+      if not os.path.isdir(custom_sysroot):
+        print("Custom sysroot is not found, downloading...")
+        sysroot_url = 'https://github.com/ONLYOFFICE-data/build_tools_data/raw/refs/heads/master/sysroot/sysroot_ubuntu_1604.tar.xz'
+        base.download(sysroot_url, dst_dir + '/sysroot_ubuntu_1604.tar.xz')
+        os.mkdir(custom_sysroot)
+        print("Unpacking...")
+        base.cmd2('tar', ['-xf', dst_dir + '/sysroot_ubuntu_1604.tar.xz', '-C', dst_dir])
+        if os.path.exists(dst_dir + '/sysroot_ubuntu_1604.tar.xz'):
+          os.remove(dst_dir + '/sysroot_ubuntu_1604.tar.xz')
+
+  if not "arm64-toolchain-bin" in options:
+    if not "custom-sysroot" in options:
+      options["arm64-toolchain-bin"] = "/usr/bin"
+    else:
+      options["arm64-toolchain-bin"] = get_custom_sysroot_bin()
+
   if check_option("platform", "ios"):
     if not check_option("config", "no_bundle_xcframeworks"):
       if not check_option("config", "bundle_xcframeworks"):
@@ -224,25 +234,13 @@ def is_mobile_platform():
     return True
   return False
 
-def get_custom_sysroot_bin(platform):
-  use_platform = platform
-  if "linux_arm64" == platform and not base.is_os_arm():
-    # use cross compiler
-    use_platform = "linux_64"
+def get_custom_sysroot_bin():
+  return option("custom-sysroot") + "/usr/bin"
 
-  return option("sysroot_" + use_platform) + "/usr/bin"
-
-def get_custom_sysroot_lib(platform, isNatural=False):
-  use_platform = platform
-  if "linux_arm64" == platform and not base.is_os_arm() and not isNatural:
-    # use cross compiler
-    use_platform = "linux_64"
-
-  if ("linux_64" == use_platform):
-    return option("sysroot_linux_64") + "/usr/lib/x86_64-linux-gnu"
-  if ("linux_arm64" == use_platform):
-    return option("sysroot_linux_arm64") + "/usr/lib/aarch64-linux-gnu"
-  return ""
+# todo 32bit support?
+def get_custom_sysroot_lib():
+  if base.is_os_64bit():
+    return option("custom-sysroot") + "/usr/lib/x86_64-linux-gnu"
 
 def parse_defaults():
   defaults_path = base.get_script_dir() + "/../defaults"

scripts/core_common/modules/android/android_ndk.py

@@ -71,6 +71,13 @@ else:
     "arch" : "darwin-x86_64"
   }
 
+def get_android_ndk_version():
+  #return "26.2.11394342"
+  return "21.1.6352462"
+
+def get_android_ndk_version_major():
+  return int(get_android_ndk_version().split(".")[0])
+
 def get_options_dict_as_array(opts):
   value = []
   for key in opts:

scripts/core_common/modules/boost.py

@@ -99,7 +99,7 @@ def make():
     correct_install_includes_win(base_dir, "win_arm64")
 
   if config.check_option("platform", "linux_64") and not base.is_dir("../build/linux_64"):
-    if config.option("sysroot") == "":
+    if config.option("custom-sysroot") == "":
       addon_config = []
       addon_compile = []
       if "1" == config.option("use-clang"):
@@ -138,14 +138,14 @@ def make():
   if (-1 != config.option("platform").find("android")) and not base.is_dir("../build/android"):
     boost_qt.make(os.getcwd(), ["filesystem", "system", "date_time", "regex"])
 
-  if config.check_option("platform", "mac_64") and not base.is_dir("../build/mac_64"):
+  if (-1 != config.option("platform").find("mac")) and not base.is_dir("../build/mac_64"):
     boost_qt.make(os.getcwd(), ["filesystem", "system", "date_time", "regex"], "mac_64")
     directory_build = base_dir + "/build/mac_64/lib"
     base.delete_file(directory_build + "/libboost_system.a")
     base.delete_file(directory_build + "/libboost_system.dylib")
     base.copy_files(directory_build + "/mac_64/*.a", directory_build)
 
-  if config.check_option("platform", "mac_arm64") and not base.is_dir("../build/mac_arm64"):
+  if (-1 != config.option("platform").find("mac_arm64")) and not base.is_dir("../build/mac_arm64"):
     boost_qt.make(os.getcwd(), ["filesystem", "system", "date_time", "regex"], "mac_arm64")
     directory_build = base_dir + "/build/mac_arm64/lib"
     base.delete_file(directory_build + "/libboost_system.a")

scripts/core_common/modules/boost_qt.py

@@ -9,14 +9,11 @@ import qmake
 
 def make(src_dir, modules, build_platform="android", qmake_addon=""):
   old_cur = os.getcwd()
-  old_env = dict(os.environ)
-  b2_addon = ""
 
   print("boost-headers...")
-  
-  base.cmd("./bootstrap.sh", ["--with-libraries=system"]) 
+  base.cmd("./bootstrap.sh", ["--with-libraries=system"])
   base.cmd("./b2", ["--prefix=./../build/" + build_platform, "headers", "install"])
-  
+
   for module in modules:
     print("boost-module: " + module + " ...")
     module_dir = src_dir + "/libs/" + module
@@ -43,8 +40,6 @@ def make(src_dir, modules, build_platform="android", qmake_addon=""):
     base.save_as_script(module_dir + "/" + module + ".pro", pro_file_content)
     os.chdir(module_dir)
     qmake.make_all_platforms(module_dir + "/" + module + ".pro", qmake_addon)
-
-  os.environ.clear()
-  os.environ.update(old_env)
+  
   os.chdir(old_cur)
   return

scripts/core_common/modules/cef.py

@@ -5,13 +5,6 @@ sys.path.append('../..')
 import config
 import base
 import os
-import glob
-
-def clear_module():
-  for child in glob.glob("./*"):
-    if base.is_dir(child):
-      base.delete_dir(child)
-  return
 
 def make():
   print("[fetch & build]: cef")
@@ -20,8 +13,7 @@ def make():
   old_cur = os.getcwd()
   os.chdir(base_dir)
 
-  base.check_module_version("2", clear_module)
-  platforms = ["win_64", "win_32", "win_64_xp", "win_32_xp", "linux_64", "linux_32", "mac_64", "mac_arm64", "win_arm64", "linux_arm64"]
+  platforms = ["win_64", "win_32", "win_64_xp", "win_32_xp", "linux_64", "linux_32", "mac_64", "mac_arm64", "win_arm64"]
 
   for platform in platforms:
     if not config.check_option("platform", platform):

scripts/core_common/modules/heif.py

@@ -21,10 +21,7 @@ IOS_CMAKE_TOOLCHAIN_FILE = base.get_script_dir() + "/../../core/Common/3dParty/h
 ANDROID_CMAKE_TOOLCHAIN_FILE = base.get_env("ANDROID_NDK_ROOT") + "/build/cmake/android.toolchain.cmake"
 
 # linux arm64 cmake toolchain
-LINUX_SYSTEM_AARCH64_TOOLCHAIN_FILE = base.get_script_dir() + "/../tools/linux/sysroot/system-aarch64.toolchain.cmake"
-LINUX_CUSTOM_SYSROOT_TOOLCHAIN_FILE = base.get_script_dir() + "/../tools/linux/sysroot/custom-sysroot.toolchain.cmake"
-
-OLD_ENV = dict()
+LINUX_ARM64_CMAKE_TOOLCHAIN_FILE = base.get_script_dir() + "/../tools/linux/arm/cross_arm64/linux-arm64.toolchain.cmake"
 
 def get_vs_version():
   vs_version = "14 2015"
@@ -70,14 +67,8 @@ def build_with_cmake(platform, cmake_args, build_type):
       cmake_args_ext += ["-DCMAKE_OSX_DEPLOYMENT_TARGET=10.11", "-DCMAKE_OSX_ARCHITECTURES=x86_64"]
     elif platform == "mac_arm64":
       cmake_args_ext += ["-DCMAKE_OSX_DEPLOYMENT_TARGET=11.0", "-DCMAKE_OSX_ARCHITECTURES=arm64"]
-    elif config.option("sysroot") != "":
-      # force use custom CXXFLAGS with Release/Debug build
-      if (platform == "linux_64"):
-        cmake_args += ["-DCMAKE_TOOLCHAIN_FILE=" + LINUX_CUSTOM_SYSROOT_TOOLCHAIN_FILE]
-      else:
-        cmake_args += ["-DCMAKE_TOOLCHAIN_FILE=" + LINUX_SYSTEM_AARCH64_TOOLCHAIN_FILE]
-    elif platform == "linux_arm64" and not base.is_os_arm():
-      cmake_args += ["-DCMAKE_TOOLCHAIN_FILE=" + LINUX_SYSTEM_AARCH64_TOOLCHAIN_FILE]
+    elif platform == "linux_arm64":
+      cmake_args += ["-DCMAKE_TOOLCHAIN_FILE=" + LINUX_ARM64_CMAKE_TOOLCHAIN_FILE]
   # IOS
   elif "ios" in platform:
     cmake_args_ext = [
@@ -110,21 +101,13 @@ def build_with_cmake(platform, cmake_args, build_type):
     elif platform == "android_x86_64":
       cmake_args_ext += get_cmake_args_android("x86_64", "21")
 
-  # env setup for custom sysroot
-  if config.option("sysroot") != "":
-    base.set_sysroot_env(platform)
-
   # run cmake
   base.cmd("cmake", cmake_args + cmake_args_ext)
-
   # build
   if "Unix Makefiles" in cmake_args_ext:
     base.cmd("make", ["-j4"])
   else:
     base.cmd("cmake", ["--build", ".", "--config", build_type])
-
-  if config.option("sysroot") != "":
-    base.restore_sysroot_env()
   return
 
 # general make function that calls `build_func` callback for configured platform(s) with specified cmake arguments
@@ -202,7 +185,6 @@ def make_x265(base_dir, build_type):
     "-DENABLE_CLI=OFF",                 # do not build standalone CLI app
     "-DENABLE_SHARED=OFF",              # do not build shared libs
     "-DENABLE_ASSEMBLY=OFF",            # disable assembly optimizations
-    "-DENABLE_LIBNUMA=OFF",             # disable libnuma usage (affects Linux only)
   ]
 
   # lib build function

scripts/core_common/modules/icu.py

@@ -9,11 +9,11 @@ import os
 import glob
 import icu_android
 
-def fetch_icu(major, minor, target_dir="icu"):
+def fetch_icu(major, minor):
   if (base.is_dir("./icu2")):
-    base.delete_dir_with_access_error("icu2")
+    base.delete_dir_with_access_error("icu2")  
   base.cmd("git", ["clone", "--depth", "1", "--branch", "release-" + major + "-" + minor, "https://github.com/unicode-org/icu.git", "./icu2"])
-  base.copy_dir("./icu2/icu4c", target_dir)
+  base.copy_dir("./icu2/icu4c", "./icu")
   base.delete_dir_with_access_error("icu2")
   return
 
@@ -35,7 +35,7 @@ def make():
   old_cur = os.getcwd()
   os.chdir(base_dir)
 
-  base.check_module_version("8", clear_module)
+  base.check_module_version("7", clear_module)
 
   if (-1 != config.option("platform").find("android")):
     icu_android.make()
@@ -44,17 +44,9 @@ def make():
 
   icu_major = "74"
   icu_minor = "2"
-
+  
   if not base.is_dir("icu"):
-    fetch_icu(icu_major, icu_minor)
-
-  # old version for win_xp
-  icu_major_old = "58"
-  icu_minor_old = "3"
-
-  if config.check_option("platform", "win_64_xp") or config.check_option("platform", "win_32_xp"):
-    if not base.is_dir("icu58"):
-      fetch_icu(icu_major_old, icu_minor_old, "icu58")
+    fetch_icu(icu_major, icu_minor)  
 
   if ("windows" == base.host_platform()):
     platformToolset = "v140"
@@ -65,61 +57,52 @@ def make():
       need_platforms.append("win_64")
     if (-1 != config.option("platform").find("win_32")):
       need_platforms.append("win_32")
-    if (-1 != config.option("platform").find("win_arm64")):
+    if (-1 != config.option("platform").find("win_arm64")): 
       need_platforms.append("win_64") # for exe files
       need_platforms.append("win_arm64")
-
-    def build_icu_win(source_dir, out_dir, icu_major):
-      if base.is_dir(out_dir):
-        return
-
-      compile_bat = []
-      compile_bat.append("setlocal")
-
-      args = {
-        "win_32" : {
-          "msbuild_platfrom" : "Win32",
-          "vcvarsall_arch" : "x86",
-          "out_bin_dir" : source_dir + "/bin/",
-          "out_lib_dir" : source_dir + "/lib/"
-        },
-        "win_64" : {
-          "msbuild_platfrom" : "X64",
-          "vcvarsall_arch" : "x64",
-          "out_bin_dir" : source_dir + "/bin64/",
-          "out_lib_dir" : source_dir + "/lib64/"
-        },
-        "win_arm64" : {
-          "msbuild_platfrom" : "ARM64",
-          "vcvarsall_arch" : "x64_arm64",
-          "out_bin_dir" : source_dir + "/binARM64/",
-          "out_lib_dir" : source_dir + "/libARM64/"
-        }
-      }
-
-      platform_args = args[platform]
-
-      compile_bat.append("call \"" + config.option("vs-path") + "/vcvarsall.bat\" " + platform_args['vcvarsall_arch'])
-      compile_bat.append("call MSBuild.exe " + source_dir + "/source/allinone/allinone.sln /p:Configuration=Release /p:PlatformToolset=" + platformToolset + " /p:Platform=" + platform_args['msbuild_platfrom'])
-      compile_bat.append("endlocal")
-      base.run_as_bat(compile_bat)
-
-      base.create_dir(out_dir)
-      base.copy_file(platform_args['out_bin_dir'] + "icudt" + icu_major + ".dll", out_dir)
-      base.copy_file(platform_args['out_bin_dir'] + "icuuc" + icu_major + ".dll", out_dir)
-      base.copy_file(platform_args['out_lib_dir'] + "icudt.lib", out_dir)
-      base.copy_file(platform_args['out_lib_dir'] + "icuuc.lib", out_dir)
-
+      
     for platform in need_platforms:
       if not config.check_option("platform", platform) and not config.check_option("platform", platform + "_xp"):
         continue
-
-      if not (config.check_option("platform", "win_64_xp") or config.check_option("platform", "win_32_xp")):
-        build_icu_win("icu", platform + "/build", icu_major)
-      else:
-        # xp
-        build_icu_win("icu58", platform + "/build/xp", icu_major_old)
-
+      
+      if not base.is_dir(platform + "/build"):
+        base.create_dir(platform)
+        compile_bat = []
+        compile_bat.append("setlocal")
+        
+        args = {
+          "win_32" : {
+            "msbuild_platfrom" : "Win32",
+            "vcvarsall_arch" : "x86",
+            "out_bin_dir" : "icu/bin/",
+            "out_lib_dir" : "icu/lib/"
+          },
+          "win_64" : {
+            "msbuild_platfrom" : "X64",
+            "vcvarsall_arch" : "x64",
+            "out_bin_dir" : "icu/bin64/",
+            "out_lib_dir" : "icu/lib64/"
+          },
+          "win_arm64" : {
+            "msbuild_platfrom" : "ARM64",
+            "vcvarsall_arch" : "x64_arm64",
+            "out_bin_dir" : "icu/binARM64/",
+            "out_lib_dir" : "icu/libARM64/"
+          }
+        }
+        
+        platform_args = args[platform]
+                  
+        compile_bat.append("call \"" + config.option("vs-path") + "/vcvarsall.bat\" " + platform_args['vcvarsall_arch'])
+        compile_bat.append("call MSBuild.exe icu/source/allinone/allinone.sln /p:Configuration=Release /p:PlatformToolset=" + platformToolset + " /p:Platform=" + platform_args['msbuild_platfrom'])
+        compile_bat.append("endlocal")
+        base.run_as_bat(compile_bat)
+        
+        base.create_dir(platform + "/build")
+        base.copy_file(platform_args['out_bin_dir'] + "icudt" + icu_major + ".dll", platform + "/build/")
+        base.copy_file(platform_args['out_bin_dir'] + "icuuc" + icu_major + ".dll", platform + "/build/")
+        base.copy_file(platform_args['out_lib_dir'] + "icudt.lib", platform + "/build/")
+        base.copy_file(platform_args['out_lib_dir'] + "icuuc.lib", platform + "/build/")
     os.chdir(old_cur)
     return
 
@@ -129,45 +112,44 @@ def make():
       os.chdir("icu/cross_build")
       command_configure = "./../source/runConfigureICU"
       command_compile_addon = "-static-libstdc++ -static-libgcc"
+      ld_library_path_copy = ''
       if "1" == config.option("use-clang"):
         command_configure = "CXXFLAGS=-stdlib=libc++ " + command_configure
         command_compile_addon = "-stdlib=libc++"
-      if "" == config.option("sysroot"):
+      if "" == config.option("custom-sysroot"):
         base.cmd(command_configure, ["Linux", "--prefix=" + base_dir + "/icu/cross_build_install"])
         base.replaceInFile("./../source/icudefs.mk.in", "LDFLAGS = @LDFLAGS@ $(RPATHLDFLAGS)", "LDFLAGS = @LDFLAGS@ $(RPATHLDFLAGS) " + command_compile_addon)
       else:
-        base.set_sysroot_env("linux_64") 
-        sysroot_path = config.option("sysroot_linux_64")
-        sysroot_path_bin = config.get_custom_sysroot_bin("linux_64")
+        if 'LD_LIBRARY_PATH' in os.environ:
+          ld_library_path_copy = os.environ['LD_LIBRARY_PATH']
+        os.environ['LD_LIBRARY_PATH'] = config.get_custom_sysroot_lib()
         base.cmd_exe("./../source/configure", ["--prefix=" + base_dir + "/icu/cross_build_install",
-                                           "CC=" + sysroot_path_bin + "/gcc", "CXX=" + sysroot_path_bin + "/g++",
-                                           "AR=" + sysroot_path_bin + "/ar", "RANLIB=" + sysroot_path_bin + "/ranlib",
-                                           "CFLAGS=--sysroot=" + sysroot_path,
-                                           "CXXFLAGS=--sysroot=" + sysroot_path + " " + command_compile_addon,
-                                           "LDFLAGS=--sysroot=" + sysroot_path])
+                                           "CC=" + config.get_custom_sysroot_bin() + "/gcc", "CXX=" + config.get_custom_sysroot_bin() + "/g++",
+                                           "AR=" + config.get_custom_sysroot_bin() + "/ar", "RANLIB=" + config.get_custom_sysroot_bin() + "/ranlib",
+                                           "CFLAGS=--sysroot=" + config.option("custom-sysroot"),
+                                           "CXXFLAGS=--sysroot=" + config.option("custom-sysroot") + " " + command_compile_addon,
+                                           "LDFLAGS=--sysroot=" + config.option("custom-sysroot")])
 
-      if "" == config.option("sysroot"):
+      if "" == config.option("custom-sysroot"):
         base.cmd("make", ["-j4"])
         base.cmd("make", ["install"], True)
       else:
         base.cmd_exe("make", ["-j4"])
         base.cmd_exe("make", ["install"], True)
-        base.restore_sysroot_env()
+        os.environ['LD_LIBRARY_PATH'] = ld_library_path_copy
 
       base.create_dir(base_dir + "/linux_64")
       base.create_dir(base_dir + "/linux_64/build")
       base.copy_file(base_dir + "/icu/cross_build_install/lib/libicudata.so." + icu_major + "." + icu_minor, base_dir + "/linux_64/build/libicudata.so." + icu_major)
       base.copy_file(base_dir + "/icu/cross_build_install/lib/libicuuc.so." + icu_major + "." + icu_minor, base_dir + "/linux_64/build/libicuuc.so." + icu_major)
       base.copy_dir(base_dir + "/icu/cross_build_install/include", base_dir + "/linux_64/build/include")
-
+      
     if config.check_option("platform", "linux_arm64") and not base.is_dir(base_dir + "/linux_arm64") and not base.is_os_arm():
       base.create_dir(base_dir + "/icu/linux_arm64")
       os.chdir(base_dir + "/icu/linux_arm64")
-      compiler_gcc_prefix = base.get_compiler_gcc_prefix("linux_arm64")
-      if config.option("sysroot") != "":
-        base.set_sysroot_env("linux_arm64")
+      base_arm_tool_dir = config.option('arm64-toolchain-bin') + '/' + base.get_prefix_cross_compiler_arm64()
       base.cmd("./../source/configure", ["--host=arm-linux", "--prefix=" + base_dir + "/icu/linux_arm64_install", "--with-cross-build=" + base_dir + "/icu/cross_build",
-        "CC=" + compiler_gcc_prefix + "gcc", "CXX=" + compiler_gcc_prefix + "g++", "AR=" + compiler_gcc_prefix + "ar", "RANLIB=" + compiler_gcc_prefix + "ranlib"])
+        "CC=" + base_arm_tool_dir + "gcc", "CXX=" + base_arm_tool_dir + "g++", "AR=" + base_arm_tool_dir + "ar", "RANLIB=" + base_arm_tool_dir + "ranlib"])
       base.cmd("make", ["-j4"])
       base.cmd("make", ["install"], True)
       base.create_dir(base_dir + "/linux_arm64")
@@ -175,8 +157,6 @@ def make():
       base.copy_file(base_dir + "/icu/linux_arm64_install/lib/libicudata.so." + icu_major + "." + icu_minor, base_dir + "/linux_arm64/build/libicudata.so." + icu_major)
       base.copy_file(base_dir + "/icu/linux_arm64_install/lib/libicuuc.so." + icu_major + "." + icu_minor, base_dir + "/linux_arm64/build/libicuuc.so." + icu_major)
       base.copy_dir(base_dir + "/icu/linux_arm64_install/include", base_dir + "/linux_arm64/build/include")
-      if config.option("sysroot") != "":
-        base.restore_sysroot_env()
 
       os.chdir("../..")
 
@@ -193,6 +173,6 @@ def make():
     if (-1 != config.option("platform").find("ios")):
       if not base.is_dir("build"):
         base.bash("./icu_ios")
-
+      
   os.chdir(old_cur)
   return

scripts/core_common/modules/icu_mac.py

@@ -41,7 +41,7 @@ if not base.is_dir(current_dir + "/mac_cross_64"):
   old_env = change_icu_defs("x86_64")
 
   base.cmd("../icu/source/runConfigureICU", ["MacOSX",
-    "--prefix=" + current_dir + "/mac_64_install", "--enable-static"])
+    "--prefix=" + current_dir + "/mac_cross_64", "--enable-static"])
 
   base.cmd("make", ["-j4"])
   base.cmd("make", ["install"], True)
@@ -58,7 +58,7 @@ addon = []
 if not base.is_os_arm():
   addon = ["--host=aarch64-apple-darwin"]
 
-base.cmd("./configure", ["--prefix=" + current_dir + "/mac_arm64_install",
+base.cmd("./configure", ["--prefix=" + current_dir + "/mac_arm_64",
   "--with-cross-build=" + current_dir + "/mac_cross_64", "--enable-static", "VERBOSE=1"] + addon)
 
 base.cmd("make", ["-j4"])
@@ -80,26 +80,25 @@ base.create_dir(current_dir + "/mac_64/build")
 base.create_dir(current_dir + "/mac_arm64")
 base.create_dir(current_dir + "/mac_arm64/build")
 
-base.copy_dir(current_dir + "/mac_64_install/include", current_dir + "/mac_64/build/include")
+base.copy_dir(current_dir + "/mac_cross_64/include", current_dir + "/mac_64/build/include")
 # copy shared libs
-base.copy_file(current_dir + "/mac_64_install/lib/libicudata." + icu_major + "." + icu_minor + ".dylib", current_dir + "/mac_64/build/libicudata." + icu_major + ".dylib")
-base.copy_file(current_dir + "/mac_64_install/lib/libicuuc." + icu_major + "." + icu_minor + ".dylib", current_dir + "/mac_64/build/libicuuc." + icu_major + ".dylib")
+base.copy_file(current_dir + "/mac_cross_64/lib/libicudata." + icu_major + "." + icu_minor + ".dylib", current_dir + "/mac_64/build/libicudata." + icu_major + ".dylib")
+base.copy_file(current_dir + "/mac_cross_64/lib/libicuuc." + icu_major + "." + icu_minor + ".dylib", current_dir + "/mac_64/build/libicuuc." + icu_major + ".dylib")
 # copy static libs
-base.copy_file(current_dir + "/mac_64_install/lib/libicudata.a", current_dir + "/mac_64/build")
-base.copy_file(current_dir + "/mac_64_install/lib/libicui18n.a", current_dir + "/mac_64/build")
-base.copy_file(current_dir + "/mac_64_install/lib/libicuuc.a", current_dir + "/mac_64/build")
+base.copy_file(current_dir + "/mac_cross_64/lib/libicudata.a", current_dir + "/mac_64/build")
+base.copy_file(current_dir + "/mac_cross_64/lib/libicui18n.a", current_dir + "/mac_64/build")
+base.copy_file(current_dir + "/mac_cross_64/lib/libicuuc.a", current_dir + "/mac_64/build")
 
-base.copy_dir(current_dir + "/mac_arm64_install/include", current_dir + "/mac_arm64/build/include")
+base.copy_dir(current_dir + "/mac_arm_64/include", current_dir + "/mac_arm64/build/include")
 # copy shared libs
-base.copy_file(current_dir + "/mac_arm64_install/lib/libicudata." + icu_major + "." + icu_minor + ".dylib", current_dir + "/mac_arm64/build/libicudata." + icu_major + ".dylib")
-base.copy_file(current_dir + "/mac_arm64_install/lib/libicuuc." + icu_major + "." + icu_minor + ".dylib", current_dir + "/mac_arm64/build/libicuuc." + icu_major + ".dylib")
+base.copy_file(current_dir + "/mac_arm_64/lib/libicudata." + icu_major + "." + icu_minor + ".dylib", current_dir + "/mac_arm64/build/libicudata." + icu_major + ".dylib")
+base.copy_file(current_dir + "/mac_arm_64/lib/libicuuc." + icu_major + "." + icu_minor + ".dylib", current_dir + "/mac_arm64/build/libicuuc." + icu_major + ".dylib")
 # copy static libs
-base.copy_file(current_dir + "/mac_arm64_install/lib/libicudata.a", current_dir + "/mac_arm64/build")
-base.copy_file(current_dir + "/mac_arm64_install/lib/libicui18n.a", current_dir + "/mac_arm64/build")
-base.copy_file(current_dir + "/mac_arm64_install/lib/libicuuc.a", current_dir + "/mac_arm64/build")
+base.copy_file(current_dir + "/mac_arm_64/lib/libicudata.a", current_dir + "/mac_arm64/build")
+base.copy_file(current_dir + "/mac_arm_64/lib/libicui18n.a", current_dir + "/mac_arm64/build")
+base.copy_file(current_dir + "/mac_arm_64/lib/libicuuc.a", current_dir + "/mac_arm64/build")
 
 base.delete_dir(current_dir + "/mac_cross_64")
-base.delete_dir(current_dir + "/mac_64_install")
-base.delete_dir(current_dir + "/mac_arm64_install")
+base.delete_dir(current_dir + "/mac_arm_64")
 
 os.chdir(current_dir_old)

scripts/core_common/modules/iwork.py

@@ -22,7 +22,7 @@ def make(use_gperf = True):
   base_dir = base.get_script_dir() + "/../../core/Common/3dParty/apple"
   
   os.chdir(base_dir)
-  base.check_module_version("4", clear_module)
+  base.check_module_version("3", clear_module)
   os.chdir(old_cur_dir)
 
   cmd_args = ["fetch.py"]
@@ -35,5 +35,4 @@ def make(use_gperf = True):
 
 if __name__ == '__main__':
   # manual compile
-  make(False)
-
+  make(False)

scripts/core_common/modules/libvlc.py

@@ -5,15 +5,21 @@ sys.path.append('../..')
 import config
 import base
 import os
+import platform
 
-def docker_build(image_name, dockerfile_dir, base_dir):
-  base.cmd("docker", ["build", "-t", image_name, dockerfile_dir])
+VLC_UPSTREAM_VERSION = "3.0.21"
+VLC_PATCH_VERSION = "-1"
+
+VLC_VERSION = VLC_UPSTREAM_VERSION + VLC_PATCH_VERSION
+
+def docker_build(image_name, dockerfile_dir, base_dir, build_options=[]):
+  base.cmd("docker", ["build", "-t", image_name, dockerfile_dir] + build_options)
   vlc_dir = base_dir + "/vlc"
   base.cmd("docker", ["run", "--rm", "-v", vlc_dir + ":/vlc", image_name])
   base.cmd("docker", ["image", "rm", image_name])
   return
 
-def form_build_win(src_dir, dest_dir):
+def form_build_win(src_dir, dest_dir, run_plugins_cache_gen=True):
   if not base.is_dir(dest_dir):
     base.create_dir(dest_dir)
   # copy include dir
@@ -26,8 +32,9 @@ def form_build_win(src_dir, dest_dir):
   base.copy_file(src_dir + "/libvlc.dll", dest_dir + "/lib")
   base.copy_file(src_dir + "/libvlccore.dll", dest_dir + "/lib")
   base.copy_file(src_dir + "/vlc-cache-gen.exe", dest_dir + "/lib")
-  # generate cache file 'plugins.dat' for plugins loading
-  base.cmd_exe(dest_dir + "/lib/vlc-cache-gen", [dest_dir + "/lib/plugins"])
+  if run_plugins_cache_gen and "windows" == base.host_platform():
+    # generate cache file 'plugins.dat' for plugins loading
+    base.cmd_exe(dest_dir + "/lib/vlc-cache-gen", [dest_dir + "/lib/plugins"])
   return
 
 def form_build_linux(src_dir, dest_dir):
@@ -54,13 +61,18 @@ def form_build_mac(src_dir, dest_dir):
   base.run_command("DYLD_LIBRARY_PATH=" + dest_dir + "/lib " + dest_dir + "/lib/vlc/vlc-cache-gen " + dest_dir + "/lib/vlc/plugins")
   return
 
+def is_host_arm():
+  machine = platform.machine().lower()
+  if "arm" in machine or "aarch" in machine:
+    return True
+  return False
+
 def make():
 
   print("[fetch & build]: libvlc")
 
   base_dir = base.get_script_dir() + "/../../core/Common/3dParty/libvlc"
   vlc_dir = base_dir + "/vlc"
-  vlc_version = "3.0.18"
 
   tools_dir = base.get_script_dir() + "/../tools"
   old_cur = os.getcwd()
@@ -71,7 +83,7 @@ def make():
     if "windows" == base.host_platform():
       autocrlf_old = base.run_command("git config --global core.autocrlf")['stdout']
       base.cmd("git", ["config", "--global", "core.autocrlf", "false"])
-    base.cmd("git", ["clone", "https://code.videolan.org/videolan/vlc.git", "--branch", vlc_version])
+    base.cmd("git", ["clone", "https://code.videolan.org/videolan/vlc.git", "--branch", VLC_VERSION])
     if "windows" == base.host_platform():
       base.cmd("git", ["config", "--global", "core.autocrlf", autocrlf_old])
 
@@ -79,46 +91,61 @@ def make():
   base.copy_file("tools/ignore-cache-time.patch", "vlc")
 
   # windows
-  if "windows" == base.host_platform():
-    if config.check_option("platform", "win_64"):
-      base.copy_file("tools/win_64/build.patch", "vlc")
-      docker_build("libvlc-win64", base_dir + "/tools/win_64", base_dir)
-      form_build_win(vlc_dir + "/build/win64/vlc-" + vlc_version, base_dir + "/build/win_64")
+  if config.check_option("platform", "win_64"):
+    base.copy_file("tools/win_32/build-win.patch", "vlc")
+    docker_build("libvlc-win64", base_dir + "/tools/win_64", base_dir)
+    form_build_win(vlc_dir + "/build/win64/vlc-" + VLC_UPSTREAM_VERSION, base_dir + "/build/win_64")
 
-    if config.check_option("platform", "win_32"):
-      base.copy_file("tools/win_32/build.patch", "vlc")
-      docker_build("libvlc-win32", base_dir + "/tools/win_32", base_dir)
-      form_build_win(vlc_dir + "/build/win32/vlc-" + vlc_version, base_dir + "/build/win_32")
+  if config.check_option("platform", "win_32"):
+    base.copy_file("tools/win_32/build-win.patch", "vlc")
+    docker_build("libvlc-win32", base_dir + "/tools/win_32", base_dir)
+    form_build_win(vlc_dir + "/build/win32/vlc-" + VLC_UPSTREAM_VERSION, base_dir + "/build/win_32")
+
+  if config.check_option("platform", "win_arm64"):
+    base.copy_file("tools/win_32/build-win.patch", "vlc")
+    base.copy_file("tools/win_arm64/contrib-vpx.patch", "vlc")
+    base.copy_file("tools/win_arm64/contrib-ffmpeg.patch", "vlc")
+    base.copy_file("tools/win_arm64/disable-npapi.patch", "vlc")
+    docker_build("libvlc-winarm64", base_dir + "/tools/win_arm64", base_dir)
+    form_build_win(vlc_dir + "/build/winarm64-ucrt/vlc-" + VLC_UPSTREAM_VERSION, base_dir + "/build/win_arm64", False)
 
   # linux
   if config.check_option("platform", "linux_64"):
     base.copy_file(tools_dir + "/linux/elf/patchelf", "vlc")
     base.copy_file("tools/linux_64/change-rpaths.sh", "vlc")
-    docker_build("libvlc-linux64", base_dir + "/tools/linux_64", base_dir)
+    docker_build("libvlc-linux64", base_dir + "/tools/linux_64", base_dir, ["--platform", "linux/amd64"])
     form_build_linux(vlc_dir + "/build/linux_64", base_dir + "/build/linux_64")
 
-  # mac
-  if "mac" == base.host_platform():
-    os.chdir(vlc_dir)
+  # NOTE: building for linux_arm64 is only possible on arm machines
+  if is_host_arm():
+    if config.check_option("platform", "linux_arm64"):
+      base.copy_file(tools_dir + "/linux/elf/patchelf", "vlc")
+      base.copy_file("tools/linux_64/change-rpaths.sh", "vlc")
+      docker_build("libvlc-linux-arm64", base_dir + "/tools/linux_arm64", base_dir)
+      form_build_linux(vlc_dir + "/build/linux_arm64", base_dir + "/build/linux_arm64")
 
-    base.cmd("git", ["restore", "src/modules/bank.c"])
-    base.cmd("patch", ["-p1", "src/modules/bank.c", "../tools/ignore-cache-time.patch"])
+  # # mac
+  # if "mac" == base.host_platform():
+  #   os.chdir(vlc_dir)
 
-    if config.check_option("platform", "mac_64"):
-      base.cmd("git", ["restore", "extras/package/macosx/build.sh"])
-      base.cmd("patch", ["-p1", "extras/package/macosx/build.sh", "../tools/mac_64/build.patch"])
-      base.create_dir("build/mac_64")
-      os.chdir("build/mac_64")
-      base.cmd("../../extras/package/macosx/build.sh", ["-c"])
-      form_build_mac(vlc_dir + "/build/mac_64/vlc_install_dir", base_dir + "/build/mac_64")
+  #   base.cmd("git", ["restore", "src/modules/bank.c"])
+  #   base.cmd("patch", ["-p1", "src/modules/bank.c", "../tools/ignore-cache-time.patch"])
 
-    if config.check_option("platform", "mac_arm64"):
-      base.cmd("git", ["restore", "extras/package/macosx/build.sh"])
-      base.cmd("patch", ["-p1", "extras/package/macosx/build.sh", "../tools/mac_arm64/build.patch"])
-      base.create_dir("build/mac_arm64")
-      os.chdir("build/mac_arm64")
-      base.cmd("../../extras/package/macosx/build.sh", ["-c"])
-      form_build_mac(vlc_dir + "/build/mac_arm64/vlc_install_dir", base_dir + "/build/mac_arm64")
+  #   if config.check_option("platform", "mac_64"):
+  #     base.cmd("git", ["restore", "extras/package/macosx/build.sh"])
+  #     base.cmd("patch", ["-p1", "extras/package/macosx/build.sh", "../tools/mac_64/build.patch"])
+  #     base.create_dir("build/mac_64")
+  #     os.chdir("build/mac_64")
+  #     base.cmd("../../extras/package/macosx/build.sh", ["-c"])
+  #     form_build_mac(vlc_dir + "/build/mac_64/vlc_install_dir", base_dir + "/build/mac_64")
+
+  #   if config.check_option("platform", "mac_arm64"):
+  #     base.cmd("git", ["restore", "extras/package/macosx/build.sh"])
+  #     base.cmd("patch", ["-p1", "extras/package/macosx/build.sh", "../tools/mac_arm64/build.patch"])
+  #     base.create_dir("build/mac_arm64")
+  #     os.chdir("build/mac_arm64")
+  #     base.cmd("../../extras/package/macosx/build.sh", ["-c"])
+  #     form_build_mac(vlc_dir + "/build/mac_arm64/vlc_install_dir", base_dir + "/build/mac_arm64")
 
   os.chdir(old_cur)
   return

scripts/core_common/modules/openssl.py

@@ -87,7 +87,9 @@ def make():
     # -------------------------------------------------------------------------------------------------------
     return
 
-  if (-1 != config.option("platform").find("linux")) and not base.is_dir("../build/linux_64"):     
+  if (-1 != config.option("platform").find("linux")) and not base.is_dir("../build/linux_64"):
+    ld_library_path_copy = ''
+
     base.cmd("./config", ["enable-md2", "no-shared", "no-asm", "--prefix=" + old_cur_dir + "/build/linux_64", "--openssldir=" + old_cur_dir + "/build/linux_64"])
     if "1" == config.option("use-clang"):
       base.replaceInFile("./Makefile", "CC=$(CROSS_COMPILE)gcc", "CC=$(CROSS_COMPILE)clang")
@@ -95,39 +97,41 @@ def make():
       base.replaceInFile("./Makefile", "CFLAGS=-Wall -O3", "CFLAGS=-Wall -O3 -fvisibility=hidden")
       base.replaceInFile("./Makefile", "CXXFLAGS=-Wall -O3", "CXXFLAGS=-Wall -O3 -fvisibility=hidden -stdlib=libc++")
       base.replaceInFile("./Makefile", "LDFLAGS=", "LDFLAGS=-stdlib=libc++")
-    elif config.option("sysroot") == "":
+    elif config.option("custom-sysroot") == "":
       base.replaceInFile("./Makefile", "CFLAGS=-Wall -O3", "CFLAGS=-Wall -O3 -fvisibility=hidden")
       base.replaceInFile("./Makefile", "CXXFLAGS=-Wall -O3", "CXXFLAGS=-Wall -O3 -fvisibility=hidden")
     else:
-      base.replaceInFile("./Makefile", "CROSS_COMPILE=", "CROSS_COMPILE=" + config.get_custom_sysroot_bin("linux_64") + "/")
-      base.replaceInFile("./Makefile", "CFLAGS=-Wall -O3", "CFLAGS=-Wall -O3 -fvisibility=hidden --sysroot=" + config.option("sysroot_linux_64"))
-      base.replaceInFile("./Makefile", "CXXFLAGS=-Wall -O3", "CXXFLAGS=-Wall -O3 -fvisibility=hidden --sysroot=" + config.option("sysroot_linux_64"))
+      if 'LD_LIBRARY_PATH' in os.environ:
+        ld_library_path_copy = os.environ['LD_LIBRARY_PATH']
+      os.environ['LD_LIBRARY_PATH'] = config.get_custom_sysroot_lib()
+      base.replaceInFile("./Makefile", "CROSS_COMPILE=", "CROSS_COMPILE=" + config.get_custom_sysroot_bin() + "/")
+      base.replaceInFile("./Makefile", "CFLAGS=-Wall -O3", "CFLAGS=-Wall -O3 -fvisibility=hidden --sysroot=" + config.option("custom-sysroot"),)
+      base.replaceInFile("./Makefile", "CXXFLAGS=-Wall -O3", "CXXFLAGS=-Wall -O3 -fvisibility=hidden --sysroot=" + config.option("custom-sysroot"))
 
-    if config.option("sysroot") == "":
+    if config.option("custom-sysroot") == "":
       base.cmd("make", [])
       base.cmd("make", ["install"])
       base.cmd("make", ["clean"], True)
     else:
-      base.set_sysroot_env("linux_64")
       base.cmd_exe("make", [])
       base.cmd_exe("make", ["install"])
       base.cmd_exe("make", ["clean"], True)
-      base.restore_sysroot_env()
+      os.environ['LD_LIBRARY_PATH'] = ld_library_path_copy
+    # TODO: support x86
 
   if (-1 != config.option("platform").find("linux_arm64")) and not base.is_dir("../build/linux_arm64"):
-    if (base.is_os_arm()):
+    if ("x86_64" != platform.machine()):
       base.copy_dir("../build/linux_64", "../build/linux_arm64")
     else:
-      if config.option("sysroot") != "":
-        base.set_sysroot_env("linux_arm64")
-      base.cmd("/usr/bin/perl", ["./Configure", "linux-aarch64", "enable-md2", "no-shared", "no-asm", "no-tests", "--prefix=" + old_cur_dir + "/build/linux_arm64", "--openssldir=" + old_cur_dir + "/build/linux_arm64"])
-      #base.cmd("./Configure", ["linux-aarch64", "enable-md2", "no-shared", "no-asm", "no-tests", "--prefix=" + old_cur_dir + "/build/linux_arm64", "--openssldir=" + old_cur_dir + "/build/linux_arm64"])
+      cross_compiler_arm64 = config.option("arm64-toolchain-bin")
+      if ("" == cross_compiler_arm64):
+        cross_compiler_arm64 = "/usr/bin"
+      cross_compiler_arm64_prefix = cross_compiler_arm64 + "/" + base.get_prefix_cross_compiler_arm64()
+      base.cmd("./Configure", ["linux-aarch64", "--cross-compile-prefix=" + cross_compiler_arm64_prefix, "enable-md2", "no-shared", "no-asm", "no-tests", "--prefix=" + old_cur_dir + "/build/linux_arm64", "--openssldir=" + old_cur_dir + "/build/linux_arm64"])
       base.replaceInFile("./Makefile", "CFLAGS=-Wall -O3", "CFLAGS=-Wall -O3 -fvisibility=hidden")
       base.replaceInFile("./Makefile", "CXXFLAGS=-Wall -O3", "CXXFLAGS=-Wall -O3 -fvisibility=hidden")
       base.cmd("make", [], True)
       base.cmd("make", ["install"], True)
-      if config.option("sysroot") != "":
-        base.restore_sysroot_env()
 
   if (-1 != config.option("platform").find("mac")) and not base.is_dir("../build/mac_64"):
     base.cmd("./Configure", ["enable-md2", "no-shared", "no-asm", "darwin64-x86_64-cc", "--prefix=" + old_cur_dir + "/build/mac_64", "--openssldir=" + old_cur_dir + "/build/mac_64", "-mmacosx-version-min=10.11"])

scripts/core_common/modules/socket_io.py

@@ -8,11 +8,6 @@ import os
 import subprocess
 import glob
 
-def clean():
-  if base.is_dir("socket.io-client-cpp"):
-    base.delete_dir_with_access_error("socket.io-client-cpp")
-  return
-
 def correct_namespace(dir):
   folder = dir
   if ("/" != folder[-1:]):
@@ -30,12 +25,6 @@ def correct_namespace(dir):
 
 def make():
   base_dir = base.get_script_dir() + "/../../core/Common/3dParty/socketio"
-
-  old_cur = os.getcwd()
-  os.chdir(base_dir)
-  base.common_check_version("socketio", "2", clean)
-  os.chdir(old_cur)
-
   if not base.is_dir(base_dir + "/socket.io-client-cpp"):
     base.cmd_in_dir(base_dir, "git", ["clone", "https://github.com/socketio/socket.io-client-cpp.git"])
     base.cmd_in_dir(base_dir + "/socket.io-client-cpp", "git", ["checkout", "da779141a7379cc30c870d48295033bc16a23c66"])
@@ -48,7 +37,6 @@ def make():
     base.apply_patch(base_dir + "/socket.io-client-cpp/src/internal/sio_client_impl.cpp", base_dir + "/patches/sio_client_impl_fail.patch")
     base.apply_patch(base_dir + "/socket.io-client-cpp/src/internal/sio_client_impl.cpp", base_dir + "/patches/sio_client_impl_open.patch")
     base.apply_patch(base_dir + "/socket.io-client-cpp/src/internal/sio_client_impl.cpp", base_dir + "/patches/sio_client_impl_close_timeout.patch")
-    base.apply_patch(base_dir + "/socket.io-client-cpp/src/internal/sio_client_impl.cpp", base_dir + "/patches/sio_client_impl_encode.patch")
 
     # no tls realization (remove if socket.io fix this)
     dst_dir = base_dir + "/socket.io-client-cpp/src_no_tls"

scripts/core_common/modules/v8.py

@@ -44,9 +44,14 @@ def is_xp_platform():
   return False
 
 def is_use_clang():
-  if config.option("sysroot") == "" and "1" == config.option("use-clang"):
-    return "true"
-  return "false"
+  gcc_version = base.get_gcc_version()  
+    
+  is_clang = "false"
+  if config.option("custom-sysroot") == "" and (gcc_version >= 6000 or "1" == config.option("use-clang")):
+    is_clang = "true"
+
+  print("gcc version: " + str(gcc_version) + ", use clang:" + is_clang)
+  return is_clang
 
 def make():
   if not is_main_platform():
@@ -230,7 +235,8 @@ def make_xp():
         base.replaceInFile("depot_tools/cipd.ps1", "windows-386", "windows-amd64")
   
   # old variant
-  path_to_python2 = "/depot_tools/bootstrap-2@3_11_8_chromium_35_bin/python/bin"
+  #path_to_python2 = "/depot_tools/win_tools-2_7_13_chromium7_bin/python/bin"
+  path_to_python2 = "/depot_tools/bootstrap-2@3_8_10_chromium_23_bin/python/bin"
   os.environ["PATH"] = os.pathsep.join([base_dir + "/depot_tools", 
     base_dir + path_to_python2, 
     config.option("vs-path") + "/../Common7/IDE",

scripts/core_common/modules/v8_89.py

@@ -7,25 +7,6 @@ import base
 import os
 import subprocess
 
-def clean():
-  if base.is_dir("depot_tools"):
-    base.delete_dir_with_access_error("depot_tools")
-    base.delete_dir("depot_tools")
-  if base.is_dir("v8"):
-    base.delete_dir_with_access_error("v8")
-    base.delete_dir("v8")
-  if base.is_exist("./.gclient"):
-    base.delete_file("./.gclient")
-  if base.is_exist("./.gclient_entries"):
-    base.delete_file("./.gclient_entries")
-  if base.is_exist("./.gclient_previous_sync_commits"):
-    base.delete_file("./.gclient_previous_sync_commits")
-  if base.is_exist("./.gcs_entries"):
-    base.delete_file("./.gcs_entries")
-  if base.is_exist("./.cipd"):
-    base.delete_dir("./.cipd")
-  return
-
 def change_bootstrap():
   base.move_file("./depot_tools/bootstrap/manifest.txt", "./depot_tools/bootstrap/manifest.txt.bak")
   content = "# changed by build_tools\n\n"
@@ -35,11 +16,7 @@ def change_bootstrap():
   content += "infra/3pp/tools/cpython/${platform} version:2@2.7.18.chromium.39\n\n"
 
   content += "@Subdir python3\n"
-
-  if ("windows" == base.host_platform()):
-    content += "infra/3pp/tools/cpython3/${platform} version:2@3.11.8.chromium.35\n\n"
-  else:
-    content += "infra/3pp/tools/cpython3/${platform} version:2@3.8.10.chromium.23\n\n"
+  content += "infra/3pp/tools/cpython3/${platform} version:2@3.8.10.chromium.23\n\n"
 
   content += "@Subdir git\n"
   content += "infra/3pp/tools/git/${platform} version:2@2.41.0.chromium.11\n"
@@ -53,31 +30,6 @@ def change_bootstrap():
   base.writeFile("./depot_tools/bootstrap/manifest.txt", content)
   return
 
-def is_ubuntu_24_or_higher():
-  try:
-    with open('/etc/os-release') as f:
-      for line in f:
-        if line.startswith('VERSION_ID='):
-          version = line.split('=')[1].strip().strip('"')
-          return float(version) >= 24
-  except:
-      pass
-  return False
-
-def fix_ubuntu24():
-  #if not is_ubuntu_24_or_higher():
-  #  return
-
-  if "" == config.option("sysroot"):
-    return
-
-  old_cur = os.getcwd()
-  os.chdir("third_party/llvm-build/Release+Asserts/lib")
-  base.cmd("mv", ["libstdc++.so.6", "libstdc++.so.6.old"])
-  base.cmd("ln", ["-s", "/usr/lib/x86_64-linux-gnu/libstdc++.so.6", "libstdc++.so.6"])
-  os.chdir(old_cur)
-  return
-
 def make_args(args, platform, is_64=True, is_debug=False):
   args_copy = args[:]
   if is_64:
@@ -91,6 +43,7 @@ def make_args(args, platform, is_64=True, is_debug=False):
     args_copy = args[:]
     args_copy.append("target_cpu=\\\"arm64\\\"")
     args_copy.append("v8_target_cpu=\\\"arm64\\\"")
+    args_copy.append("use_sysroot=true")
     
   if (platform == "win_arm64"):
     args_copy = args[:]
@@ -107,27 +60,9 @@ def make_args(args, platform, is_64=True, is_debug=False):
   
   linux_clang = False
   if platform == "linux":
-    if "" != config.option("sysroot"):
-      args_copy.append("use_sysroot=true")
+    if "" != config.option("custom-sysroot"):
+      args_copy.append("use_sysroot=false")
       args_copy.append("is_clang=false")
-      if is_ubuntu_24_or_higher():
-        args_copy.append("use_gold=false")
-      args_copy.append("sysroot=\\\"" + config.option("sysroot_linux_64") + "\\\"")
-      args_copy.append("target_sysroot=\\\"" + config.option("sysroot_linux_64") + "\\\"")
-    else:
-      args_copy.append("is_clang=true")
-      if "1" == config.option("use-clang"):
-        linux_clang = True
-      else:
-        args_copy.append("use_sysroot=false")
-
-  if platform == "linux_arm64":
-    if "" != config.option("sysroot"):
-      args_copy.append("use_sysroot=true")
-      if is_ubuntu_24_or_higher():
-        args_copy.append("use_gold=false")
-      #args_copy.append("sysroot=\\\"" + config.option("sysroot_linux_64") + "\\\"")
-      args_copy.append("target_sysroot=\\\"" + config.option("sysroot_linux_arm64") + "\\\"")
     else:
       args_copy.append("is_clang=true")
       if "1" == config.option("use-clang"):
@@ -139,9 +74,6 @@ def make_args(args, platform, is_64=True, is_debug=False):
   if (platform == "windows"):
     args_copy.append("is_clang=false")
 
-  if (platform == "mac") and base.is_os_arm():
-    args_copy.append("host_cpu=\\\"x64\\\"")
-
   if linux_clang != True:
     args_copy.append("use_custom_libcxx=false")
 
@@ -214,8 +146,6 @@ def make():
     base.cmd("git", ["config", "--global", "http.postBuffer", "157286400"], True)
 
   os.chdir(base_dir)
-  base.common_check_version("v8", "1", clean)
-    
   if not base.is_dir("depot_tools"):
     base.cmd("git", ["clone", "https://chromium.googlesource.com/chromium/tools/depot_tools.git"])
     change_bootstrap()
@@ -239,9 +169,6 @@ def make():
     base.cmd("./depot_tools/gclient", ["sync", "-r", v8_branch_version], True)
     base.cmd("gclient", ["sync", "--force"], True)
     base.copy_dir("./v8/third_party_new/ninja", "./v8/third_party/ninja")
-    if ("linux" == base.host_platform()):
-      if not base.is_file("./depot_tools/python3_bin_reldir.txt"):
-        base.cmd_in_dir("./depot_tools", "./ensure_bootstrap", [], True)
 
   if ("windows" == base.host_platform()):
     base.replaceInFile("v8/build/config/win/BUILD.gn", ":static_crt", ":dynamic_crt")
@@ -271,9 +198,6 @@ def make():
     base.replaceInFile("v8/third_party/jinja2/tests.py", "from collections import Mapping", "try:\n    from collections.abc import Mapping\nexcept ImportError:\n    from collections import Mapping")
 
   os.chdir("v8")
-
-  is_ubuntu24 = is_ubuntu_24_or_higher()
-  fix_ubuntu24()
   
   gn_args = ["v8_static_library=true",
              "is_component_build=false",
@@ -282,24 +206,23 @@ def make():
              "treat_warnings_as_errors=false"]
 
   if config.check_option("platform", "linux_64"):
-    if config.option("sysroot") != "":
-      sysroot_path = config.option("sysroot_linux_64")
-      sysroot_path_bin = config.get_custom_sysroot_bin("linux_64")
+    ld_library_path_copy = ''
+    if config.option("custom-sysroot") != "":
+      if 'LD_LIBRARY_PATH' in os.environ:
+        ld_library_path_copy = os.environ['LD_LIBRARY_PATH']
+      os.environ['LD_LIBRARY_PATH'] = config.get_custom_sysroot_lib()
 
-      old_env = dict(os.environ)
-      base.set_sysroot_env("linux_64")
+      src_replace = "config(\"compiler\") {\n  asmflags = []\n  cflags = []\n  cflags_c = []\n  cflags_cc = []\n  cflags_objc = []\n  cflags_objcc = []\n  ldflags = []"
+      dst_replace = "config(\"compiler\") {\n  asmflags = []\n  cflags = [\"--sysroot=" + config.option("custom-sysroot") + "\"]" + "\n  cflags_c = []\n  cflags_cc = [\"--sysroot=" + config.option("custom-sysroot") + "\"]" + "\n  cflags_objc = []\n  cflags_objcc = []\n  ldflags = [\"--sysroot=" + config.option("custom-sysroot") + "\"]"
+      base.replaceInFile("build/config/compiler/BUILD.gn", src_replace, dst_replace)
 
-      pkg_old = os.environ.get("PKG_CONFIG_PATH", "")
-      os.environ["PKG_CONFIG_PATH"] = sysroot_path + "/usr/lib/x86_64-linux-gnu/pkgconfig:" + sysroot_path + "/usr/lib/pkgconfig:" + sysroot_path + "/usr/share/pkgconfig"
-      base.cmd2("gn", ["gen", "out.gn/linux_64", make_args(gn_args, "linux")], False)
-      os.environ["PKG_CONFIG_PATH"] = pkg_old
-
-      base.cmd2("ninja", ["-C", "out.gn/linux_64"], False)
-      base.restore_sysroot_env()
-    else:
-      base.cmd2("gn", ["gen", "out.gn/linux_64", make_args(gn_args, "linux")], False)
-      base.cmd2("ninja", ["-C", "out.gn/linux_64"], False)
+      src_replace = "gcc_toolchain(\"x64\") {\n  cc = \"gcc\"\n  cxx = \"g++\""
+      dst_replace = "gcc_toolchain(\"x64\") {\n  cc = \""+ config.get_custom_sysroot_bin() + "/gcc\"\n  cxx = \"" + config.get_custom_sysroot_bin() + "/g++\""
+      base.replaceInFile("build/toolchain/linux/BUILD.gn", src_replace, dst_replace)
 
+    base.cmd2("gn", ["gen", "out.gn/linux_64", make_args(gn_args, "linux")], False)
+    base.cmd2("ninja", ["-C", "out.gn/linux_64"], False)
+    os.environ['LD_LIBRARY_PATH'] = ld_library_path_copy
 
   if config.check_option("platform", "linux_32"):
     base.cmd2("gn", ["gen", "out.gn/linux_32", make_args(gn_args, "linux", False)])
@@ -307,13 +230,7 @@ def make():
 
   if config.check_option("platform", "linux_arm64"):
     base.cmd("build/linux/sysroot_scripts/install-sysroot.py", ["--arch=arm64"], False)
-    
-    sysroot_path = config.option("sysroot_linux_64")
-    pkg_old = os.environ.get("PKG_CONFIG_PATH", "")
-    os.environ["PKG_CONFIG_PATH"] = sysroot_path + "/usr/lib/x86_64-linux-gnu/pkgconfig:" + sysroot_path + "/usr/lib/pkgconfig:" + sysroot_path + "/usr/share/pkgconfig"
     base.cmd2("gn", ["gen", "out.gn/linux_arm64", make_args(gn_args, "linux_arm64", False)])
-    os.environ["PKG_CONFIG_PATH"] = pkg_old
-
     base.cmd("ninja", ["-C", "out.gn/linux_arm64"])
 
   if config.check_option("platform", "mac_64"):

scripts/deploy.py

@@ -22,6 +22,4 @@ def make():
     deploy_mobile.make()
   if config.check_option("module", "osign"):
     deploy_osign.make()
-  if base.is_use_create_artifacts_qemu_any_platform():
-    base.create_artifacts_qemu_any_platform()
   return

scripts/deploy_builder.py

@@ -47,8 +47,6 @@ def make():
     base.copy_lib(core_build_dir + "/lib/" + platform_postfix, root_dir, "IWorkFile")
     base.copy_lib(core_build_dir + "/lib/" + platform_postfix, root_dir, "HWPFile")
     base.copy_lib(core_build_dir + "/lib/" + platform_postfix, root_dir, "DocxRenderer")
-    base.copy_lib(core_build_dir + "/lib/" + platform_postfix, root_dir, "StarMathConverter")
-    base.copy_lib(core_build_dir + "/lib/" + platform_postfix, root_dir, "ooxmlsignature", "xp" if isWindowsXP else "")
     base.copy_file(git_dir + "/sdkjs/pdf/src/engine/cmap.bin", root_dir + "/cmap.bin")
 
     if ("ios" == platform):
@@ -60,7 +58,7 @@ def make():
     #  base.generate_check_linux_system(git_dir + "/build_tools", root_dir)
 
     # icu
-    base.deploy_icu(core_dir, root_dir, native_platform)
+    base.deploy_icu(core_dir, root_dir, platform)
 
     # doctrenderer
     if isWindowsXP:
@@ -110,13 +108,13 @@ def make():
 
     # correct ios frameworks
     if ("ios" == platform):
-      base.for_each_framework(root_dir, "ios", callbacks=[base.generate_plist, base.generate_xcprivacy])
+      base.generate_plist(root_dir, "ios")
 
     if (0 == platform.find("linux")):
       base.linux_correct_rpath_docbuilder(root_dir)
 
     if (0 == platform.find("mac")):
-      base.for_each_framework(root_dir, "mac", callbacks=[base.generate_plist], max_depth=1)
+      base.generate_plist(root_dir, "mac", max_depth=1)
       base.mac_correct_rpath_x2t(root_dir)
       base.mac_correct_rpath_docbuilder(root_dir)
 
@@ -129,6 +127,11 @@ def make():
     base.copy_dir(git_dir  + "/core-fonts/openoffice", root_dir + "/fonts/openoffice")
     base.copy_file(git_dir + "/core-fonts/ASC.ttf",    root_dir + "/fonts/ASC.ttf")
 
+    if native_platform == "win_arm64":
+      base.delete_dir(root_dir + "/sdkjs")
+      base.copy_dir(root_dir_win64 + "/sdkjs", root_dir + "/sdkjs")
+      return
+
     # delete unnecessary builder files
     def delete_files(files):
       for file in files:

scripts/deploy_core.py

@@ -25,7 +25,6 @@ def make():
 
     platform = native_platform
     platform_postfix = platform + base.qt_dst_postfix()
-    isWindowsXP = False if (-1 == native_platform.find("_xp")) else True
 
     base.copy_lib(core_build_dir + "/lib/" + platform_postfix, archive_dir, "kernel")
     base.copy_lib(core_build_dir + "/lib/" + platform_postfix, archive_dir, "kernel_network")
@@ -43,8 +42,6 @@ def make():
     base.copy_lib(core_build_dir + "/lib/" + platform_postfix, archive_dir, "HWPFile")
     base.copy_lib(core_build_dir + "/lib/" + platform_postfix, archive_dir, "DocxRenderer")
     base.copy_lib(core_build_dir + "/lib/" + platform_postfix, archive_dir, "hunspell")
-    base.copy_lib(core_build_dir + "/lib/" + platform_postfix, archive_dir, "StarMathConverter")
-    base.copy_lib(core_build_dir + "/lib/" + platform_postfix, archive_dir, "ooxmlsignature", "xp" if isWindowsXP else "")
     base.copy_file(git_dir + "/sdkjs/pdf/src/engine/cmap.bin", archive_dir + "/cmap.bin")
     base.copy_exe(core_build_dir + "/bin/" + platform_postfix, archive_dir, "x2t")
 
@@ -72,13 +69,17 @@ def make():
 
     # correct mac frameworks
     if (0 == platform.find("mac")):
-      base.for_each_framework(archive_dir, "mac", callbacks=[base.generate_plist], max_depth=1)
-      base.mac_correct_rpath_x2t(archive_dir)
+      base.generate_plist(archive_dir, "mac", max_depth=1)
 
     # js cache
     base.generate_doctrenderer_config(archive_dir + "/DoctRenderer.config", "./", "builder", "", "./dictionaries")
     base.create_x2t_js_cache(archive_dir, "core", platform)
     base.delete_file(archive_dir + "/DoctRenderer.config")
+    
+    # just copy sdkjs to avoid executing arm64 x2t on non-arm system
+    if native_platform == "win_arm64" :
+      base.delete_dir(archive_dir + "/sdkjs")
+      base.copy_dir(archive_dir + "/../../../win_64/" + branding + "/core/sdkjs", archive_dir + "/sdkjs")
 
     # dictionaries
     base.copy_dictionaries(git_dir + "/dictionaries", archive_dir + "/dictionaries", True, False)

scripts/deploy_desktop.py

@@ -72,8 +72,6 @@ def make():
     base.copy_lib(build_libraries_path, root_dir + "/converter", "IWorkFile")
     base.copy_lib(build_libraries_path, root_dir + "/converter", "HWPFile")
     base.copy_lib(build_libraries_path, root_dir + "/converter", "DocxRenderer")
-    base.copy_lib(build_libraries_path, root_dir + "/converter", "StarMathConverter")
-    base.copy_lib(build_libraries_path, root_dir + "/converter", "ooxmlsignature", "xp" if isWindowsXP else "")
 
     if ("ios" == platform):
       base.copy_lib(build_libraries_path, root_dir + "/converter", "x2t")
@@ -84,7 +82,7 @@ def make():
     #  base.generate_check_linux_system(git_dir + "/build_tools", root_dir + "/converter")
 
     # icu
-    base.deploy_icu(core_dir, root_dir + "/converter", native_platform)
+    base.deploy_icu(core_dir, root_dir + "/converter", platform)
 
     # doctrenderer
     if isWindowsXP:
@@ -119,26 +117,13 @@ def make():
     else:
       base.copy_files(core_dir + "/Common/3dParty/cef/" + native_platform + "/" + build_dir_name + "/*", root_dir)
 
-    if (0 == platform.find("mac")):
-      dir_base_old = os.getcwd()
-      os.chdir(root_dir + "/Chromium Embedded Framework.framework")
-      base.create_dir("Versions")
-      base.create_dir("Versions/A")
-      base.move_file("Chromium Embedded Framework", "Versions/A/Chromium Embedded Framework")
-      base.move_dir("Resources", "Versions/A/Resources")
-      base.move_dir("Libraries", "Versions/A/Libraries")
-      base.cmd("ln", ["-s", "Versions/A/Chromium Embedded Framework", "Chromium Embedded Framework"])
-      base.cmd("ln", ["-s", "Versions/A/Resources", "Resources"])
-      base.cmd("ln", ["-s", "Versions/A/Libraries", "Libraries"])
-      base.cmd("ln", ["-s", "A", "Versions/Current"])
-      os.chdir(dir_base_old);
-
     isUseQt = True
     if (0 == platform.find("mac")) or (0 == platform.find("ios")):
       isUseQt = False
 
     # libraries
     base.copy_lib(build_libraries_path, root_dir, "hunspell")
+    base.copy_lib(build_libraries_path + ("/xp" if isWindowsXP else ""), root_dir, "ooxmlsignature")
     base.copy_lib(build_libraries_path + ("/xp" if isWindowsXP else ""), root_dir, "ascdocumentscore")
     if (0 != platform.find("mac")):
       base.copy_lib(build_libraries_path + ("/xp" if isWindowsXP else ""), root_dir, "qtascdocumentscore")
@@ -179,7 +164,7 @@ def make():
         base.qt_copy_lib("Qt5DBus", root_dir)
         base.qt_copy_lib("Qt5X11Extras", root_dir)
         base.qt_copy_lib("Qt5XcbQpa", root_dir)
-        base.qt_copy_icu(root_dir, platform)
+        base.qt_copy_icu(root_dir)
         if not base.check_congig_option_with_platfom(platform, "libvlc"):
           base.copy_files(base.get_env("QT_DEPLOY") + "/../lib/libqgsttools_p.so*", root_dir)
 
@@ -187,6 +172,8 @@ def make():
         base.copy_file(git_dir + "/desktop-apps/win-linux/extras/projicons/" + apps_postfix + "/projicons.exe", root_dir + "/DesktopEditors.exe")
         if not isWindowsXP:
           base.copy_file(git_dir + "/desktop-apps/win-linux/extras/update-daemon/" + apps_postfix + "/updatesvc.exe", root_dir + "/updatesvc.exe")
+        else:
+          base.copy_file(git_dir + "/desktop-apps/win-linux/extras/online-installer/" + apps_postfix + "/online-installer.exe", root_dir + "/online-installer.exe")
         base.copy_file(git_dir + "/desktop-apps/win-linux/" + apps_postfix + "/DesktopEditors.exe", root_dir + "/editors.exe")
         base.copy_file(git_dir + "/desktop-apps/win-linux/res/icons/desktopeditors.ico", root_dir + "/app.ico")
       elif (0 == platform.find("linux")):
@@ -243,21 +230,6 @@ def make():
     #base.copy_dir(git_dir + "/desktop-sdk/ChromiumBasedEditors/plugins/encrypt/ui/engine/database/{9AB4BBA8-A7E5-48D5-B683-ECE76A020BB1}", root_dir + "/editors/sdkjs-plugins/{9AB4BBA8-A7E5-48D5-B683-ECE76A020BB1}")
     base.copy_sdkjs_plugin(git_dir + "/desktop-sdk/ChromiumBasedEditors/plugins", root_dir + "/editors/sdkjs-plugins", "sendto", True)
 
-    isUseAgent = True
-    if isWindowsXP:
-      isUseAgent = False
-    if (0 == platform.find("mac")) and (config.check_option("config", "use_v8")):
-      isUseAgent = False
-
-    if (isUseAgent):
-      agent_plugin_dir = git_dir + "/desktop-sdk/ChromiumBasedEditors/plugins/ai-agent"
-      if (False):
-        base.cmd_in_dir(agent_plugin_dir, "npm", ["install"], True)
-        base.cmd_in_dir(agent_plugin_dir, "npm", ["run", "build"], True)
-        base.copy_dir(agent_plugin_dir + "/{9DC93CDB-B576-4F0C-B55E-FCC9C48DD777}", root_dir + "/editors/sdkjs-plugins/{9DC93CDB-B576-4F0C-B55E-FCC9C48DD777}")
-      else:
-        base.copy_dir(agent_plugin_dir + "/deploy/{9DC93CDB-B576-4F0C-B55E-FCC9C48DD777}", root_dir + "/editors/sdkjs-plugins/{9DC93CDB-B576-4F0C-B55E-FCC9C48DD777}")
-
     base.copy_file(base_dir + "/js/" + branding + "/desktop/index.html", root_dir + "/index.html")
     base.create_dir(root_dir + "/editors/webext")
     base.copy_file(base_dir + "/js/" + branding + "/desktop/noconnect.html", root_dir + "/editors/webext/noconnect.html")
@@ -268,6 +240,11 @@ def make():
     else:
       base.copy_dir(git_dir + "/desktop-apps/common/loginpage/providers", root_dir + "/providers")
 
+    # license
+    if (0 == platform.find("mac")):
+      base.create_dir(root_dir + "/license")
+      base.copy_file(git_dir + "/desktop-apps/common/package/license/opensource/EULA.html", root_dir + "/license/EULA.html")
+
     isUseJSC = False
     if (0 == platform.find("mac")):
       doctrenderer_lib = "libdoctrenderer.dylib"
@@ -289,12 +266,12 @@ def make():
 
     is_host_not_arm = False
     host_platform = ""
-
-    # TODO: fix this on mac_arm64 (qemu)
-    # on windows we are using qemu
-    if (platform == "mac_arm64") and not base.is_os_arm():
+    if (platform == "mac_arm64" or platform == "win_arm64") and not base.is_os_arm():
       is_host_not_arm = True
-      host_platform = "mac_64"
+      if platform == "mac_arm64":
+        host_platform = "mac_64"
+      elif platform == "win_arm64":
+        host_platform = "win_64"
 
     # all themes generate ----
     base.copy_exe(core_build_dir + "/bin/" + platform_postfix, root_dir + "/converter", "allfontsgen")
@@ -302,45 +279,27 @@ def make():
 
     if (0 == platform.find("mac")):
       # gen plists with max_depth 2 because frameworks are only located in root_dir and converter subdirectory
-      base.for_each_framework(root_dir, "mac", callbacks=[base.generate_plist], max_depth=2)
+      base.generate_plist(root_dir, "mac", max_depth=2)
       base.mac_correct_rpath_desktop(root_dir)
 
     if is_host_not_arm:
       sdkjs_dir = root_dir + "/editors/sdkjs"
-      str1 = "/" + platform + "/"
-      str2 = "/" + host_platform + "/"
-      sdkjs_dir_host = sdkjs_dir.replace(str1, str2)
+      end_find_platform = sdkjs_dir.rfind("/" + platform + "/")
+      sdkjs_dir_64 = sdkjs_dir[0:end_find_platform] + "/" + host_platform + "/" + sdkjs_dir[end_find_platform+11:]
       base.delete_dir(sdkjs_dir)
-      base.copy_dir(sdkjs_dir_host, sdkjs_dir)
+      base.copy_dir(sdkjs_dir_64, sdkjs_dir)
     else:
       themes_params = []
       if ("" != config.option("themesparams")):
         themes_params = ["--params=\"" + config.option("themesparams") + "\""]
-
-      params_allfontsgen = ["--use-system=\"1\"", "--input=\"" + root_dir + "/fonts\"", "--input=\"" + git_dir + "/core-fonts\"", "--allfonts=\"" + root_dir + "/converter/AllFonts.js\"", "--selection=\"" + root_dir + "/converter/font_selection.bin\""]
-      params_allthemesgen = ["--converter-dir=\"" + root_dir + "/converter\"", "--src=\"" + root_dir + "/editors/sdkjs/slide/themes\"", "--allfonts=\"AllFonts.js\"", "--output=\"" + root_dir + "/editors/sdkjs/common/Images\""] + themes_params
-      if (0 == platform.find("linux_arm") and not base.is_os_arm()):
-        x2t_origin = ""
-        if (config.option("sysroot") != ""):
-          x2t_origin = base.create_qemu_wrapper(root_dir + "/converter/x2t", platform)
- 
-        base.cmd_in_dir_qemu(platform, root_dir + "/converter", "./allfontsgen", params_allfontsgen, True)
-        base.cmd_in_dir_qemu(platform, root_dir + "/converter", "./allthemesgen", params_allthemesgen, True)
-
-        if "" != x2t_origin:
-          base.delete_file(root_dir + "/converter/x2t")
-          base.move_file(x2t_origin, root_dir + "/converter/x2t")
-      else:        
-        base.cmd_exe(root_dir + "/converter/allfontsgen", params_allfontsgen, True)
-        base.cmd_exe(root_dir + "/converter/allthemesgen", params_allthemesgen, True)
-
+      base.cmd_exe(root_dir + "/converter/allfontsgen", ["--use-system=\"1\"", "--input=\"" + root_dir + "/fonts\"", "--input=\"" + git_dir + "/core-fonts\"", "--allfonts=\"" + root_dir + "/converter/AllFonts.js\"", "--selection=\"" + root_dir + "/converter/font_selection.bin\""])
+      base.cmd_exe(root_dir + "/converter/allthemesgen", ["--converter-dir=\"" + root_dir + "/converter\"", "--src=\"" + root_dir + "/editors/sdkjs/slide/themes\"", "--allfonts=\"AllFonts.js\"", "--output=\"" + root_dir + "/editors/sdkjs/common/Images\""] + themes_params)
       base.delete_file(root_dir + "/converter/AllFonts.js")
       base.delete_file(root_dir + "/converter/font_selection.bin")
       base.delete_file(root_dir + "/converter/fonts.log")
 
-    if not base.is_use_create_artifacts_qemu(platform):
-      base.delete_exe(root_dir + "/converter/allfontsgen")
-      base.delete_exe(root_dir + "/converter/allthemesgen")
+    base.delete_exe(root_dir + "/converter/allfontsgen")
+    base.delete_exe(root_dir + "/converter/allthemesgen")
 
     if not isUseJSC:
       base.delete_file(root_dir + "/editors/sdkjs/slide/sdk-all.cache")

scripts/deploy_mobile.py

@@ -65,8 +65,6 @@ def make():
     base.copy_lib(core_build_dir + "/lib/" + platform_postfix, root_dir, "IWorkFile")
     base.copy_lib(core_build_dir + "/lib/" + platform_postfix, root_dir, "HWPFile")
     base.copy_lib(core_build_dir + "/lib/" + platform_postfix, root_dir, "DocxRenderer")
-    base.copy_lib(core_build_dir + "/lib/" + platform_postfix, root_dir, "StarMathConverter")
-    base.copy_lib(core_build_dir + "/lib/" + platform_postfix, root_dir, "ooxmlsignature")
     base.copy_file(git_dir + "/sdkjs/pdf/src/engine/cmap.bin", root_dir + "/cmap.bin")
 
     if (0 == platform.find("win") or 0 == platform.find("linux") or 0 == platform.find("mac")):
@@ -82,7 +80,7 @@ def make():
 
     # correct ios frameworks
     if ("ios" == platform):
-      base.for_each_framework(root_dir, "ios", callbacks=[base.generate_plist, base.generate_xcprivacy])
+      base.generate_plist(root_dir, "ios")
       deploy_fonts(git_dir, root_dir)
       base.copy_dictionaries(git_dir + "/dictionaries", root_dir + "/dictionaries", True, False)
 

scripts/deploy_osign.py

@@ -37,7 +37,7 @@ def make():
 
     # correct ios frameworks
     if ("ios" == platform):
-      base.for_each_framework(root_dir, "ios", callbacks=[base.generate_plist, base.generate_xcprivacy])
+      base.generate_plist(root_dir, "ios")
 
   for native_platform in platforms:
     if native_platform == "android":

scripts/deploy_server.py

@@ -41,7 +41,6 @@ def make():
 
     build_server_dir = root_dir + '/server'
     server_dir = base.get_script_dir() + "/../../server"
-    server_admin_panel_dir = base.get_script_dir() + "/../../server-admin-panel"
 
     base.create_dir(build_server_dir + '/DocService')
 
@@ -59,15 +58,6 @@ def make():
     base.create_dir(build_server_dir + '/Metrics/node_modules/modern-syslog/build/Release')
     base.copy_file(server_dir + "/Metrics/node_modules/modern-syslog/build/Release/core.node", build_server_dir + "/Metrics/node_modules/modern-syslog/build/Release/core.node")
 
-    if "server-admin-panel" in base.get_server_addons() and base.is_exist(server_admin_panel_dir):
-      # AdminPanel server part
-      base.create_dir(build_server_dir + '/AdminPanel/server')
-      base.copy_exe(server_admin_panel_dir + "/server", build_server_dir + '/AdminPanel/server', "adminpanel")
-
-      # AdminPanel client part
-      base.create_dir(build_server_dir + '/AdminPanel/client/build')
-      base.copy_dir(server_admin_panel_dir + '/client/build', build_server_dir + '/AdminPanel/client/build')
-
     qt_dir = base.qt_setup(native_platform)
     platform = native_platform
 
@@ -95,8 +85,6 @@ def make():
     base.copy_lib(core_build_dir + "/lib/" + platform_postfix, converter_dir, "IWorkFile")
     base.copy_lib(core_build_dir + "/lib/" + platform_postfix, converter_dir, "HWPFile")
     base.copy_lib(core_build_dir + "/lib/" + platform_postfix, converter_dir, "DocxRenderer")
-    base.copy_lib(core_build_dir + "/lib/" + platform_postfix, converter_dir, "StarMathConverter")
-    base.copy_lib(core_build_dir + "/lib/" + platform_postfix, converter_dir, "ooxmlsignature")
     base.copy_file(git_dir + "/sdkjs/pdf/src/engine/cmap.bin", converter_dir + "/cmap.bin")
     base.copy_exe(core_build_dir + "/bin/" + platform_postfix, converter_dir, "x2t")
 
@@ -116,7 +104,7 @@ def make():
 
     # correct mac frameworks
     if (0 == platform.find("mac")):
-      base.for_each_framework(converter_dir, "mac", callbacks=[base.generate_plist], max_depth=1)
+      base.generate_plist(converter_dir, "mac", max_depth=1)
 
     # js
     js_dir = root_dir
@@ -183,12 +171,6 @@ def make():
     base.copy_dir(document_templates_files + '/new', document_templates + '/new')
     base.copy_dir(document_templates_files + '/sample', document_templates + '/sample')
 
-    #document-formats
-    document_formats_files = server_dir + '/../document-formats'
-    document_formats = build_server_dir + '/../document-formats'
-    base.create_dir(document_formats)
-    base.copy_file(document_formats_files + '/onlyoffice-docs-formats.json', document_formats + '/onlyoffice-docs-formats.json')
-
     #license
     license_file1 = server_dir + '/LICENSE.txt'
     license_file2 = server_dir + '/3rd-Party.txt'

scripts/develop/dependence.py

@@ -111,8 +111,7 @@ def check_dependencies():
   if (host_platform == 'windows'):
     checksResult.append(check_nodejs())
 
-  sql_type = config.option("sql-type")
-  if (sql_type == 'mysql' and host_platform == 'windows'):
+  if (config.option("sql-type") == 'mysql' and host_platform == 'windows'):
     checksResult.append(check_mysqlServer())
   else:
     checksResult.append(check_postgreSQL())
@@ -301,21 +300,9 @@ def check_rabbitmq():
       print('RabbitMQ is installed')
       return dependence
   elif (host_platform == 'linux'):
-    result = ''
-    
-    # Prefer systemctl for systemd
-    systemctl_result = base.run_command('systemctl status rabbitmq-server')
-    if systemctl_result['returncode'] == 0 and systemctl_result['stdout']:
-      result = systemctl_result['stdout']
-    
-    # Fallback to service for SysV
-    if result == '':
-      command_result = base.run_command('service rabbitmq-server status')
-      if command_result['returncode'] == 0 and command_result['stdout']:
-        result = command_result['stdout']
-    
-    if result != '':
-      print('RabbitMQ is installed')
+    result = base.run_command('service rabbitmq-server status')['stdout']
+    if (result != ''):
+      print('Installed RabbitMQ is valid')
       return dependence
 
   print('RabbitMQ not found')
@@ -530,9 +517,8 @@ def check_mysqlServer():
   if (host_platform != 'windows'):
     result = os.system(mysqlLoginSrt + ' -e "exit"')
     if (result == 0):
-      connectionResult = base.run_command(connectionString)
-      expected_port = config.option("db-port")
-      if (connectionResult['stdout'].find('port') != -1 and connectionResult['stdout'].find(expected_port) != -1):
+      connectionResult = base.run_command(connectionString)['stdout']
+      if (connectionResult.find('port') != -1 and connectionResult.find(config.option("db-port")) != -1):
         print('MySQL configuration is valid')
         dependence.sqlPath = 'mysql'
         return dependence
@@ -547,15 +533,13 @@ def check_mysqlServer():
       continue
 
     mysql_full_name = 'MySQL Server ' + info['Version'] + ' '
-    mysql_bin_path = get_mysql_path_to_bin(info['Location'])
-    connectionResult = base.run_command_in_dir(mysql_bin_path, connectionString)
-    
-    expected_port = config.option("db-port")
-    if (connectionResult['stdout'].find('port') != -1 and connectionResult['stdout'].find(expected_port) != -1):
+
+    connectionResult = base.run_command_in_dir(get_mysql_path_to_bin(info['Location']), connectionString)['stdout']
+    if (connectionResult.find('port') != -1 and connectionResult.find(config.option("db-port")) != -1):
       print(mysql_full_name + 'configuration is valid')
       dependence.sqlPath = info['Location']
       return dependence
-    print(mysql_full_name + 'configuration is not valid')
+    print(mysql_full_name + 'configuration is not valid:' + connectionResult)
     # if path exists, then further removal and installation fails(according to startup statistics). it is better to fix issue manually.
     return dependence
 
@@ -648,8 +632,8 @@ def get_postrgre_path_to_bin(postgrePath = ''):
   return postgrePath
 def get_postgreLoginSrting(userName):
   if (host_platform == 'windows'):
-    return 'psql -U ' + userName + ' -h localhost '
-  return 'PGPASSWORD="' + config.option("db-pass") + '" psql -U ' + userName + ' -h localhost '
+    return 'psql -U' + userName + ' '
+  return 'PGPASSWORD="' + config.option("db-pass") + '" psql -U' + userName + ' -hlocalhost '
 def get_postgreSQLInfoByFlag(flag):
   arrInfo = []
 
@@ -683,10 +667,9 @@ def check_postgreSQL():
 
   if (host_platform == 'linux'):
     result = os.system(postgreLoginSrt + ' -c "\q"')
-    connectionResult = base.run_command(connectionString)
-    expected_port = config.option("db-port")
+    connectionResult = base.run_command(connectionString)['stdout']
 
-    if (result != 0 or connectionResult['stdout'].find(expected_port) == -1):
+    if (result != 0 or connectionResult.find(config.option("db-port")) == -1):
       print('Valid PostgreSQL not found!')
       dependence.append_install('PostgreSQL')
       dependence.append_uninstall('PostgreSQL')
@@ -697,20 +680,18 @@ def check_postgreSQL():
 
   arrInfo = get_postgreSQLInfo()
   base.set_env('PGPASSWORD', config.option("db-pass"))
-  
   for info in arrInfo:
     if (base.is_dir(info['Location']) == False):
       continue
     
     postgre_full_name = 'PostgreSQL ' + info['Version'][:2] + ' '
-    postgre_bin_path = get_postrgre_path_to_bin(info['Location'])
-    connectionResult = base.run_command_in_dir(postgre_bin_path, connectionString)
-    
-    expected_port = config.option("db-port")
-    if (connectionResult['stdout'].find(expected_port) != -1):
+    connectionResult = base.run_command_in_dir(get_postrgre_path_to_bin(info['Location']), connectionString)['stdout']
+
+    if (connectionResult.find(config.option("db-port")) != -1):
       print(postgre_full_name + 'configuration is valid')
       dependence.sqlPath = info['Location']
       return dependence
+    print(postgre_full_name + 'configuration is not valid')
 
   print('Valid PostgreSQL not found')
 
@@ -723,8 +704,6 @@ def check_postgreSQL():
   return dependence
 def check_postgreConfig(postgrePath = ''):
   result = True
-  base.print_info('Checking PostgreSQL configuration')
-  
   if (host_platform == 'windows'):
     base.set_env('PGPASSWORD', config.option("db-pass"))
 
@@ -732,78 +711,53 @@ def check_postgreConfig(postgrePath = ''):
   dbUser = config.option("db-user")
   dbName = config.option("db-name")
   dbPass = config.option("db-pass")
-  
   postgre_path_to_bin = get_postrgre_path_to_bin(postgrePath)
   postgreLoginRoot = get_postgreLoginSrting(rootUser)
   postgreLoginDbUser = get_postgreLoginSrting(dbUser)
   creatdb_path = base.get_script_dir() + "/../../server/schema/postgresql/createdb.sql"
 
-  # Check if user exists
-  user_check_result = base.run_command_in_dir(postgre_path_to_bin, postgreLoginRoot + ' -c "\du ' + dbUser + '"')
-  
-  if (user_check_result['stdout'].find(dbUser) != -1):
-    # User exists, check password
+  if (base.run_command_in_dir(postgre_path_to_bin, postgreLoginRoot + ' -c "\du ' + dbUser + '"')['stdout'].find(dbUser) != -1):
+    print('User ' + dbUser + ' is exist')
     if (os.system(postgreLoginDbUser + '-c "\q"') != 0):
-      print('Invalid user password, changing...')
+      print('Invalid user password!')
+      base.print_info('Changing password...')
       result = change_userPass(dbUser, dbPass, postgre_path_to_bin) and result
   else:
-    print('Creating user ' + dbUser + '...')
+    print('User ' + dbUser + ' not exist!')
+    base.print_info('Creating ' + dbName + ' user...')
     result = create_postgreUser(dbUser, dbPass, postgre_path_to_bin) and result
 
-  # Check if database exists
-  db_check_result = base.run_command_in_dir(postgre_path_to_bin, postgreLoginRoot + ' -c "SELECT datname FROM pg_database;"')
-  
-  if (db_check_result['stdout'].find(dbName) == -1):
-    print('Creating database ' + dbName + '...')
-    create_result = create_postgreDb(dbName, postgre_path_to_bin)
-    
-    if create_result:
-      # Grant privileges to user on database and schema
-      base.run_command_in_dir(postgre_path_to_bin, postgreLoginRoot + '-c "GRANT ALL privileges ON DATABASE ' + dbName + ' TO ' + dbUser + ';"')
-      base.run_command_in_dir(postgre_path_to_bin, postgreLoginRoot + '-d ' + dbName + ' -c "GRANT ALL ON SCHEMA public TO ' + dbUser + ';"')
-      
-      configure_result = configureDb(dbUser, dbName, creatdb_path, postgre_path_to_bin)
-      result = create_result and configure_result
-    else:
-      result = False
+  if (base.run_command_in_dir(postgre_path_to_bin, postgreLoginRoot + ' -c "SELECT datname FROM pg_database;"')['stdout'].find(config.option("db-name")) == -1):
+    print('Database ' + dbName + ' not found')
+    base.print_info('Creating ' + dbName + ' database...')
+    result = create_postgreDb(dbName, postgre_path_to_bin) and configureDb(dbUser, dbName, creatdb_path, postgre_path_to_bin)
   else:
-    # Database exists - check if tables need to be created
-    table_count_result = base.run_command_in_dir(postgre_path_to_bin, postgreLoginRoot + '-c "SELECT count(*) FROM information_schema.tables WHERE table_schema = \'public\';"')
-    
-    needs_configure = False
-    
-    if table_count_result['stdout'].find(' 0') != -1:
-      # No tables - need to configure
-      needs_configure = True
-    
-    if needs_configure:
-      # Grant privileges and configure
-      base.run_command_in_dir(postgre_path_to_bin, postgreLoginRoot + '-c "GRANT ALL privileges ON DATABASE ' + dbName + ' TO ' + dbUser + ';"')
-      base.run_command_in_dir(postgre_path_to_bin, postgreLoginRoot + '-d ' + dbName + ' -c "GRANT ALL ON SCHEMA public TO ' + dbUser + ';"')
-      
-      configure_result = configureDb(dbUser, dbName, creatdb_path, postgre_path_to_bin)
-      result = configure_result and result
-  
+    if (base.run_command_in_dir(postgre_path_to_bin, postgreLoginRoot + '-c "SELECT pg_size_pretty(pg_database_size(' + "'" + dbName + "'" + '));"')['stdout'].find('7559 kB') != -1):
+      print('Database ' + dbName + ' not configured')
+      base.print_info('Configuring ' + dbName + ' database...')
+      result = configureDb(dbName, creatdb_path, postgre_path_to_bin) and result
+    print('Database ' + dbName + ' is valid')
+
+  if (base.run_command_in_dir(postgre_path_to_bin, postgreLoginRoot + '-c "\l+ ' + dbName + '"')['stdout'].find(dbUser +'=CTc/' + rootUser) == -1):
+    print('User ' + dbUser + ' has no database privileges!')
+    base.print_info('Setting database privileges for user ' + dbUser + '...')
+    result = set_dbPrivilegesForUser(dbUser, dbName, postgre_path_to_bin) and result
+  print('User ' + dbUser + ' has database privileges')
+
   return result
 def create_postgreDb(dbName, postgre_path_to_bin = ''):
   postgreLoginUser = get_postgreLoginSrting(install_params['PostgreSQL']['root'])
-  result = base.run_command_in_dir(postgre_path_to_bin, postgreLoginUser + '-c "CREATE DATABASE ' + dbName +';"')
-  if (result['returncode'] != 0):
-    print('Database creation failed!')
+  if (base.exec_command_in_dir(postgre_path_to_bin, postgreLoginUser + '-c "CREATE DATABASE ' + dbName +';"') != 0):
     return False
   return True
 def set_dbPrivilegesForUser(userName, dbName, postgre_path_to_bin = ''):
   postgreLoginUser = get_postgreLoginSrting(install_params['PostgreSQL']['root'])
-  result = base.run_command_in_dir(postgre_path_to_bin, postgreLoginUser + '-c "GRANT ALL privileges ON DATABASE ' + dbName + ' TO ' + userName + ';"')
-  if (result['returncode'] != 0):
-    print('Grant privileges failed!')
+  if (base.exec_command_in_dir(postgre_path_to_bin, postgreLoginUser + '-c "GRANT ALL privileges ON DATABASE ' + dbName + ' TO ' + userName + ';"') != 0):
     return False
   return True
 def create_postgreUser(userName, userPass, postgre_path_to_bin = ''):
   postgreLoginRoot = get_postgreLoginSrting(install_params['PostgreSQL']['root'])
-  result = base.run_command_in_dir(postgre_path_to_bin, postgreLoginRoot + '-c "CREATE USER ' + userName + ' WITH password ' + "'" + userPass + "'" + ';"')
-  if (result['returncode'] != 0):
-    print('User creation failed!')
+  if (base.exec_command_in_dir(postgre_path_to_bin, postgreLoginRoot + '-c "CREATE USER ' + userName + ' WITH password ' + "'" + userPass + "'" + ';"') != 0):
     return False
   return True
 def change_userPass(userName, userPass, postgre_path_to_bin = ''):
@@ -812,24 +766,13 @@ def change_userPass(userName, userPass, postgre_path_to_bin = ''):
     return False
   return True
 def configureDb(userName, dbName, scriptPath, postgre_path_to_bin = ''):
-  print('Executing ' + scriptPath)
-  
-  if not base.is_file(scriptPath):
-    print('ERROR: Script file does not exist!')
-    return False
-  
+  print('Execution ' + scriptPath)
   postgreLoginSrt = get_postgreLoginSrting(userName)
-  full_command = postgreLoginSrt + ' -d ' + dbName + ' -f "' + scriptPath + '"'
-  
-  # Use run_command_in_dir to capture output
-  result = base.run_command_in_dir(postgre_path_to_bin, full_command)
-  
-  if (result['returncode'] != 0):
+
+  code = base.exec_command_in_dir(postgre_path_to_bin, postgreLoginSrt + ' -d ' + dbName + ' -f "' + scriptPath + '"')
+  if (code != 0):
     print('Execution failed!')
-    if result['stderr']:
-      print('Error: ' + result['stderr'])
     return False
-  
   print('Execution completed')
   return True
 def uninstall_postgresql():

scripts/package_builder.py

@@ -131,8 +131,6 @@ def make_tar():
   make_args = ["tar"]
   if common.platform == "darwin_arm64":
     make_args += ["-e", "UNAME_M=arm64"]
-  if common.platform == "darwin_x86_64":
-    make_args += ["-e", "UNAME_M=x86_64"]
   if common.platform == "linux_aarch64":
     make_args += ["-e", "UNAME_M=aarch64"]
   if not branding.onlyoffice:
@@ -170,7 +168,7 @@ def make_wheel():
 
   utils.delete_dir("python")
   utils.copy_dir("../onlyoffice/build_tools/packaging/docbuilder/resources", "python")
-  utils.copy_dir(builder_dir, "python/docbuilder/lib", True, True)
+  utils.copy_dir(builder_dir, "python/docbuilder/lib")
 
   desktop_dir = "../desktop-apps/macos/build/ONLYOFFICE.app/Contents/Resources/converter"
   if utils.is_macos() and "desktop" in common.targets and utils.is_exist(desktop_dir):
@@ -204,11 +202,7 @@ def make_wheel():
     utils.delete_file("docbuilder.net.dll")
     utils.delete_file("docbuilder.jni.dll")
   elif utils.is_macos():
-    if (utils.is_file("libdocbuilder.jni.dylib")):
-      utils.delete_file("libdocbuilder.jni.dylib")
-    if (utils.is_dir("docbuilder.jni.framework")):
-      utils.delete_file("docbuilder.jni.framework")
-    utils.remove_all_symlinks(".")
+    utils.delete_file("libdocbuilder.jni.dylib")
   elif utils.is_linux():
     utils.delete_file("libdocbuilder.jni.so")
 

scripts/package_common.py

@@ -3,14 +3,14 @@
 platformPrefixes = {
   "windows_x64":      "win_64",
   "windows_x86":      "win_32",
-  "windows_arm64":    "win_arm64",
   "windows_x64_xp":   "win_64_xp",
   "windows_x86_xp":   "win_32_xp",
-  "darwin_arm64":     "mac_arm64",
   "darwin_x86_64":    "mac_64",
+  "darwin_arm64":     "mac_arm64",
   "darwin_x86_64_v8": "mac_64",
   "linux_x86_64":     "linux_64",
   "linux_aarch64":    "linux_arm64",
+  "linux_x86_64_cef": "linux_64",
 }
 
 out_dir = "build_tools/out"

scripts/package_desktop.py

@@ -36,7 +36,7 @@ def s3_upload(files, dst):
 
 def make_windows():
   global package_name, package_version, arch, xp
-  utils.set_cwd("desktop-apps\\package")
+  utils.set_cwd("desktop-apps\\win-linux\\package\\windows")
 
   package_name = branding.desktop_package_name
   package_version = common.version + "." + common.build
@@ -44,38 +44,40 @@ def make_windows():
     "windows_x64":    "x64",
     "windows_x64_xp": "x64",
     "windows_x86":    "x86",
-    "windows_x86_xp": "x86",
-    "windows_arm64":  "arm64"
+    "windows_x86_xp": "x86"
   }[common.platform]
   xp = common.platform.endswith("_xp")
 
   if common.clean:
     utils.log_h2("desktop clean")
-    utils.delete_dir("build")
-    utils.delete_files("inno\\package.config")
-    utils.delete_files("inno\\*.exe")
-    utils.delete_dir("advinst\\DesktopEditors-cache")
-    utils.delete_files("advinst\\package.config")
-    utils.delete_files("advinst\\*.msi")
-    utils.delete_files("advinst\\*.aic")
-    utils.delete_dir("zip")
+    utils.delete_dir("DesktopEditors-cache")
+    utils.delete_files("*.exe")
+    utils.delete_files("*.msi")
+    utils.delete_files("*.aic")
+    utils.delete_files("*.tmp")
+    utils.delete_files("*.zip")
+    utils.delete_files("data\\*.exe")
 
   if not xp:
     make_prepare()
     make_zip()
+    make_inno()
     if branding.onlyoffice:
-      make_inno()
       make_inno("standalone")
-      make_advinst()
+      make_inno("update")
+    make_advinst()
 
-      make_prepare("commercial")
-      make_zip("commercial")
-      make_inno("commercial")
-      make_advinst("commercial")
+    make_prepare("commercial")
+    make_zip("commercial")
+    make_inno("commercial")
+    make_advinst("commercial")
   else:
     make_prepare("xp")
     make_zip("xp")
     make_inno("xp")
+  # Disable build online installer
+  # if common.platform == "windows_x86_xp":
+  #  make_online()
 
   utils.set_cwd(common.workspace_dir)
   return
@@ -84,8 +86,7 @@ def make_prepare(edition = "opensource"):
   args = [
     "-Version", package_version,
     "-Arch", arch,
-    "-Target", edition,
-    "-CompanyName", branding.company_name
+    "-Target", edition
   ]
   if common.sign:
     args += ["-Sign"]
@@ -99,12 +100,11 @@ def make_zip(edition = "opensource"):
   if   edition == "commercial": zip_file = "%s-Enterprise-%s-%s.zip"
   elif edition == "xp":         zip_file = "%s-XP-%s-%s.zip"
   else:                         zip_file = "%s-%s-%s.zip"
-  zip_file = "zip\\" + zip_file % (package_name, package_version, arch)
+  zip_file = zip_file % (package_name, package_version, arch)
   args = [
     "-Version", package_version,
     "-Arch", arch,
-    "-Target", edition,
-    "-CompanyName", branding.company_name
+    "-Target", edition
   ]
   # if common.sign:
   #   args += ["-Sign"]
@@ -125,7 +125,7 @@ def make_inno(edition = "opensource"):
   elif edition == "update":     inno_file = "%s-Update-%s-%s.exe"
   elif edition == "xp":         inno_file = "%s-XP-%s-%s.exe"
   else:                         inno_file = "%s-%s-%s.exe"
-  inno_file = "inno\\" + inno_file % (package_name, package_version, arch)
+  inno_file = inno_file % (package_name, package_version, arch)
   args = [
     "-Version", package_version,
     "-Arch", arch,
@@ -150,7 +150,7 @@ def make_inno(edition = "opensource"):
 def make_advinst(edition = "opensource"):
   if edition == "commercial": advinst_file = "%s-Enterprise-%s-%s.msi"
   else:                       advinst_file = "%s-%s-%s.msi"
-  advinst_file = "advinst\\" + advinst_file % (package_name, package_version, arch)
+  advinst_file = advinst_file % (package_name, package_version, arch)
   args = [
     "-Version", package_version,
     "-Arch", arch,
@@ -169,6 +169,18 @@ def make_advinst(edition = "opensource"):
     utils.set_summary("desktop advinst " + edition + " deploy", ret)
   return
 
+def make_online():
+  online_file = utils.glob_file("OnlineInstaller-" + package_version + "*.exe")
+  utils.log_h2("desktop online installer build")
+  ret = utils.is_file(online_file)
+  utils.set_summary("desktop online installer build", ret)
+
+  if common.deploy and ret:
+    utils.log_h2("desktop online installer deploy")
+    ret = s3_upload([online_file], "desktop/win/online/")
+    utils.set_summary("desktop online installer deploy", ret)
+  return
+
 #
 # macOS
 #
@@ -315,7 +327,7 @@ def make_sparkle_updates():
 #
 
 def make_linux():
-  utils.set_cwd("desktop-apps/package")
+  utils.set_cwd("desktop-apps/win-linux/package/linux")
 
   for edition in ["opensource", "commercial"]:
     utils.log_h2("desktop " + edition + " build")
@@ -325,19 +337,14 @@ def make_linux():
     if common.platform == "linux_aarch64":
       make_args += ["-e", "UNAME_M=aarch64"]
     if not branding.onlyoffice:
-      make_args += ["-e", "BRANDING_DIR=../../" + common.branding + "/desktop-apps/package"]
+      make_args += ["-e", "BRANDING_DIR=../../../../" + common.branding + "/desktop-apps/win-linux/package/linux"]
     ret = utils.sh("make clean && make " + " ".join(make_args), verbose=True)
     utils.set_summary("desktop " + edition + " build", ret)
 
     if common.deploy:
       for t in branding.desktop_make_targets:
         utils.log_h2("desktop " + edition + " " + t["make"] + " deploy")
-        uploads = []
-        for f in utils.glob_path(t["src"]):
-          if "help" in f and not \
-            ("x86_64" in common.platform and edition == "opensource"): continue
-          uploads.append(f)
-        ret = s3_upload(uploads, t["dst"])
+        ret = s3_upload(utils.glob_path(t["src"]), t["dst"])
         utils.set_summary("desktop " + edition + " " + t["make"] + " deploy", ret)
 
   utils.set_cwd(common.workspace_dir)

scripts/package_utils.py

@@ -201,12 +201,12 @@ def copy_files(src, dst, override=True, verbose=True):
       copy_files(file + "/*", dst + "/" + file_name, override)
   return
 
-def copy_dir(src, dst, verbose=True, symlinks=False):
+def copy_dir(src, dst, verbose=True):
   if verbose:
     log("- copy_dir:")
     log("    src: " + src)
     log("    dst: " + dst)
-  shutil.copytree(src, dst, symlinks=symlinks)
+  shutil.copytree(src, dst)
   return
 
 def copy_dir_content(src, dst, filter_include = "", filter_exclude = "", verbose=True):
@@ -262,20 +262,6 @@ def delete_files(src, verbose=True):
       shutil.rmtree(path, ignore_errors=True)
   return
 
-def remove_all_symlinks(dir):
-  for root, dirs, files in os.walk(dir, topdown=True, followlinks=False):
-    for name in files:
-      path = os.path.join(root, name)
-      if os.path.islink(path):
-        os.unlink(path)
-    
-    for name in list(dirs):
-      path = os.path.join(root, name)
-      if os.path.islink(path):
-        os.unlink(path)
-        dirs.remove(name)
-  return
-
 def set_summary(target, status):
   common.summary.append({target: status})
   return

scripts/qmake.py

@@ -36,7 +36,7 @@ def make(platform, project, qmake_config_addon="", is_no_errors=False):
     return
 
   old_env = dict(os.environ)
-
+  
   # qt
   qt_dir = base.qt_setup(platform)
   base.set_env("OS_DEPLOY", platform)
@@ -50,7 +50,7 @@ def make(platform, project, qmake_config_addon="", is_no_errors=False):
   if (pro_dir.endswith("/")):
     pro_dir = pro_dir[:-1]
 
-  makefile_name = "Makefile." + get_make_file_suffix(platform)
+  makefile_name = "Makefile." + get_make_file_suffix(platform) 
   makefile = pro_dir + "/" + makefile_name
   stash_file = pro_dir + "/.qmake.stash"
 
@@ -73,11 +73,6 @@ def make(platform, project, qmake_config_addon="", is_no_errors=False):
   # setup ios env
   if (-1 != platform.find("ios")):
     base.hack_xcode_ios()
-    sdk_name = "iphoneos"
-    if qmake_config_addon.find("ios_simulator") != -1:
-      sdk_name = "iphonesimulator"
-    base.set_env("SDK_PATH", base.find_ios_sdk(sdk_name))
-    base.set_env("XCODE_TOOLCHAIN_PATH", base.find_xcode_toolchain(sdk_name))
 
   if base.is_file(makefile):
     base.delete_file(makefile)
@@ -105,35 +100,20 @@ def make(platform, project, qmake_config_addon="", is_no_errors=False):
     if "1" == config.option("use-clang"):
       build_params.append("-spec")
       build_params.append("linux-clang-libc++")
-
-    if "" != config.option("sysroot"):
-      sysroot_path = config.option("sysroot_" + platform)
-      os.environ['QMAKE_CUSTOM_SYSROOT'] = sysroot_path
-      os.environ['QMAKE_CUSTOM_SYSROOT_BIN'] = config.get_custom_sysroot_bin(platform)
-      os.environ['PKG_CONFIG_PATH'] = config.get_custom_sysroot_lib(platform, True) + "/pkgconfig"
-      os.environ['PKG_CONFIG_SYSROOT_DIR'] = sysroot_path
-
-    base.cmd_exe(qmake_app, build_params)
-
-    if "" != config.option("sysroot"):
-      base.set_sysroot_env(platform)
+    if "" != config.option("custom-sysroot"):
+      os.environ['LD_LIBRARY_PATH'] = config.get_custom_sysroot_lib()
+      os.environ['QMAKE_CUSTOM_SYSROOT'] = config.option("custom-sysroot")
+      base.cmd_exe(qmake_app, build_params) # calls cmd_exe to pass os.env
+    else:
+      base.cmd(qmake_app, build_params)
 
     base.correct_makefile_after_qmake(platform, makefile)
     if ("1" == config.option("clean")):
       base.cmd_and_return_cwd("make", clean_params, True)
       base.cmd_and_return_cwd("make", distclean_params, True)
-      
-      if "" != config.option("sysroot"):
-        base.restore_sysroot_env()
-      base.cmd(qmake_app, build_params)   
-      if "" != config.option("sysroot"):
-        base.set_sysroot_env(platform)
-      
+      base.cmd(qmake_app, build_params)
       base.correct_makefile_after_qmake(platform, makefile)
     base.cmd_and_return_cwd("make", ["-f", makefile] + get_j_num(), is_no_errors)
-
-    if "" != config.option("sysroot"):
-      base.restore_sysroot_env()
   else:
     config_params_array = base.qt_config_as_param(config_param)
     config_params_string = ""

scripts/sdkjs_common/jsdoc/README.md

@@ -14,7 +14,7 @@ and Plugins (Methods/Events) API using the following Python scripts:
 
 ```bash
 Node.js v20 and above
-Python v3.12 and above
+Python v3.10 and above
 ```
 
 ## Installation

scripts/sdkjs_common/jsdoc/office-api/config/correct_doclets.js

@@ -66,21 +66,11 @@ exports.handlers = {
             const isMethod = doclet.kind === 'function' || doclet.kind === 'method';
             const hasTypeofEditorsTag = isMethod && doclet.tags && doclet.tags.some(tag => tag.title === 'typeofeditors' && tag.value.includes(process.env.EDITOR));
 
-            let shouldAddMethod = 
+            const shouldAddMethod = 
                 doclet.kind !== 'member' &&
                 (!doclet.longname || doclet.longname.search('private') === -1) &&
                 doclet.scope !== 'inner' && hasTypeofEditorsTag;
 
-			// class names may be the same between editors, we check against the inheritance tree
-			if (doclet.inherits) {
-				const parentClass = doclet.inherits.split('#')[0];
-				const curClass = cleanName(doclet.memberof);
-
-				if (!classesDocletsMap[curClass].augments || !classesDocletsMap[curClass].augments.includes(parentClass)) {
-					shouldAddMethod = false;
-				}
-			}
-
             if (shouldAddMethod) {
                 // if the class is not in our map, then we deleted it ourselves -> not available in the editor
                 if (false == passedClasses.includes(cleanName(doclet.memberof))) {

scripts/sdkjs_common/jsdoc/office-api/config/pdf.json

@@ -1,6 +1,6 @@
 {
   "source": {
-    "include": ["../../../../../sdkjs/word/apiBuilder.js", "../../../../../sdkjs/pdf/apiBuilder.js"]
+    "include": ["../../../../../sdkjs/pdf/apiBuilder.js"]
   },
   "plugins": ["./correct_doclets.js"],
   "opts": {
@@ -13,4 +13,4 @@
       "pretty": true
     }
   }
-}
+}

scripts/sdkjs_common/jsdoc/office-api/generate_docs_json.py

@@ -5,29 +5,24 @@ import argparse
 import re
 import platform
 
-script_path = os.path.abspath(__file__)
-root = os.path.abspath(os.path.join(os.path.dirname(script_path), '../../../../..'))
+root = '../../../../..'
 
 # Configuration files
 configs = [
     "./config/word.json",
     "./config/cell.json",
     "./config/slide.json",
-    "./config/forms.json",
-    "./config/pdf.json"
+    "./config/forms.json"
 ]
 
 editors_maps = {
     "word":     "CDE",
     "cell":     "CSE",
     "slide":    "CPE",
-    "forms":    "CFE",
-    "pdf":		"PDFE"
+    "forms":    "CFE"
 }
 
 def generate(output_dir, md=False):
-    os.chdir(os.path.dirname(script_path))
-
     if not os.path.exists(output_dir):
         os.makedirs(output_dir)
 
@@ -79,7 +74,10 @@ def generate(output_dir, md=False):
                             doclet['example'] = remove_js_comments(comment) + "```js\n" + code_content + "\n```"
                         
                         if md == False:
-                            doclet['description'] = doclet['description'] + f'\n\n## Try it\n\n ```js document-builder={{"documentType": "{editor_name}"}}\n{code_content}\n```'
+                            document_type = editor_name
+                            if "forms" == document_type:
+                                document_type = "pdf"
+                            doclet['description'] = doclet['description'] + f'\n\n## Try it\n\n ```js document-builder={{"documentType": "{document_type}"}}\n{code_content}\n```'
         
         # Write the modified JSON file back
         with open(output_file, 'w', encoding='utf-8') as f:

scripts/sdkjs_common/jsdoc/office-api/generate_docs_md.py

@@ -4,53 +4,19 @@ import re
 import shutil
 import argparse
 import generate_docs_json
-import json
-from pathlib import PurePosixPath
 
 # Configuration files
 editors = {
     "word": "text-document-api",
     "cell": "spreadsheet-api",
     "slide": "presentation-api",
-    "forms": "form-api",
-    "pdf": "pdf-api",
+    "forms": "form-api"
 }
 
-
-script_path = os.path.abspath(__file__)
-root = os.path.abspath(os.path.join(os.path.dirname(script_path), '../../../../..'))
-
 missing_examples = []
 used_enumerations = set()
-translations = {}
-translations_lang = None
-missed_translations = {}
-used_translations_keys = {}
-global_output_dir = ""
-cur_editor_name = None
 
-def find_common_path_part(path_full: str, path_suffix: str, anchor: str) -> str:
-    path_full = path_full.replace('\\', '/')
-    path_suffix = path_suffix.replace('\\', '/')
-    
-    parts1 = PurePosixPath(path_full).parts
-    parts2 = PurePosixPath(path_suffix).parts
-    
-    try:
-        idx1 = [p.lower() for p in parts1].index(anchor.lower())
-        idx2 = [p.lower() for p in parts2].index(anchor.lower())
-    except ValueError:
-        return ""
-        
-    common_segments = []
-    
-    for p1, p2 in zip(parts1[idx1:], parts2[idx2:]):
-        if p1.lower() == p2.lower(): 
-            common_segments.append(p1)
-        else:
-            break
-            
-    return "/".join(common_segments)
+cur_editor_name = None
 
 def load_json(file_path):
     with open(file_path, 'r', encoding='utf-8') as f:
@@ -65,21 +31,6 @@ def remove_js_comments(text):
     text = re.sub(r'/\*.*?\*/', '', text, flags=re.DOTALL)     # multi-line
     return text.strip()
 
-def get_translation(key):
-    def process_part(k):
-        if k not in translations:
-            missed_translations[k] = k
-        else:
-            used_translations_keys[k] = True
-        return translations.get(k, k)
-
-    if '\\\n' in key:
-        parts = key.split('\\\n')
-        translated_parts = [process_part(p) for p in parts]
-        return '\\\n'.join(translated_parts)
-    
-    return process_part(key)
-
 def process_link_tags(text, root=''):
     """
     Finds patterns like {@link ...} and replaces them with Markdown links.
@@ -87,22 +38,27 @@ def process_link_tags(text, root=''):
     otherwise, a link to a class method is created.
     For a method, if an alias is not specified, the name is left in the format 'Class#Method'.
     """
-    
+    reserved_links = {
+        '/docbuilder/global#ShapeType': f"{'../../../../../../' if root == '' else '../../../../../' if root == '../' else root}docs/office-api/usage-api/text-document-api/Enumeration/ShapeType.md",
+        '/plugin/config': 'https://api.onlyoffice.com/docs/plugin-and-macros/structure/configuration/',
+        '/docbuilder/basic': 'https://api.onlyoffice.com/docs/office-api/usage-api/text-document-api/'
+    }
+
     def replace_link(match):
-        content = match.group(1).strip()  # Example: "global#ShapeType shape type" or "global#ErrorValue ErrorValue
+        content = match.group(1).strip()  # Example: "/docbuilder/global#ShapeType shape type" or "global#ErrorValue ErrorValue"
         parts = content.split()
         ref = parts[0]
         label = parts[1] if len(parts) > 1 else None
 
-        if ref.startswith('/docs/'):
-            url = root + '../../../..' + ref
-            display_text = label if label else ref
-            
-            if url.endswith('/'):
-                last_dir = url.rstrip('/').split('/')[-1]
-                url = f"{url}{last_dir}"
-        
-            return f"[{display_text}]({url}.md)"
+        if ref.startswith('/'):
+            # Handle reserved links using mapping
+            if ref in reserved_links:
+                url = reserved_links[ref]
+                display_text = label if label else ref
+                return f"[{display_text}]({url})"
+            else:
+                # If the link is not in the mapping, return the original construction
+                return match.group(0)
         elif ref.startswith("global#"):
             # Handle links to typedef (similar logic as before)
             typedef_name = ref.split("#")[1]
@@ -130,7 +86,7 @@ def correct_description(string, root='', isInTable=False):
       - All '\r' characters are replaced with '\n'.
     """
     if string is None:
-        return get_translation('No description provided.')
+        return 'No description provided.'
 
     if False == isInTable:
         # Line breaks
@@ -139,7 +95,6 @@ def correct_description(string, root='', isInTable=False):
         string = re.sub(r'<b>', '-**', string)
     else:
         string = re.sub(r'<b>', '**', string)
-        string = remove_line_breaks(string)
     
     string = re.sub(r'</b>', '**', string)
     
@@ -149,7 +104,7 @@ def correct_description(string, root='', isInTable=False):
     # Process {@link ...} constructions
     string = process_link_tags(string, root)
     
-    return get_translation(string)
+    return string
 
 def correct_default_value(value, enumerations, classes):
     if value is None or value == '':
@@ -346,12 +301,12 @@ def generate_data_types_markdown(types, enumerations, classes, root='../../'):
 
 
 def generate_class_markdown(class_name, methods, properties, enumerations, classes):
-    content = f"# {class_name}\n\n{get_translation(f"Represents the {class_name} class.")}\n\n"
+    content = f"# {class_name}\n\nRepresents the {class_name} class.\n\n"
     
     content += generate_properties_markdown(properties, enumerations, classes)
 
-    content += f"\n## {get_translation(f"Methods")}\n\n"
-    content += f"| {get_translation(f"Method")} | {get_translation(f"Returns")} | {get_translation(f"Description")} |\n"
+    content += "\n## Methods\n\n"
+    content += "| Method | Returns | Description |\n"
     content += "| ------ | ------- | ----------- |\n"
     
     for method in sorted(methods, key=lambda m: m['name']):
@@ -363,10 +318,10 @@ def generate_class_markdown(class_name, methods, properties, enumerations, class
             return_type_list = returns[0].get('type', {}).get('names', [])
             returns_markdown = generate_data_types_markdown(return_type_list, enumerations, classes, '../')
         else:
-            returns_markdown = get_translation(f"None")
+            returns_markdown = "None"
         
         # Processing the method description
-        description = correct_description(method.get('description', 'No description provided.'), '../', True)
+        description = remove_line_breaks(correct_description(method.get('description', 'No description provided.'), '../', True))
         
         # Form a link to the method document
         method_link = f"[{method_name}](./Methods/{method_name}.md)"
@@ -388,47 +343,47 @@ def generate_method_markdown(method, enumerations, classes, example_editor_name)
     
     # Syntax
     param_list = ', '.join([param['name'] for param in params if '.' not in param['name']]) if params else ''
-    content += f"## {get_translation(f"Syntax")}\n\n```javascript\nexpression.{method_name}({param_list});\n```\n\n"
+    content += f"## Syntax\n\n```javascript\nexpression.{method_name}({param_list});\n```\n\n"
     if memberof:
-        content += f"`expression` - {get_translation(f"A variable that represents a [{memberof}](../{memberof}.md) class.")}\n\n"
+        content += f"`expression` - A variable that represents a [{memberof}](../{memberof}.md) class.\n\n"
 
     # Parameters
-    content += f"## {get_translation(f"Parameters")}\n\n"
+    content += "## Parameters\n\n"
     if params:
-        content += f"| **{get_translation(f"Name")}** | **{get_translation(f"Required/Optional")}** | **{get_translation(f"Data type")}** | **{get_translation(f"Default")}** | **{get_translation(f"Description")}** |\n"
+        content += "| **Name** | **Required/Optional** | **Data type** | **Default** | **Description** |\n"
         content += "| ------------- | ------------- | ------------- | ------------- | ------------- |\n"
         for param in params:
             param_name = param.get('name', 'Unnamed')
             param_types = param.get('type', {}).get('names', []) if param.get('type') else []
             param_types_md = generate_data_types_markdown(param_types, enumerations, classes)
-            param_desc = correct_description(param.get('description', 'No description provided.'), '../../', True)
-            param_required = f"{get_translation(f"Required")}" if not param.get('optional') else f"{get_translation(f"Optional")}"
+            param_desc = remove_line_breaks(correct_description(param.get('description', 'No description provided.'), '../../', True))
+            param_required = "Required" if not param.get('optional') else "Optional"
             param_default = correct_default_value(param.get('defaultvalue', ''), enumerations, classes)
 
             content += f"| {param_name} | {param_required} | {param_types_md} | {param_default} | {param_desc} |\n"
     else:
-        content += f"{get_translation("This method doesn't have any parameters.")}\n"
+        content += "This method doesn't have any parameters.\n"
 
     # Returns
-    content += f"\n## {get_translation(f"Returns")}\n\n"
+    content += "\n## Returns\n\n"
     if returns:
         return_type_list = returns[0].get('type', {}).get('names', [])
         return_type_md = generate_data_types_markdown(return_type_list, enumerations, classes)
         content += return_type_md
     else:
-        content += get_translation(f"This method doesn't return any data.")
+        content += "This method doesn't return any data."
     
     # Example
     if example:
         # Separate comment and code, remove JS comments
         if '```js' in example:
             comment, code = example.split('```js', 1)
-            comment = get_translation(comment.strip())
-            content += f"\n\n## {get_translation(f"Example")}\n\n{comment}\n\n```javascript {example_editor_name}\n{code.strip()}\n"
+            comment = remove_js_comments(comment)
+            content += f"\n\n## Example\n\n{comment}\n\n```javascript {example_editor_name}\n{code.strip()}\n"
         else:
             # If there's no triple-backtick structure, just show it as code
             cleaned_example = remove_js_comments(example)
-            content += f"\n\n## {get_translation(f"Example")}\n\n```javascript {example_editor_name}\n{cleaned_example}\n```\n"
+            content += f"\n\n## Example\n\n```javascript {example_editor_name}\n{cleaned_example}\n```\n"
 
     return escape_text_outside_code_blocks(content)
 
@@ -436,14 +391,14 @@ def generate_properties_markdown(properties, enumerations, classes, root='../'):
     if properties is None:
         return ''
     
-    content = f"## {get_translation(f"Properties")}\n\n"
-    content += f"| {get_translation(f"Name")} | {get_translation(f"Type")} | {get_translation(f"Description")} |\n"
+    content = "## Properties\n\n"
+    content += "| Name | Type | Description |\n"
     content += "| ---- | ---- | ----------- |\n"
 
     for prop in sorted(properties, key=lambda m: m['name']):
         prop_name = prop['name']
         prop_description = prop.get('description', 'No description provided.')
-        prop_description = correct_description(prop_description, root, True)
+        prop_description = remove_line_breaks(correct_description(prop_description, root, True))
         prop_types = prop['type']['names'] if prop.get('type') else []
         param_types_md = generate_data_types_markdown(prop_types, enumerations, classes, root)
         content += f"| {prop_name} | {param_types_md} | {prop_description} |\n"
@@ -467,8 +422,8 @@ def generate_enumeration_markdown(enumeration, enumerations, classes, example_ed
     if ptype['type'] == 'TypeUnion':
         enum_empty = True # is empty enum
 
-        content += f"## {get_translation(f"Type")}\n\n{get_translation(f"Enumeration")}\n\n"
-        content += f"## {get_translation(f"Values")}\n\n"
+        content += "## Type\n\nEnumeration\n\n"
+        content += "## Values\n\n"
         # Each top-level name in the union
         for raw_t in enumeration['type']['names']:
             ts_t = convert_jsdoc_array_to_ts(raw_t)
@@ -488,25 +443,25 @@ def generate_enumeration_markdown(enumeration, enumerations, classes, example_ed
         if enum_empty == True:
             return None
     elif enumeration['properties'] is not None:
-        content += f"## {get_translation(f"Type")}\n\n{get_translation(f"Object")}\n\n"
+        content += "## Type\n\nObject\n\n"
         content += generate_properties_markdown(enumeration['properties'], enumerations, classes)
     else:
-        content += f"## {get_translation(f"Type")}\n\n"
+        content += "## Type\n\n"
         # If it's not a union and has no properties, simply print the type(s).
         types = enumeration['type']['names']
-        t_md = generate_data_types_markdown(types, enumerations, classes, '../')
+        t_md = generate_data_types_markdown(types, enumerations, classes)
         content += t_md + "\n\n"
 
     # Example
     if example:
         if '```js' in example:
             comment, code = example.split('```js', 1)
-            comment = get_translation(comment.strip())
-            content += f"\n\n## {get_translation(f"Example")}\n\n{comment}\n\n```javascript {example_editor_name}\n{code.strip()}\n"
+            comment = remove_js_comments(comment)
+            content += f"\n\n## Example\n\n{comment}\n\n```javascript {example_editor_name}\n{code.strip()}\n"
         else:
             # If there's no triple-backtick structure
             cleaned_example = remove_js_comments(example)
-            content += f"\n\n## {get_translation(f"Example")}\n\n```javascript {example_editor_name}\n{cleaned_example}\n```\n"
+            content += f"\n\n## Example\n\n```javascript {example_editor_name}\n{cleaned_example}\n```\n"
 
     return escape_text_outside_code_blocks(content)
 
@@ -523,13 +478,11 @@ def process_doclets(data, output_dir, editor_name):
     if editor_name == 'word':
         example_editor_name += 'docx'
     elif editor_name == 'forms':
-        example_editor_name += 'forms'
+        example_editor_name += 'pdf'
     elif editor_name == 'slide':
         example_editor_name += 'pptx'
     elif editor_name == 'cell':
         example_editor_name += 'xlsx'
-    elif editor_name == 'pdf':
-        example_editor_name += 'pdf'
 
     for doclet in data:
         if doclet['kind'] == 'class':
@@ -596,20 +549,7 @@ def process_doclets(data, output_dir, editor_name):
         if not enum.get('example', ''):
             missing_examples.append(os.path.relpath(enum_file_path, output_dir))
 
-def generate(output_dir, translations_file):
-    global translations
-    global translations_lang
-    global global_output_dir
-    global_output_dir = output_dir
-    
-    if translations_file is not None and os.path.exists(translations_file):
-        translations = load_json(translations_file)
-        translations_lang = os.path.splitext(os.path.basename(translations_file))[0]
-    else:
-        translations = {}
-		
-    os.chdir(os.path.dirname(script_path))
-    
+def generate(output_dir):
     print('Generating Markdown documentation...')
     
     generate_docs_json.generate(output_dir + 'tmp_json', md=True)
@@ -626,21 +566,6 @@ def generate(output_dir, translations_file):
         used_enumerations.clear()
         process_doclets(data, output_dir, editor_name)
     
-    if translations_file is not None:
-        target_dir = os.path.dirname(translations_file)
-        
-        missed_file_path = os.path.join(target_dir, "missed_translations.json")
-        print(f'Saving missed translations to: {missed_file_path}')
-        with open(missed_file_path, 'w', encoding='utf-8') as f:
-            json.dump(missed_translations, f, ensure_ascii=False, indent=4)
-
-        unused_keys = set(translations.keys()) - set(used_translations_keys.keys())
-        unused_data = {k: translations[k] for k in unused_keys}
-        unused_file_path = os.path.join(target_dir, "unused_translations.json")
-        print(f'Saving unused translations to: {unused_file_path}')
-        with open(unused_file_path, 'w', encoding='utf-8') as f:
-            json.dump(unused_data, f, ensure_ascii=False, indent=4)   
-
     shutil.rmtree(output_dir + 'tmp_json')
     print('Done')
 
@@ -651,19 +576,10 @@ if __name__ == "__main__":
         type=str, 
         help="Destination directory for the generated documentation",
         nargs='?',  # Indicates the argument is optional
-        default=f"{root}/api.onlyoffice.com/site/docs/office-api/usage-api/"  # Default value
+        default="../../../../../api.onlyoffice.com/site/docs/office-api/usage-api/"  # Default value
     )
-    parser.add_argument(
-        "--translations", 
-        type=str, 
-        help="Path to the JSON file with translations",
-        nargs='?',
-        default=None
-    )
-    
     args = parser.parse_args()
-    
-    generate(args.destination, args.translations)
+    generate(args.destination)
     print("START_MISSING_EXAMPLES")
     print(",".join(missing_examples))
     print("END_MISSING_EXAMPLES")

scripts/sdkjs_common/jsdoc/office-api/generate_jsonl_dataset.py

@@ -11,21 +11,17 @@ editors = [
     "word",
     "cell",
     "slide",
-    "forms",
-    "pdf"
+    "forms"
 ]
 
 editors_names = {
     "word": "Word",
     "cell": "Spreadsheet",
     "slide": "Presentation",
-    "forms": "Forms",
-    "pdf": "PDF"
+    "forms": "Forms"
 }
 
-script_path = os.path.abspath(__file__)
-root = os.path.abspath(os.path.join(os.path.dirname(script_path), '../../../../..'))
-
+root = '../../../../..'
 missing_examples = []
 
 def load_json(file_path):
@@ -203,8 +199,6 @@ def process_doclets(doclets, output_entries, editor_name, model):
                 output_entries.append(create_entry(system_message, comment, assistant_message, model))
             
 def generate(output_dir, model):
-    os.chdir(os.path.dirname(script_path))
-    
     print('Generating documentation JSONL dataset...')
     
     shutil.rmtree(output_dir, ignore_errors=True)
@@ -234,7 +228,7 @@ if __name__ == "__main__":
         type=str, 
         help="Destination directory for the generated documentation",
         nargs='?',  # Indicates the argument is optional
-        default=f"{root}/office-js-api/dataset"  # Default value
+        default="../../../../../office-js-api/dataset"  # Default value
     )
     parser.add_argument(
         "model", 

scripts/sdkjs_common/jsdoc/plugins/config/events/pdf.json

@@ -1,16 +0,0 @@
-{
-  "source": {
-    "include": ["../../../../../sdkjs/pdf/plugin-events.js"]
-  },
-  "plugins": ["../correct_doclets.js"],
-  "opts": {
-    "destination": "./out",
-    "recurse": true,
-    "encoding": "utf8"
-  },
-  "templates": {
-    "json": {
-      "pretty": true
-    }
-  }
-}

scripts/sdkjs_common/jsdoc/plugins/config/methods/pdf.json

@@ -1,16 +0,0 @@
-{
-  "source": {
-    "include": ["../../../../../sdkjs/pdf/api_plugins.js"]
-  },
-  "plugins": ["../correct_doclets.js"],
-  "opts": {
-    "destination": "./out",
-    "recurse": true,
-    "encoding": "utf8"
-  },
-  "templates": {
-    "json": {
-      "pretty": true
-    }
-  }
-}

scripts/sdkjs_common/jsdoc/plugins/generate_docs_events_json.py

@@ -10,16 +10,12 @@ configs = [
     "./config/events/word.json",
     "./config/events/cell.json",
     "./config/events/slide.json",
-    "./config/events/forms.json",
-    "./config/events/pdf.json"
+    "./config/events/forms.json"
 ]
 
-script_path = os.path.abspath(__file__)
-root = os.path.abspath(os.path.join(os.path.dirname(script_path), '../../../../..'))
+root = '../../../../..'
 
 def generate(output_dir, md=False):
-    os.chdir(os.path.dirname(script_path))
-    
     if not os.path.exists(output_dir):
         os.makedirs(output_dir)
 

scripts/sdkjs_common/jsdoc/plugins/generate_docs_events_md.py

@@ -5,51 +5,18 @@ import re
 import shutil
 import argparse
 import generate_docs_events_json
-import json
-from pathlib import PurePosixPath
 
 # Папки для каждого editor_name
 editors = {
     "word": "text-document-api",
     "cell": "spreadsheet-api",
     "slide": "presentation-api",
-    "forms": "form-api",
-    "pdf": "pdf-api"
+    "forms": "form-api"
 }
 
-script_path = os.path.abspath(__file__)
-root = os.path.abspath(os.path.join(os.path.dirname(script_path), '../../../../..'))
-
 missing_examples = []
 used_enumerations = set()
-translations = {}
-translations_lang = None
-missed_translations = {}
-used_translations_keys = {}
-global_output_dir = ""
 
-def find_common_path_part(path_full: str, path_suffix: str, anchor: str) -> str:
-    path_full = path_full.replace('\\', '/')
-    path_suffix = path_suffix.replace('\\', '/')
-    
-    parts1 = PurePosixPath(path_full).parts
-    parts2 = PurePosixPath(path_suffix).parts
-    
-    try:
-        idx1 = [p.lower() for p in parts1].index(anchor.lower())
-        idx2 = [p.lower() for p in parts2].index(anchor.lower())
-    except ValueError:
-        return ""
-        
-    common_segments = []
-    
-    for p1, p2 in zip(parts1[idx1:], parts2[idx2:]):
-        if p1.lower() == p2.lower(): 
-            common_segments.append(p1)
-        else:
-            break
-            
-    return "/".join(common_segments)
 
 def load_json(path):
     with open(path, 'r', encoding='utf-8') as f:
@@ -67,20 +34,6 @@ def remove_js_comments(text):
     text = re.sub(r'/\*.*?\*/', '', text, flags=re.DOTALL)
     return text.strip()
 
-def get_translation(key):
-    def process_part(k):
-        if k not in translations:
-            missed_translations[k] = k
-        else:
-            used_translations_keys[k] = True
-        return translations.get(k, k)
-
-    if '\\\n' in key:
-        parts = key.split('\\\n')
-        translated_parts = [process_part(p) for p in parts]
-        return '\\\n'.join(translated_parts)
-    
-    return process_part(key)
 
 def correct_description(string, root='', isInTable=False):
     """
@@ -92,7 +45,7 @@ def correct_description(string, root='', isInTable=False):
       - All '\r' characters are replaced with '\n'.
     """
     if string is None:
-        return get_translation('No description provided.')
+        return 'No description provided.'
 
     if False == isInTable:
         # Line breaks
@@ -101,7 +54,6 @@ def correct_description(string, root='', isInTable=False):
         string = re.sub(r'<b>', '-**', string)
     else:
         string = re.sub(r'<b>', '**', string)
-        string = remove_line_breaks(string)
     
     string = re.sub(r'</b>', '**', string)
     
@@ -111,7 +63,7 @@ def correct_description(string, root='', isInTable=False):
     # Process {@link ...} constructions
     string = process_link_tags(string, root)
     
-    return get_translation(string)
+    return string
 
 def process_link_tags(text, root=''):
     """
@@ -120,22 +72,31 @@ def process_link_tags(text, root=''):
     otherwise, a link to a class method is created.
     For a method, if an alias is not specified, the name is left in the format 'Class#Method'.
     """
-    
+    reserved_links = {
+        '/docbuilder/global#ShapeType': f"{'../../../../../../' if root == '' else '../../../../../' if root == '../' else root}docs/office-api/usage-api/text-document-api/Enumeration/ShapeType.md",
+        '/plugin/config': 'https://api.onlyoffice.com/docs/plugin-and-macros/structure/configuration/',
+        '/docbuilder/basic': 'https://api.onlyoffice.com/docs/office-api/usage-api/text-document-api/'
+    }
+
     def replace_link(match):
-        content = match.group(1).strip()  # Example: "global#ShapeType shape type" or "global#ErrorValue ErrorValue
+        content = match.group(1).strip()  # Example: "/docbuilder/global#ShapeType shape type" or "global#ErrorValue ErrorValue"
         parts = content.split()
         ref = parts[0]
         label = parts[1] if len(parts) > 1 else None
 
-        if ref.startswith('/docs/'):
-            url = root + '../../../..' + ref
-            display_text = label if label else ref
-            
-            if url.endswith('/'):
-                last_dir = url.rstrip('/').split('/')[-1]
-                url = f"{url}{last_dir}"
-        
-            return f"[{display_text}]({url}.md)"
+        if ref.startswith('/'):
+            # Handle reserved links using mapping
+            if ref in reserved_links:
+                url = reserved_links[ref]
+                display_text = label if label else ref
+                return f"[{display_text}]({url})"
+            elif ref.startswith('/docs/plugins/'):
+                url = f"../../{ref.split('/docs/plugins/')[1]}.md"
+                display_text = label if label else ref
+                return f"[{display_text}]({url})"
+            else:
+                # If the link is not in the mapping, return the original construction
+                return match.group(0)
         elif ref.startswith("global#"):
             # Handle links to typedef (similar logic as before)
             typedef_name = ref.split("#")[1]
@@ -196,26 +157,26 @@ def escape_text_outside_code_blocks(md):
 
 def generate_event_markdown(event, enumerations):
     name = event['name']
-    desc = correct_description(event.get('description', ''), '../', True)
+    desc = correct_description(event.get('description', ''))
     params = event.get('params', [])
 
     md = f"# {name}\n\n{desc}\n\n"
 
     # Parameters
-    md += f"## {get_translation("Parameters")}\n\n"
+    md += "## Parameters\n\n"
     if params:
-        md += f"| **{get_translation("Name")}** | **{get_translation("Data type")}** | **{get_translation("Description")}** |\n"
+        md += "| **Name** | **Data type** | **Description** |\n"
         md += "| --------- | ------------- | ----------- |\n"
         for p in params:
             t_md = generate_data_types_markdown(
                 p.get('type', {}).get('names', []),
                 enumerations
             )
-            d = correct_description(p.get('description', ''), isInTable=True)
+            d = remove_line_breaks(correct_description(p.get('description', ''), isInTable=True))
             md += f"| {p['name']} | {t_md} | {d} |\n"
         md += "\n"
     else:
-        md += f"{get_translation("This event has no parameters.")}\n\n"
+        md += "This event has no parameters.\n\n"
 
     for ex in event.get('examples', []):
         code = remove_js_comments(ex).strip()
@@ -248,7 +209,7 @@ def generate_enumeration_markdown(enumeration, enumerations):
         # If parsedType is missing, just list 'type.names' if available
         type_names = enumeration['type'].get('names', [])
         if type_names:
-            content += f"## {get_translation("Type")}\n\n"
+            content += "## Type\n\n"
             t_md = generate_data_types_markdown(type_names, enumerations)
             content += t_md + "\n\n"
     else:
@@ -256,8 +217,8 @@ def generate_enumeration_markdown(enumeration, enumerations):
 
         # 1) Handle TypeUnion
         if ptype == 'TypeUnion':
-            content += f"## {get_translation("Type")}\n\n{get_translation("Enumeration")}\n\n"
-            content += f"## {get_translation("Values")}\n\n"
+            content += "## Type\n\nEnumeration\n\n"
+            content += "## Values\n\n"
             for raw_t in enumeration['type']['names']:
                 # Attempt linking
                 if any(enum['name'] == raw_t for enum in enumerations):
@@ -268,11 +229,11 @@ def generate_enumeration_markdown(enumeration, enumerations):
 
         # 2) Handle TypeApplication (e.g. Object.<string, string>)
         elif ptype == 'TypeApplication':
-            content += f"## {get_translation("Type")}\n\n{get_translation("Object")}\n\n"
+            content += "## Type\n\nObject\n\n"
             type_names = enumeration['type'].get('names', [])
             if type_names:
                 t_md = generate_data_types_markdown(type_names, enumerations)
-                content += f"**{get_translation("Type")}:** {t_md}\n\n"
+                content += f"**Type:** {t_md}\n\n"
 
         # 3) If properties are present, treat it like an object
         if enumeration.get('properties') is not None:
@@ -282,16 +243,16 @@ def generate_enumeration_markdown(enumeration, enumerations):
         if ptype not in ('TypeUnion', 'TypeApplication'):
             type_names = enumeration['type'].get('names', [])
             if type_names:
-                content += f"## {get_translation("Type")}\n\n"
+                content += "## Type\n\n"
                 t_md = generate_data_types_markdown(type_names, enumerations)
                 content += t_md + "\n\n"
 
     # Process examples array
     if examples:
         if len(examples) > 1:
-            content += f"\n\n## {get_translation("Examples")}\n\n"
+            content += "\n\n## Examples\n\n"
         else:
-            content += f"\n\n## {get_translation("Example")}\n\n"
+            content += "\n\n## Example\n\n"
 
         for i, ex_line in enumerate(examples, start=1):
             # Remove JS comments
@@ -300,15 +261,15 @@ def generate_enumeration_markdown(enumeration, enumerations):
             # Attempt splitting if the user used ```js
             if '```js' in cleaned_example:
                 comment, code = cleaned_example.split('```js', 1)
-                comment = get_translation(comment.strip())
+                comment = comment.strip()
                 code = code.strip()
                 if len(examples) > 1:
-                    content += f"**{get_translation("Example")} {i}:**\n\n{comment}\n\n"
+                    content += f"**Example {i}:**\n\n{comment}\n\n"
                 
                 content += f"```javascript\n{code}\n```\n"
             else:
                 if len(examples) > 1:
-                    content += f"**{get_translation("Example")} {i}:**\n\n{comment}\n\n"
+                    content += f"**Example {i}:**\n\n{comment}\n\n"
                 # No special fences, just show as code
                 content += f"```javascript\n{cleaned_example}\n```\n"
 
@@ -319,13 +280,13 @@ def generate_events_summary(events):
     Create Events.md summary listing all events with their description.
     """
     header = [
-        f"# {get_translation("Events")}\n\n",
-        f"| {get_translation("Event")} | {get_translation("Description")} |\n",
+        "# Events\n\n",
+        "| Event | Description |\n",
         "| ----- | ----------- |\n"
     ]
     lines = [
         f"| [{ev['name']}](./{ev['name']}.md) | "
-        f"{correct_description(ev.get('description', ''), '../', isInTable=True)} |\n"
+        f"{remove_line_breaks(correct_description(ev.get('description', ''), isInTable=True))} |\n"
         for ev in sorted(events, key=lambda e: e['name'])
     ]
     return "".join(header + lines)
@@ -334,14 +295,14 @@ def generate_properties_markdown(properties, enumerations):
     if properties is None:
         return ''
     
-    content = f"## {get_translation("Properties")}\n\n"
-    content += f"| {get_translation("Name")} | {get_translation("Type")} | {get_translation("Description")} |\n"
+    content = "## Properties\n\n"
+    content += "| Name | Type | Description |\n"
     content += "| ---- | ---- | ----------- |\n"
 
     for prop in sorted(properties, key=lambda m: m['name']):
         prop_name = prop['name']
         prop_description = prop.get('description', 'No description provided.')
-        prop_description = correct_description(prop_description, isInTable=True)
+        prop_description = remove_line_breaks(correct_description(prop_description, isInTable=True))
         prop_types = prop['type']['names'] if prop.get('type') else []
         param_types_md = generate_data_types_markdown(prop_types, enumerations)
         content += f"| {prop_name} | {param_types_md} | {prop_description} |\n"
@@ -410,20 +371,7 @@ def process_events(data, editor_dir):
     # events summary
     write_markdown_file(os.path.join(events_dir, "Events.md"), generate_events_summary(events))
 
-def generate_events(output_dir, translations_file):
-    global translations
-    global translations_lang
-    global global_output_dir
-    global_output_dir = output_dir
-
-    if translations_file is not None and os.path.exists(translations_file):
-        translations = load_json(translations_file)
-        translations_lang = os.path.splitext(os.path.basename(translations_file))[0]
-    else:
-        translations = {}
-
-    os.chdir(os.path.dirname(script_path))
-    
+def generate_events(output_dir):
     if output_dir.endswith('/'):
         output_dir = output_dir[:-1]
     tmp = os.path.join(output_dir, 'tmp_json')
@@ -434,21 +382,6 @@ def generate_events(output_dir, translations_file):
         data = load_json(os.path.join(tmp, f"{editor_name}.json"))
         process_events(data, os.path.join(output_dir, folder))
 
-    if translations_file is not None:
-        target_dir = os.path.dirname(translations_file)
-        
-        missed_file_path = os.path.join(target_dir, "missed_translations.json")
-        print(f'Saving missed translations to: {missed_file_path}')
-        with open(missed_file_path, 'w', encoding='utf-8') as f:
-            json.dump(missed_translations, f, ensure_ascii=False, indent=4)
-
-        unused_keys = set(translations.keys()) - set(used_translations_keys.keys())
-        unused_data = {k: translations[k] for k in unused_keys}
-        unused_file_path = os.path.join(target_dir, "unused_translations.json")
-        print(f'Saving unused translations to: {unused_file_path}')
-        with open(unused_file_path, 'w', encoding='utf-8') as f:
-            json.dump(unused_data, f, ensure_ascii=False, indent=4)    
-    
     shutil.rmtree(tmp)
     print("Done. Missing examples:", missing_examples)
 
@@ -458,17 +391,8 @@ if __name__ == "__main__":
     parser.add_argument(
         "destination",
         nargs="?",
-        default=f"{root}/api.onlyoffice.com/site/docs/plugin-and-macros/interacting-with-editors/",
+        default="../../../../../api.onlyoffice.com/site/docs/plugin-and-macros/interacting-with-editors/",
         help="Output directory"
     )
-    parser.add_argument(
-        "--translations", 
-        type=str, 
-        help="Path to the JSON file with translations",
-        nargs='?',
-        default=None
-    )
-    
     args = parser.parse_args()
-
-    generate_events(args.destination, args.translations)
+    generate_events(args.destination)

scripts/sdkjs_common/jsdoc/plugins/generate_docs_methods_json.py

@@ -10,16 +10,12 @@ configs = [
     "./config/methods/word.json",
     "./config/methods/cell.json",
     "./config/methods/slide.json",
-    "./config/methods/forms.json",
-    "./config/methods/pdf.json"
+    "./config/methods/forms.json"
 ]
 
-script_path = os.path.abspath(__file__)
-root = os.path.abspath(os.path.join(os.path.dirname(script_path), '../../../../..'))
+root = '../../../../..'
 
 def generate(output_dir, md=False):
-    os.chdir(os.path.dirname(script_path))
-    
     if not os.path.exists(output_dir):
         os.makedirs(output_dir)
 

scripts/sdkjs_common/jsdoc/plugins/generate_docs_methods_md.py

@@ -4,52 +4,19 @@ import re
 import shutil
 import argparse
 import generate_docs_methods_json
-import json
-from pathlib import PurePosixPath
 
 # Configuration files
 editors = {
     "word": "text-document-api",
     "cell": "spreadsheet-api",
     "slide": "presentation-api",
-    "forms": "form-api",
-    "pdf": "pdf-api"
+    "forms": "form-api"
 }
 
-script_path = os.path.abspath(__file__)
-root = os.path.abspath(os.path.join(os.path.dirname(script_path), '../../../../..'))
-
 missing_examples = []
 used_enumerations = set()
-translations = {}
-translations_lang = None
-missed_translations = {}
-used_translations_keys = {}
-global_output_dir = ""
-cur_editor_name = None
 
-def find_common_path_part(path_full: str, path_suffix: str, anchor: str) -> str:
-    path_full = path_full.replace('\\', '/')
-    path_suffix = path_suffix.replace('\\', '/')
-    
-    parts1 = PurePosixPath(path_full).parts
-    parts2 = PurePosixPath(path_suffix).parts
-    
-    try:
-        idx1 = [p.lower() for p in parts1].index(anchor.lower())
-        idx2 = [p.lower() for p in parts2].index(anchor.lower())
-    except ValueError:
-        return ""
-        
-    common_segments = []
-    
-    for p1, p2 in zip(parts1[idx1:], parts2[idx2:]):
-        if p1.lower() == p2.lower(): 
-            common_segments.append(p1)
-        else:
-            break
-            
-    return "/".join(common_segments)
+cur_editor_name = None
 
 def load_json(file_path):
     with open(file_path, 'r', encoding='utf-8') as f:
@@ -64,21 +31,6 @@ def remove_js_comments(text):
     text = re.sub(r'/\*.*?\*/', '', text, flags=re.DOTALL)     # multi-line
     return text.strip()
 
-def get_translation(key):
-    def process_part(k):
-        if k not in translations:
-            missed_translations[k] = k
-        else:
-            used_translations_keys[k] = True
-        return translations.get(k, k)
-
-    if '\\\n' in key:
-        parts = key.split('\\\n')
-        translated_parts = [process_part(p) for p in parts]
-        return '\\\n'.join(translated_parts)
-    
-    return process_part(key)
-
 def process_link_tags(text, root=''):
     """
     Finds patterns like {@link ...} and replaces them with Markdown links.
@@ -86,28 +38,36 @@ def process_link_tags(text, root=''):
     otherwise, a link to a class method is created.
     For a method, if an alias is not specified, the name is left in the format 'Class#Method'.
     """
-    
+    reserved_links = {
+        '/docbuilder/global#ShapeType': f"{'../../../../../' if root == '' else '../../../../' if root == '../' else root}docs/office-api/usage-api/text-document-api/Enumeration/ShapeType.md",
+        '/plugin/config': 'https://api.onlyoffice.com/docs/plugin-and-macros/structure/configuration/',
+        '/docbuilder/basic': 'https://api.onlyoffice.com/docs/office-api/usage-api/text-document-api/'
+    }
+
     def replace_link(match):
-        content = match.group(1).strip()  # Example: "global#ShapeType shape type" or "global#ErrorValue ErrorValue
+        content = match.group(1).strip()  # Example: "/docbuilder/global#ShapeType shape type" or "global#ErrorValue ErrorValue"
         parts = content.split()
         ref = parts[0]
         label = parts[1] if len(parts) > 1 else None
 
-        if ref.startswith('/docs/'):
-            url = root + '../../../..' + ref
-            display_text = label if label else ref
-            
-            if url.endswith('/'):
-                last_dir = url.rstrip('/').split('/')[-1]
-                url = f"{url}{last_dir}"
-        
-            return f"[{display_text}]({url}.md)"
+        if ref.startswith('/'):
+            # Handle reserved links using mapping
+            if ref in reserved_links:
+                url = reserved_links[ref]
+                display_text = label if label else ref
+                return f"[{display_text}]({url})"
+            else:
+                # If the link is not in the mapping, return the original construction
+                return match.group(0)
         elif ref.startswith("global#"):
             # Handle links to typedef (similar logic as before)
             typedef_name = ref.split("#")[1]
             used_enumerations.add(typedef_name)
             display_text = label if label else typedef_name
             return f"[{display_text}]({root}Enumeration/{typedef_name}.md)"
+        elif ref.startswith("https"):
+            display_text = label if label else ref  # Keep the full notation, e.g., "Api#CreateSlide"
+            return f"[{display_text}]({ref})"
         else:
             # Handle links to class methods like ClassName#MethodName
             try:
@@ -129,7 +89,7 @@ def correct_description(string, root='', isInTable=False):
       - All '\r' characters are replaced with '\n'.
     """
     if string is None:
-        return get_translation('No description provided.')
+        return 'No description provided.'
 
     if False == isInTable:
         # Line breaks
@@ -138,7 +98,6 @@ def correct_description(string, root='', isInTable=False):
         string = re.sub(r'<b>', '-**', string)
     else:
         string = re.sub(r'<b>', '**', string)
-        string = remove_line_breaks(string)
     
     string = re.sub(r'</b>', '**', string)
     
@@ -148,7 +107,7 @@ def correct_description(string, root='', isInTable=False):
     # Process {@link ...} constructions
     string = process_link_tags(string, root)
     
-    return get_translation(string)
+    return string
 
 def correct_default_value(value, enumerations, classes):
     if value is None or value == '':
@@ -346,12 +305,12 @@ def generate_data_types_markdown(types, enumerations, classes, root='../'):
     return param_types_md
 
 def generate_class_markdown(class_name, methods, properties, enumerations, classes):
-    content = f"# {class_name}\n\n{get_translation(f"Represents the {class_name} class.")}\n\n"
+    content = f"# {class_name}\n\nRepresents the {class_name} class.\n\n"
     
     content += generate_properties_markdown(properties, enumerations, classes)
 
-    content += f"\n## {get_translation("Methods")}\n\n"
-    content += f"| {get_translation("Method")} | {get_translation("Returns")} | {get_translation("Description")} |\n"
+    content += "\n## Methods\n\n"
+    content += "| Method | Returns | Description |\n"
     content += "| ------ | ------- | ----------- |\n"
     
     for method in sorted(methods, key=lambda m: m['name']):
@@ -363,10 +322,10 @@ def generate_class_markdown(class_name, methods, properties, enumerations, class
             return_type_list = returns[0].get('type', {}).get('names', [])
             returns_markdown = generate_data_types_markdown(return_type_list, enumerations, classes, '../')
         else:
-            returns_markdown = get_translation("None")
+            returns_markdown = "None"
         
         # Processing the method description
-        description = correct_description(method.get('description', 'No description provided.'), '../', True)
+        description = remove_line_breaks(correct_description(method.get('description', 'No description provided.'), '../', True))
         
         # Form a link to the method document
         method_link = f"[{method_name}](./{method_name}.md)"
@@ -395,42 +354,42 @@ def generate_method_markdown(method, enumerations, classes):
     
     # Syntax
     param_list = ', '.join([param['name'] for param in params if '.' not in param['name']]) if params else ''
-    content += f"## {get_translation("Syntax")}\n\n```javascript\nexpression.{method_name}({param_list});\n```\n\n"
+    content += f"## Syntax\n\n```javascript\nexpression.{method_name}({param_list});\n```\n\n"
     if memberof:
-        content += f"`expression` - {get_translation(f"A variable that represents a [{memberof}](Methods.md) class.")}\n\n"
+        content += f"`expression` - A variable that represents a [{memberof}](Methods.md) class.\n\n"
 
     # Parameters
-    content += f"## {get_translation("Parameters")}\n\n"
+    content += "## Parameters\n\n"
     if params:
-        content += f"| **{get_translation("Name")}** | **{get_translation("Required/Optional")}** | **{get_translation("Data type")}** | **{get_translation("Default")}** | **{get_translation("Description")}** |\n"
+        content += "| **Name** | **Required/Optional** | **Data type** | **Default** | **Description** |\n"
         content += "| ------------- | ------------- | ------------- | ------------- | ------------- |\n"
         for param in params:
             param_name = param.get('name', 'Unnamed')
             param_types = param.get('type', {}).get('names', []) if param.get('type') else []
             param_types_md = generate_data_types_markdown(param_types, enumerations, classes)
-            param_desc = correct_description(param.get('description', 'No description provided.'), '../', True)
-            param_required = get_translation("Required") if not param.get('optional') else get_translation("Optional")
+            param_desc = remove_line_breaks(correct_description(param.get('description', 'No description provided.'), '../', True))
+            param_required = "Required" if not param.get('optional') else "Optional"
             param_default = correct_default_value(param.get('defaultvalue', ''), enumerations, classes)
 
             content += f"| {param_name} | {param_required} | {param_types_md} | {param_default} | {param_desc} |\n"
     else:
-        content += f"{get_translation("This method doesn't have any parameters.")}\n"
+        content += "This method doesn't have any parameters.\n"
 
     # Returns
-    content += f"\n## {get_translation("Returns")}\n\n"
+    content += "\n## Returns\n\n"
     if returns:
         return_type_list = returns[0].get('type', {}).get('names', [])
         return_type_md = generate_data_types_markdown(return_type_list, enumerations, classes)
         content += return_type_md
     else:
-        content += get_translation("This method doesn't return any data.")
+        content += "This method doesn't return any data."
 
     # Process examples array
     if examples:
         if len(examples) > 1:
-            content += f"\n\n## {get_translation("Examples")}\n\n"
+            content += "\n\n## Examples\n\n"
         else:
-            content += f"\n\n## {get_translation("Example")}\n\n"
+            content += "\n\n## Example\n\n"
 
         for i, ex_line in enumerate(examples, start=1):
             # Remove JS comments
@@ -439,15 +398,15 @@ def generate_method_markdown(method, enumerations, classes):
             # Attempt splitting if the user used ```js
             if '```js' in cleaned_example:
                 comment, code = cleaned_example.split('```js', 1)
-                comment = get_translation(comment.strip())
+                comment = comment.strip()
                 code = code.strip()
                 if len(examples) > 1:
-                    content += f"**{get_translation("Example")} {i}:**\n\n{comment}\n\n"
+                    content += f"**Example {i}:**\n\n{comment}\n\n"
                 
                 content += f"```javascript\n{code}\n```\n"
             else:
                 if len(examples) > 1:
-                    content += f"**{get_translation("Example")} {i}:**\n\n{comment}\n\n"
+                    content += f"**Example {i}:**\n\n{comment}\n\n"
                 # No special fences, just show as code
                 content += f"```javascript\n{cleaned_example}\n```\n"
 
@@ -457,14 +416,14 @@ def generate_properties_markdown(properties, enumerations, classes, root='../'):
     if properties is None:
         return ''
     
-    content = f"## {get_translation("Properties")}\n\n"
-    content += f"| {get_translation("Name")} | {get_translation("Type")} | {get_translation("Description")} |\n"
+    content = "## Properties\n\n"
+    content += "| Name | Type | Description |\n"
     content += "| ---- | ---- | ----------- |\n"
 
     for prop in sorted(properties, key=lambda m: m['name']):
         prop_name = prop['name']
         prop_description = prop.get('description', 'No description provided.')
-        prop_description = correct_description(prop_description, root, isInTable=True)
+        prop_description = remove_line_breaks(correct_description(prop_description, isInTable=True))
         prop_types = prop['type']['names'] if prop.get('type') else []
         param_types_md = generate_data_types_markdown(prop_types, enumerations, classes, root)
         content += f"| {prop_name} | {param_types_md} | {prop_description} |\n"
@@ -496,7 +455,7 @@ def generate_enumeration_markdown(enumeration, enumerations, classes):
         # If parsedType is missing, just list 'type.names' if available
         type_names = enumeration['type'].get('names', [])
         if type_names:
-            content += f"## {get_translation("Type")}\n\n"
+            content += "## Type\n\n"
             t_md = generate_data_types_markdown(type_names, enumerations, classes)
             content += t_md + "\n\n"
     else:
@@ -504,8 +463,8 @@ def generate_enumeration_markdown(enumeration, enumerations, classes):
 
         # 1) Handle TypeUnion
         if ptype == 'TypeUnion':
-            content += f"## {get_translation("Type")}\n\n{get_translation("Enumeration")}\n\n"
-            content += f"## {get_translation("Values")}\n\n"
+            content += "## Type\n\nEnumeration\n\n"
+            content += "## Values\n\n"
             for raw_t in enumeration['type']['names']:
                 # Attempt linking
                 if any(enum['name'] == raw_t for enum in enumerations):
@@ -518,11 +477,11 @@ def generate_enumeration_markdown(enumeration, enumerations, classes):
 
         # 2) Handle TypeApplication (e.g. Object.<string, string>)
         elif ptype == 'TypeApplication':
-            content += f"## {get_translation("Type")}\n\n{get_translation("Object")}\n\n"
+            content += "## Type\n\nObject\n\n"
             type_names = enumeration['type'].get('names', [])
             if type_names:
                 t_md = generate_data_types_markdown(type_names, enumerations, classes)
-                content += f"**{get_translation("Type")}:** {t_md}\n\n"
+                content += f"**Type:** {t_md}\n\n"
 
         # 3) If properties are present, treat it like an object
         if enumeration.get('properties') is not None:
@@ -532,16 +491,16 @@ def generate_enumeration_markdown(enumeration, enumerations, classes):
         if ptype not in ('TypeUnion', 'TypeApplication'):
             type_names = enumeration['type'].get('names', [])
             if type_names:
-                content += f"## {get_translation("Type")}\n\n"
+                content += "## Type\n\n"
                 t_md = generate_data_types_markdown(type_names, enumerations, classes)
                 content += t_md + "\n\n"
 
     # Process examples array
     if examples:
         if len(examples) > 1:
-            content += f"\n\n## {get_translation("Examples")}\n\n"
+            content += "\n\n## Examples\n\n"
         else:
-            content += f"\n\n## {get_translation("Example")}\n\n"
+            content += "\n\n## Example\n\n"
 
         for i, ex_line in enumerate(examples, start=1):
             # Remove JS comments
@@ -550,15 +509,15 @@ def generate_enumeration_markdown(enumeration, enumerations, classes):
             # Attempt splitting if the user used ```js
             if '```js' in cleaned_example:
                 comment, code = cleaned_example.split('```js', 1)
-                comment = get_translation(comment.strip())
+                comment = comment.strip()
                 code = code.strip()
                 if len(examples) > 1:
-                    content += f"**{get_translation("Example")} {i}:**\n\n{comment}\n\n"
+                    content += f"**Example {i}:**\n\n{comment}\n\n"
                 
                 content += f"```javascript\n{code}\n```\n"
             else:
                 if len(examples) > 1:
-                    content += f"**{get_translation("Example")} {i}:**\n\n{comment}\n\n"
+                    content += f"**Example {i}:**\n\n{comment}\n\n"
                 # No special fences, just show as code
                 content += f"```javascript\n{cleaned_example}\n```\n"
 
@@ -654,20 +613,7 @@ def process_doclets(data, output_dir, editor_name):
         if not enum.get('examples', ''):
             missing_examples.append(os.path.relpath(enum_file_path, output_dir))
 
-def generate(output_dir, translations_file):
-    global translations
-    global translations_lang
-    global global_output_dir
-    global_output_dir = output_dir
-    
-    if translations_file is not None and os.path.exists(translations_file):
-        translations = load_json(translations_file)
-        translations_lang = os.path.splitext(os.path.basename(translations_file))[0]
-    else:
-        translations = {}
-        
-    os.chdir(os.path.dirname(script_path))
-
+def generate(output_dir):
     print('Generating Markdown documentation...')
     
     if output_dir[-1] == '/':
@@ -681,21 +627,6 @@ def generate(output_dir, translations_file):
         used_enumerations.clear()
         process_doclets(data, output_dir, editor_name)
     
-    if translations_file is not None:
-        target_dir = os.path.dirname(translations_file)
-        
-        missed_file_path = os.path.join(target_dir, "missed_translations.json")
-        print(f'Saving missed translations to: {missed_file_path}')
-        with open(missed_file_path, 'w', encoding='utf-8') as f:
-            json.dump(missed_translations, f, ensure_ascii=False, indent=4)
-
-        unused_keys = set(translations.keys()) - set(used_translations_keys.keys())
-        unused_data = {k: translations[k] for k in unused_keys}
-        unused_file_path = os.path.join(target_dir, "unused_translations.json")
-        print(f'Saving unused translations to: {unused_file_path}')
-        with open(unused_file_path, 'w', encoding='utf-8') as f:
-            json.dump(unused_data, f, ensure_ascii=False, indent=4)   
-        
     shutil.rmtree(output_dir + '/tmp_json')
     print('Done')
 
@@ -706,19 +637,10 @@ if __name__ == "__main__":
         type=str, 
         help="Destination directory for the generated documentation",
         nargs='?',  # Indicates the argument is optional
-        default=f"{root}/api.onlyoffice.com/site/docs/plugin-and-macros/interacting-with-editors/"  # Default value
+        default="../../../../../api.onlyoffice.com/site/docs/plugin-and-macros/interacting-with-editors/"  # Default value
     )
-    parser.add_argument(
-        "--translations", 
-        type=str, 
-        help="Path to the JSON file with translations",
-        nargs='?',
-        default=None
-    )
-    
     args = parser.parse_args()
-    
-    generate(args.destination, args.translations)
+    generate(args.destination)
     print("START_MISSING_EXAMPLES")
     print(",".join(missing_examples))
     print("END_MISSING_EXAMPLES")

sln.json

@@ -13,11 +13,9 @@
     "core/UnicodeConverter/UnicodeConverter.pro",
     "core/Common/kernel.pro",
     "core/Common/Network/network.pro",
-
-    "core/OdfFile/Reader/Converter/StarMath2OOXML/StarMath2OOXML.pro",
-
+    
     "core/DesktopEditor/graphics/pro/graphics.pro",
-
+    
     "core/PdfFile/PdfFile.pro",
     "core/DjVuFile/DjVuFile.pro",
     "core/XpsFile/XpsFile.pro",
@@ -29,12 +27,10 @@
 
     "core/Apple/IWork.pro",
 
-    "core/DocxRenderer/DocxRenderer.pro",
+    "core/DocxRenderer/DocxRenderer.pro",   
 
     "core/DesktopEditor/doctrenderer/doctrenderer.pro",
 
-    "core/DesktopEditor/xmlsec/src/ooxmlsignature.pro",
-
     "[!no_x2t]core/OOXML/Projects/Linux/DocxFormatLib/DocxFormatLib.pro",
     "[!no_x2t]core/OOXML/Projects/Linux/PPTXFormatLib/PPTXFormatLib.pro",
     "[!no_x2t]core/OOXML/Projects/Linux/XlsbFormatLib/XlsbFormatLib.pro",
@@ -83,17 +79,19 @@
   "multimedia" : [
     "[win,linux]desktop-sdk/ChromiumBasedEditors/videoplayerlib/videoplayerlib.pro"
   ],
-
+  
   "desktop" : [
     "core",
     "multimedia",
+    
+    "core/DesktopEditor/xmlsec/src/ooxmlsignature.pro",
 
     "desktop-sdk/ChromiumBasedEditors/lib/ascdocumentscore.pro",
     "desktop-sdk/ChromiumBasedEditors/lib/ascdocumentscore_helper.pro",
 
     "[win,linux]desktop-sdk/ChromiumBasedEditors/lib/qt_wrapper/qtascdocumentscore.pro",
     "[win,linux]desktop-apps/win-linux/ASCDocumentEditor.pro",
-
+    
     "[win]desktop-apps/win-linux/extras/projicons/ProjIcons.pro",
     "[win,!win_xp]desktop-apps/win-linux/extras/update-daemon/UpdateDaemon.pro"
   ],

tools/common/thumbnails_auto.py

@@ -1,54 +0,0 @@
-#!/usr/bin/env python
-
-import sys
-sys.path.append('../../scripts')
-import base
-import os
-import glob
-from pathlib import Path
-
-params = sys.argv[1:]
-
-if (3 != len(params)):
-  print("use: thumbnails_auto.py path_to_builder_directory path_to_input_files_directory path_to_output_files_directory")
-  exit(0)
-
-base.configure_common_apps()
-
-directory_x2t = params[0].replace("\\", "/")
-directory_input = params[1].replace("\\", "/")
-directory_output = params[2].replace("\\", "/")
-
-
-if not os.path.exists(directory_output):
-  os.mkdir(directory_output)
-
-def rename_dir(input, output):
-  if base.is_dir(u"" + directory_output + u"/" + output):
-    base.delete_dir(u"" + directory_output + u"/" + output)
-  os.rename(u"" + directory_output + u"/" + input, u"" + directory_output + u"/" + output)
-  return
-
-base.cmd("python", ["thumbnails_old.py", directory_x2t, directory_input, directory_output, "512", "724"])
-base.cmd("python", ["thumbnails_old.py", directory_x2t, directory_input, directory_output, "1024", "1448"])
-base.cmd("python", ["thumbnails_old.py", directory_x2t, directory_input, directory_output, "324", "458"])
-base.cmd("python", ["thumbnails_old.py", directory_x2t, directory_input, directory_output, "648", "916"])
-base.cmd("python", ["thumbnails_old.py", directory_x2t, directory_input, directory_output, "256", "368"])
-
-base.cmd("python", ["thumbnails_old.py", directory_x2t, directory_input, directory_output, "400", "566"])
-base.cmd("python", ["thumbnails_old.py", directory_x2t, directory_input, directory_output, "184", "260"])
-#base.cmd("python", ["thumbnails.py", directory_x2t, directory_input, directory_output, "792", "1098"])
-
-#rename_dir("[512x724]", "inside_1x_[512x724]")
-#rename_dir("[1024x1448]", "inside_2x_[1024x1448]")
-#rename_dir("[228x316]", "main_1x_[228x316]")
-#rename_dir("[456x632]", "main_2x_[456x632]")
-#rename_dir("[256x368]", "mobile_[256x368]")
-#rename_dir("[792x1098]", "source_[792x1098]")
-
-dirnames = list(Path(directory_output).iterdir())
-for dir_name in dirnames:
-  if len(list(Path(dir_name).iterdir())) == 0:
-    print("Delete dir ", dir_name)
-    Path(dir_name).rmdir()
-    #base.delete_dir(dir_name)

tools/common/thumbnails_old.py

@@ -1,274 +0,0 @@
-#!/usr/bin/env python
-
-import sys
-sys.path.append('../../scripts')
-import base
-import os
-import glob
-import imagesize
-import importlib.util
-from pathlib import Path
-from os.path import dirname, abspath, join
-
-# Python 3 compatibility hack
-try:
-    unicode('')
-except NameError:
-    unicode = str
-
-
-params = sys.argv[1:]
-
-if (5 != len(params)):
-  print("use: thumbnails.py path_to_builder_directory path_to_input_files_directory path_to_output_files_directory width height")
-  exit(0)
-
-mapping = {"[512x724]": "inside_1x_[512x724]",
-        "[1024x1448]": "inside_2x_[1024x1448]",
-        "[228x316]": "main_1x_[228x316]",
-        "[456x632]": "main_2x_[456x632]",
-        "[256x368]": "mobile_[256x368]",
-        "[792x1098]": "source_[792x1098]",
-        "[324x458]": "main_1x_[324x458]",
-        "[648x916]": "main_2x_[648x916]",
-		"[400x566]": "pop_up_[400x566]",
-        "[184x260]": "desktop[184x260]",
-}
-
-cur_path = os.getcwd()
-base.configure_common_apps()
-
-directory_x2t = params[0].replace("\\", "/")
-directory_input = params[1].replace("\\", "/")
-directory_output = params[2].replace("\\", "/")
-th_width = params[3]
-th_height = params[4]
-
-docbuilder_path = os.path.join(directory_x2t, "docbuilder.py")
-if not os.path.isfile(docbuilder_path):
-    print(f"ERROR: docbuilder.py not found in '{directory_x2t}'")
-    exit(1)
-
-spec = importlib.util.spec_from_file_location("docbuilder", docbuilder_path)
-docbuilder_mod = importlib.util.module_from_spec(spec)
-spec.loader.exec_module(docbuilder_mod)
-
-CDocBuilder      = docbuilder_mod.CDocBuilder
-CDocBuilderValue = docbuilder_mod.CDocBuilderValue
-
-#output_dir = directory_output + "/[" + str(th_width) + "x" + str(th_height) + "]"
-#if base.is_dir(output_dir):
-#  base.delete_dir(output_dir)
-#base.create_dir(output_dir)
-
-input_files = []
-for file in glob.glob(os.path.join(u"" + directory_input, u'*')):
-  input_files.append(file.replace("\\", "/"))
-
-#print(input_files)
-temp_dir = os.getcwd().replace("\\", "/") + "/temp"
-if base.is_dir(temp_dir):
-  base.delete_dir(temp_dir)
-base.create_dir(temp_dir)
-
-directory_fonts = directory_x2t + "/sdkjs/common"
-if not base.is_file(directory_fonts + "/AllFonts.js"):
-  base.cmd_in_dir(directory_x2t, "docbuilder", [], True)
-
-# # True for fit, False for 100%
-# isScaleSheetToPage = False
-#
-# json_fit_text = "0"
-# if isScaleSheetToPage:
-#   json_fit_text = "1"
-#
-# #json_params += "'fitToWidth':" + json_fit_text + ",'fitToHeight':" + json_fit_text + ","
-# if isScaleSheetToPage:
-#   json_params = "{'spreadsheetLayout':{'fitToWidth':1,'fitToHeight':1},"
-# else:
-#   json_params = "{'spreadsheetLayout':{'fitToWidth':0,'fitToHeight':0},"
-# json_params += "'documentLayout':{'drawPlaceHolders':true,'drawFormHighlight':true,'isPrint':true}}"
-# json_params = json_params.replace("'", """)
-
-
-json_params = "{"
-
-json_params += "'spreadsheetLayout':{"
-
-# True for fit, False for 100%
-isScaleSheetToPage = False
-
-json_fit_text = "0"
-if isScaleSheetToPage:
-  json_fit_text = "1"
-
-json_params += "'fitToWidth':" + json_fit_text + ",'fitToHeight':" + json_fit_text + ","
-
-if True:
-  json_params += "'orientation':'landscape',"
-
-page_margins = "'pageMargins':{'bottom':10,'footer':5,'header':5,'left':5,'right':5,'top':10}"
-page_setup = "'pageSetup':{'orientation':1,'width':210,'height':297,'paperUnits':0,'scale':190," \
-             "'printArea':false,'horizontalDpi':600,'verticalDpi':600,'usePrinterDefaults':true,'fitToHeight':1,'fitToWidth':1}"
-
-json_params += "'sheetsProps':{'0':{'headings':false,'printTitlesWidth':null,'printTitlesHeight':null," + page_margins + "," + page_setup + "}}},"
-
-json_params += "'documentLayout':{'drawPlaceHolders':true,'drawFormHighlight':true,'isPrint':true},"
-json_params += "'ignorePrintArea':'false'"
-json_params += "}"
-json_params = json_params.replace("'", """)
-
-if not os.path.exists(directory_output):
-  os.mkdir(directory_output)
-
-output_len = len(input_files)
-output_cur = 1
-for input_file in input_files:
-  if os.path.isdir(input_file):
-    next_dir_name = os.path.basename(input_file)
-    base.cmd("python", ["thumbnails_old.py", directory_x2t, input_file, os.path.join(directory_output, next_dir_name), th_width, th_height])
-    if base.is_dir(temp_dir):
-      base.delete_dir(temp_dir)
-    base.create_dir(temp_dir)
-    continue
-  print("process [" + str(output_cur) + " of " + str(output_len) + "]: " + str(input_file.encode("utf-8")))
-
-  width_page = th_width
-  height_page = th_height
-
-  json_params_file = json_params
-
-  if input_file.lower().endswith('.xlsx'):
-    temp_dir_builder = directory_output + "/temp_builder"
-    if base.is_dir(temp_dir_builder):
-      base.delete_dir(temp_dir_builder)
-    base.create_dir(temp_dir_builder)
-    builder = CDocBuilder()
-    builder.SetTmpFolder(temp_dir_builder)
-
-    builder.OpenFile(input_file)
-    context = builder.GetContext()
-    globalObj = context.GetGlobal()
-
-    cmd = """
-(function(){
-Api.getPrintAreaSize = function() {
-  return { Width:0, Height:0 };
-};
-var sheet = Api.GetSheets()[0];
-var usedRange = sheet.GetUsedRange();
-
-var maxCol = -1;
-var maxRow = -1;
-usedRange.ForEach(function (cell) {
-    if (cell.GetRowHeight() === 0 || cell.GetColumnWidth() === 0) {
-        return;
-    }
-    var row0 = cell.GetRow() - 1;
-    var col0 = cell.GetCol() - 1;
-    var hasContent = false;
-    var val = cell.GetValue();
-    if (val !== "" && val !== null && val !== undefined) {
-        hasContent = true;
-    }
-    if (!hasContent) {
-        var formula = cell.GetFormula();
-        if (typeof formula === 'string' && formula.indexOf("=") === 0) {
-            hasContent = true;
-        }
-    }
-    if (hasContent) {
-        if (col0 > maxCol) maxCol = col0;
-        if (row0 > maxRow) maxRow = row0;
-    }
-});
-if (maxRow < 0 || maxCol < 0) {
-    return;
-}
-var printRange = sheet.GetRange(
-    sheet.GetRangeByNumber(0, 0),
-    sheet.GetRangeByNumber(maxRow, maxCol)
-);
-Api.getPrintAreaSize = function() {
-  return { Width:printRange.Width, Height:printRange.Height };
-};})();
-"""
-
-    builder.ExecuteCommand(cmd)
-    api = globalObj['Api']
-
-    sizeWH = api.getPrintAreaSize()
-    wPrint = sizeWH.Get("Width").ToDouble()
-    hPrint = sizeWH.Get("Height").ToDouble()
-
-    print("CELL (printSize): " + str(wPrint) + "x" + str(hPrint))
-
-    if (wPrint > 1 and hPrint > wPrint):
-      tmp = width_page
-      width_page = height_page
-      height_page = tmp
-      json_params_file = json_params_file.replace("&quot;width&quot;:210,&quot;height&quot;:297", "&quot;width&quot;:297,&quot;height&quot;:210")
-
-    builder.CloseFile()
-    base.delete_dir(temp_dir_builder)
-
-  output_dir = os.path.join(directory_output,
-                            os.path.splitext(os.path.basename(input_file))[0])
-  #output_dir = str(output_dir.encode("utf8"))
-  output_dir = abspath(unicode(output_dir))
-  if not os.path.exists(output_dir):
-    os.mkdir(output_dir)
-  output_dir = os.path.join(output_dir,
-                            mapping["[" + str(th_width) + "x" + str(th_height) + "]"])
-  #output_dir = str(output_dir.encode("utf8"))
-  #output_dir = dirname(abspath(unicode(output_dir)))
-  output_dir = abspath(unicode(output_dir))
-  if not os.path.exists(output_dir):
-    os.mkdir(output_dir)
-  output_file = output_dir # os.path.join(output_dir, os.path.splitext(os.path.basename(input_file))[0])
-  xml_convert = u"<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
-  xml_convert += u"<TaskQueueDataConvert>"
-  xml_convert += (u"<m_sFileFrom>" + input_file + u"</m_sFileFrom>")
-  xml_convert += (u"<m_sFileTo>" + output_file + u".zip</m_sFileTo>")
-  xml_convert += u"<m_nFormatTo>1029</m_nFormatTo>"
-  xml_convert += (u"<m_sAllFontsPath>" + directory_fonts + u"/AllFonts.js</m_sAllFontsPath>")
-  xml_convert += (u"<m_sFontDir>" + directory_fonts + u"</m_sFontDir>")
-  xml_convert += (u"<m_sJsonParams>" + json_params_file + u"</m_sJsonParams>")
-  xml_convert += u"<m_nDoctParams>1</m_nDoctParams>"
-  xml_convert += u"<m_oThumbnail>"
-  xml_convert += u"<first>false</first>"
-
-  if ((0 != width_page) and (0 != height_page)):
-    xml_convert += u"<aspect>16</aspect>"
-    xml_convert += (u"<width>" + str(width_page) + u"</width>")
-    xml_convert += (u"<height>" + str(height_page) + u"</height>")
-  xml_convert += u"</m_oThumbnail>"
-  xml_convert += u"<m_nDoctParams>1</m_nDoctParams>"
-  xml_convert += (u"<m_sTempDir>" + temp_dir + u"</m_sTempDir>")
-  xml_convert += u"</TaskQueueDataConvert>"
-  base.save_as_script(temp_dir + "/to.xml", [xml_convert])
-  base.cmd_in_dir(directory_x2t, "x2t", [temp_dir + "/to.xml"], True)
-  base.delete_dir(temp_dir)
-  base.create_dir(temp_dir)
-  base.extract_unicode(output_file + u".zip", output_file)
-  if os.path.exists(output_file + ".zip"):
-    try:
-      base.delete_file(output_file + ".zip")
-    except:
-      print("Error in deletin file: ", output_file + ".zip")
-  output_cur += 1
-  #output_file = output_file.replace("\\", "/")
-  #imnames = Path(output_file).glob("*.png")#glob.glob("/" + output_file.replace(":", "") + "/*.png")
-  imnames = [str(pp) for pp in Path(output_file).glob("*.png")]
-  #print(output_file + "/*.png", imnames)
-  #continue
-  if len(imnames) == 0:
-    base.delete_dir(output_file)
-  else:
-    width, height = imagesize.get(imnames[0])
-    print("WxH: ", width, height)
-    if width < height and False: #удалить вертикальные превью
-      base.delete_dir(output_file)
-
-base.delete_dir(temp_dir)
-os.chdir(cur_path)

tools/linux/.gitignore

@@ -1,5 +0,0 @@
-qt_build
-packages_complete
-python3
-python3.tar.gz
-extract.sh

tools/linux/automate.py

@@ -6,7 +6,6 @@ import base
 import os
 import subprocess
 import deps
-import qt_binary_build
 
 def get_branch_name(directory):
   cur_dir = os.getcwd()
@@ -58,7 +57,12 @@ def install_qt():
   return
   
 def install_qt_prebuild():
-  base.cmd("python3", ["qt_binary_fetch.py", "all"])
+  url_amd64 = "https://github.com/ONLYOFFICE-data/build_tools_data/raw/refs/heads/master/qt/qt_binary_linux_amd64.7z"
+  base.download(url_amd64, "./qt_amd64.7z")
+  base.extract("./qt_amd64.7z", "./qt_build")
+  base.create_dir("./qt_build/Qt-5.9.9")
+  base.cmd("mv", ["./qt_build/qt_amd64", "./qt_build/Qt-5.9.9/gcc_64"])
+  base.setup_local_qmake("./qt_build/Qt-5.9.9/gcc_64/bin")
   return
 
 if not base.is_file("./node_js_setup_14.x"):
@@ -67,10 +71,7 @@ if not base.is_file("./node_js_setup_14.x"):
 
 if not base.is_dir("./qt_build"):
   print("install qt...")
-  if base.get_env("DO_NOT_USE_PREBUILD_QT") == "1":
-    qt_binary_build.install_qt()
-  else:
-    install_qt_prebuild()
+  install_qt_prebuild()
 
 branch = get_branch_name("../..")
 

tools/linux/cmake.sh

@@ -1,5 +0,0 @@
-wget https://github.com/Kitware/CMake/releases/download/v3.30.0/cmake-3.30.0-linux-x86_64.tar.gz
-tar -xzf cmake-3.30.0-linux-x86_64.tar.gz -C /opt
-ln -s /opt/cmake-3.30.0-linux-x86_64/bin/cmake /usr/local/bin/cmake
-ln -s /opt/cmake-3.30.0-linux-x86_64/bin/ctest /usr/local/bin/ctest
-rm cmake-3.30.0-linux-x86_64.tar.gz

tools/linux/deps.py

@@ -16,7 +16,6 @@ def install_deps():
               "build-essential",
               "ca-certificates",
               "cmake",
-              "perl",
               "curl",
               "git",
               "glib-2.0-dev",
@@ -44,8 +43,7 @@ def install_deps():
               "libncurses6",
               "curl",
               "libxkbcommon-dev",
-              "libxkbcommon-x11-dev",
-              "libnotify-dev"]
+              "libxkbcommon-x11-dev"]
 
   for package in packages:
     base.cmd("sudo", ["apt-get", "install", "-y", package], True)
@@ -69,7 +67,7 @@ def install_deps():
     print("OK")
     base.cmd("sudo", ["apt-get", "-y", "install", "npm", "yarn"], True)
   base.cmd("sudo", ["npm", "install", "-g", "grunt-cli"])
-  base.cmd("sudo", ["npm", "install", "-g", "@yao-pkg/pkg@6.11.0"])
+  base.cmd("sudo", ["npm", "install", "-g", "@yao-pkg/pkg"])
 
   # java
   java_error = base.cmd("sudo", ["apt-get", "-y", "install", "openjdk-11-jdk"], True)

tools/linux/python.sh

@@ -1,16 +0,0 @@
-#!/bin/bash
-
-wget https://github.com/ONLYOFFICE-data/build_tools_data/raw/refs/heads/master/python/python3.tar.gz
-wget https://github.com/ONLYOFFICE-data/build_tools_data/raw/refs/heads/master/python/extract.sh
-
-chmod +x ./extract.sh
-./extract.sh
-
-cd ./python3/bin
-ln -s python3 python
-cd ../../
-
-rm ./extract.sh
-rm ./python3.tar.gz
-
-

tools/linux/qt_binary_build.py

@@ -1,47 +0,0 @@
-#!/usr/bin/env python
-
-import sys
-sys.path.append('../../scripts')
-import base
-import os
-import subprocess
-import deps
-
-def install_qt():
-  # qt
-  if not base.is_file("./qt_source_5.9.9.tar.xz"):
-    base.download("https://github.com/ONLYOFFICE-data/build_tools_data/raw/refs/heads/master/qt/qt-everywhere-opensource-src-5.9.9.tar.xz", "./qt_source_5.9.9.tar.xz")
-
-  if not base.is_dir("./qt-everywhere-opensource-src-5.9.9"):
-    base.cmd("tar", ["-xf", "./qt_source_5.9.9.tar.xz"])
-
-  qt_params = ["-opensource",
-               "-confirm-license",
-               "-release",
-               "-shared",
-               "-accessibility",
-               "-prefix",
-               "./../qt_build/Qt-5.9.9/gcc_64",
-               "-qt-zlib",
-               "-qt-libpng",
-               "-qt-libjpeg",
-               "-qt-xcb",
-               "-qt-pcre",
-               "-no-sql-sqlite",
-               "-no-qml-debug",
-               "-gstreamer", "1.0",
-               "-nomake", "examples",
-               "-nomake", "tests",
-               "-skip", "qtenginio",
-               "-skip", "qtlocation",
-               "-skip", "qtserialport",
-               "-skip", "qtsensors",
-               "-skip", "qtxmlpatterns",
-               "-skip", "qt3d",
-               "-skip", "qtwebview",
-               "-skip", "qtwebengine"]
-
-  base.cmd_in_dir("./qt-everywhere-opensource-src-5.9.9", "./configure", qt_params)
-  base.cmd_in_dir("./qt-everywhere-opensource-src-5.9.9", "make", ["-j", "4"])
-  base.cmd_in_dir("./qt-everywhere-opensource-src-5.9.9", "make", ["install"])
-  return

tools/linux/qt_binary_fetch.py

@@ -1,67 +0,0 @@
-#!/usr/bin/env python3
-
-import sys
-import os
-sys.path.append('../../scripts')
-
-import base
-
-URL = "https://github.com/ONLYOFFICE-data/build_tools_data/raw/refs/heads/master/qt/"
-
-SYSROOTS = {
-  "amd64": "qt_binary_5.9.9_gcc_64.7z",
-  "arm64": "qt_binary_5.9.9_gcc_arm64.7z",
-}
-
-COMPILERS = {
-  "amd64": "gcc_64",
-  "arm64": "gcc_arm64",
-}
-
-def download_and_extract(name):
-  cur_dir = os.getcwd()
-  os.chdir("./qt_build/Qt-5.9.9")
-  archive = SYSROOTS[name]
-  folder = "./" + COMPILERS[name]
-  if (base.is_dir(folder)):
-    base.delete_dir(folder)
-  archive_file = "./" + archive
-  base.download(URL + archive, archive_file)
-  base.extract(archive_file, "./")
-  os.chdir(cur_dir)
-  base.setup_local_qmake("./qt_build/Qt-5.9.9/" + COMPILERS[name] + "/bin")
-
-def main():
-  if len(sys.argv) != 2:
-    print("Usage: fetch.py [amd64|arm64|all]")
-    sys.exit(1)
-
-  target = sys.argv[1]
-
-  if not base.is_dir("./qt_build/Qt-5.9.9"):
-    base.create_dir("./qt_build/Qt-5.9.9")
-
-  targets = []
-  if ("all" == target):
-    targets.append("amd64")
-    targets.append("arm64")
-  elif ("arm64" == target) and not base.is_os_arm():
-    targets.append("amd64")
-    targets.append(target)
-  else:
-    targets.append(target)
-
-  if (0 == len(targets)):
-    print(f"Unknown target: {target}")
-    print("Valid values: amd64, arm64, all")
-    sys.exit(1)
-
-  for name in targets:
-    download_and_extract(name)
-
-  if "arm64" in targets and not base.is_os_arm():
-    base.move_dir("./qt_build/Qt-5.9.9/gcc_arm64/bin", "./qt_build/Qt-5.9.9/gcc_arm64/_bin")
-    base.copy_dir("./qt_build/Qt-5.9.9/gcc_64/bin", "./qt_build/Qt-5.9.9/gcc_arm64/bin")
-
-if __name__ == "__main__":
-    main()

tools/linux/sysroot/.gitignore

@@ -1,2 +0,0 @@
-*sysroot*
-

tools/linux/sysroot/build_sysroot.py

@@ -0,0 +1,52 @@
+#!/usr/bin/env python
+
+import sys
+sys.path.append('../../../scripts')
+import base
+import os
+import shutil
+import fix_symlinks
+
+def bash_chroot(command, sysroot):
+    base.cmd2('sudo -S chroot', [sysroot, '/bin/bash -c', '\"' + command + ' \"'])
+
+
+def download_sysroot():
+    curr_dir = base.get_script_dir(__file__)
+    tmp_sysroot_ubuntu_dir = curr_dir + '/sysroot_ubuntu_1604'
+
+    if os.path.isdir(tmp_sysroot_ubuntu_dir):
+       shutil.rmtree(tmp_sysroot_ubuntu_dir)
+
+    # debootstrap for downloading sysroot
+    base.cmd2('sudo -S apt-get', ['install', 'debootstrap'])
+
+    archive_ubuntu_url = 'http://archive.ubuntu.com/ubuntu/'
+    base.cmd2('sudo -S debootstrap', ['--arch=amd64', 'xenial', tmp_sysroot_ubuntu_dir, archive_ubuntu_url])
+
+    # setup a new sources
+    base.cmd2('sudo -S cp', [curr_dir + '/sources.list', tmp_sysroot_ubuntu_dir + '/etc/apt/sources.list'])
+
+    bash_chroot('apt update -y', tmp_sysroot_ubuntu_dir)
+    bash_chroot('apt upgrade -y', tmp_sysroot_ubuntu_dir)
+    bash_chroot('apt install -y build-essential curl libpthread-stubs0-dev zlib1g-dev', tmp_sysroot_ubuntu_dir)
+
+    # # downloading arm toolchain
+    arm_toolchain_url = 'https://releases.linaro.org/components/toolchain/binaries/5.4-2017.05/aarch64-linux-gnu/'
+    arm_toolchain_tar_filename = 'gcc-linaro-5.4.1-2017.05-x86_64_aarch64-linux-gnu.tar.xz'
+    arm_toolchain_output_dir = 'gcc-linaro-5.4.1-2017.05-x86_64_aarch64-linux-gnu'
+    base.cmd2('wget', [arm_toolchain_url + arm_toolchain_tar_filename])
+    base.cmd2('tar', ['-xf', arm_toolchain_tar_filename])
+    base.cmd2('sudo -S rsync', ['-avh', '--progress', curr_dir + '/' + arm_toolchain_output_dir + '/', tmp_sysroot_ubuntu_dir + '/usr/'])
+    shutil.rmtree(arm_toolchain_output_dir)
+    os.remove(arm_toolchain_tar_filename)
+
+    base.cmd2('sudo -S chmod', ['-R', 'o+rwx', tmp_sysroot_ubuntu_dir])
+
+    # fix symlinks
+    fix_symlinks.fix_symlinks(tmp_sysroot_ubuntu_dir)
+
+    return
+
+if __name__ == '__main__':
+    download_sysroot()

tools/linux/sysroot/custom-sysroot.toolchain.cmake

@@ -1,19 +0,0 @@
-set(CMAKE_SYSTEM_NAME Linux)
-set(CMAKE_SYSTEM_PROCESSOR aarch64)
-
-set(CMAKE_MAKE_PROGRAM "/usr/bin/make" CACHE FILEPATH "" FORCE)
-
-set(CMAKE_C_COMPILER $ENV{CC})
-set(CMAKE_CXX_COMPILER $ENV{CXX})
-set(CMAKE_AR $ENV{AR})
-set(CMAKE_RANLIB $ENV{RANLIB})
-
-set(CMAKE_C_FLAGS "$ENV{CFLAGS}" CACHE STRING "" FORCE)
-set(CMAKE_CXX_FLAGS "$ENV{CXXFLAGS}" CACHE STRING "" FORCE)
-set(CMAKE_EXE_LINKER_FLAGS "$ENV{LDFLAGS}" CACHE STRING "" FORCE)
-set(CMAKE_SHARED_LINKER_FLAGS "$ENV{LDFLAGS}" CACHE STRING "" FORCE)
-
-set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
-set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
-set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
-set(CMAKE_FIND_ROOT_PATH_MODE_PACKAGE ONLY)

tools/linux/sysroot/fetch.py

@@ -1,224 +0,0 @@
-#!/usr/bin/env python3
-
-import sys
-import os
-sys.path.append('../../../scripts')
-
-import base
-
-URL = "https://github.com/ONLYOFFICE-data/build_tools_data/raw/refs/heads/master/sysroot/"
-
-SYSROOTS = {
-  "amd64": "ubuntu16-amd64-sysroot.tar.gz",
-  "arm64": "ubuntu16-arm64-sysroot.tar.gz",
-}
-
-def patch_linker_scripts(sysroot_path, arch):
-  """Fix absolute paths in linker scripts to use sysroot-relative paths"""
-  
-  # Determine directories to patch
-  lib_dirs = []
-  
-  if arch == "arm64":
-    lib_dirs = [
-      os.path.join(sysroot_path, "usr/lib/aarch64-linux-gnu")
-    ]
-  elif arch == "amd64":
-    lib_dirs = [
-      os.path.join(sysroot_path, "usr/lib/x86_64-linux-gnu"),
-      os.path.join(sysroot_path, "usr/aarch64-linux-gnu/lib")
-    ]
-  else:
-    return
-  
-  total_patched = 0
-  
-  for lib_dir in lib_dirs:
-    if not os.path.exists(lib_dir):
-      print(f"Warning: {lib_dir} not found, skipping")
-      continue
-    
-    print(f"Patching linker scripts in {lib_dir}...")
-    patched_count = 0
-    
-    for filename in os.listdir(lib_dir):
-      if not filename.endswith(".so"):
-        continue
-      
-      filepath = os.path.join(lib_dir, filename)
-      if not os.path.isfile(filepath):
-        continue
-      
-      # Check if it's a text file (linker script)
-      try:
-        with open(filepath, 'r') as f:
-          content = f.read()
-        
-        # Skip if not a linker script
-        if "GROUP" not in content and "INPUT" not in content:
-          continue
-          
-        original_content = content
-        
-        # STEP 1: Normalize all /usr/lib paths to /lib
-        # ORDER MATTERS - do longest paths first to avoid partial matches
-        
-        # For aarch64
-        content = content.replace("/usr/aarch64-linux-gnu/lib/", "/lib/aarch64-linux-gnu/")
-        content = content.replace("/usr/lib/aarch64-linux-gnu/", "/lib/aarch64-linux-gnu/")
-        
-        # For x86_64  
-        content = content.replace("/usr/x86_64-linux-gnu/lib/", "/lib/x86_64-linux-gnu/")
-        content = content.replace("/usr/lib/x86_64-linux-gnu/", "/lib/x86_64-linux-gnu/")
-        
-        # STEP 2: Add = prefix for sysroot-relative paths
-        content = content.replace("/lib/aarch64-linux-gnu/", "=/lib/aarch64-linux-gnu/")
-        content = content.replace("/lib/x86_64-linux-gnu/", "=/lib/x86_64-linux-gnu/")
-        
-        # Write back only if changed
-        if content != original_content:
-          with open(filepath, 'w') as f:
-            f.write(content)
-          
-          print(f"  Patched: {filename}")
-          patched_count += 1
-      except Exception as e:
-        # Not a text file or other error, skip
-        pass
-    
-    total_patched += patched_count
-    print(f"Patched {patched_count} linker scripts in {lib_dir}")
-  
-  print(f"Total patched: {total_patched} linker scripts")
-  
-  # Create symlinks from /lib to /usr/lib for library resolution
-  create_lib_symlinks(sysroot_path, arch)
-  
-  # Fix absolute symlinks to relative ones
-  fix_absolute_symlinks(sysroot_path, arch)
-
-
-def create_lib_symlinks(sysroot_path, arch):
-  """Create symlinks from /lib to /usr/lib for library resolution"""
-  print(f"Creating library symlinks in {sysroot_path}...")
-  
-  if arch == "arm64":
-    lib_symlink_dir = os.path.join(sysroot_path, "lib/aarch64-linux-gnu")
-    lib_target_dir = os.path.join(sysroot_path, "usr/lib/aarch64-linux-gnu")
-  elif arch == "amd64":
-    lib_symlink_dir = os.path.join(sysroot_path, "lib/x86_64-linux-gnu")
-    lib_target_dir = os.path.join(sysroot_path, "usr/lib/x86_64-linux-gnu")
-  else:
-    return
-  
-  # Create /lib/{arch} directory
-  os.makedirs(lib_symlink_dir, exist_ok=True)
-  
-  if not os.path.exists(lib_target_dir):
-    print(f"  Warning: Target directory {lib_target_dir} does not exist")
-    return
-  
-  symlink_count = 0
-  
-  # Create symlinks for all files in /usr/lib/{arch}
-  for filename in os.listdir(lib_target_dir):
-    target = os.path.join(lib_target_dir, filename)
-    link = os.path.join(lib_symlink_dir, filename)
-    
-    # Skip if symlink already exists
-    if os.path.exists(link) or os.path.islink(link):
-      continue
-    
-    # Create relative symlink
-    rel_target = os.path.relpath(target, lib_symlink_dir)
-    try:
-      os.symlink(rel_target, link)
-      symlink_count += 1
-    except OSError as e:
-      print(f"  Warning: Could not create symlink {link}: {e}")
-  
-  print(f"Created {symlink_count} symlinks in {lib_symlink_dir}")
-
-
-def fix_absolute_symlinks(sysroot_path, arch):
-  """Fix absolute symlinks in /usr/lib to use relative paths"""
-  print(f"Fixing absolute symlinks in {sysroot_path}...")
-  
-  if arch == "arm64":
-    lib_dir = os.path.join(sysroot_path, "usr/lib/aarch64-linux-gnu")
-    target_lib_dir = "aarch64-linux-gnu"
-  elif arch == "amd64":
-    lib_dir = os.path.join(sysroot_path, "usr/lib/x86_64-linux-gnu")
-    target_lib_dir = "x86_64-linux-gnu"
-  else:
-    return
-  
-  if not os.path.exists(lib_dir):
-    print(f"  Warning: {lib_dir} not found")
-    return
-  
-  fixed_count = 0
-  
-  # Find all .so symlinks pointing to /lib/
-  for filename in os.listdir(lib_dir):
-    if not filename.endswith(".so"):
-      continue
-    
-    filepath = os.path.join(lib_dir, filename)
-    
-    # Check if it's a symlink
-    if not os.path.islink(filepath):
-      continue
-    
-    # Get symlink target
-    target = os.readlink(filepath)
-    
-    # Check if it's an absolute path starting with /lib/
-    if target.startswith("/lib/"):
-      # Convert to relative path: /lib/... -> ../../../lib/...
-      relative_target = os.path.join("../../..", target[1:])  # Remove leading /
-      
-      # Remove old symlink and create new one
-      os.unlink(filepath)
-      os.symlink(relative_target, filepath)
-      
-      print(f"  Fixed: {filename} -> {relative_target}")
-      fixed_count += 1
-      
-  libgcc_usr_symlink = os.path.join(lib_dir, "libgcc_s.so")
-  libgcc_target = os.path.join(sysroot_path, "lib", target_lib_dir, "libgcc_s.so.1")
-  
-  if os.path.exists(libgcc_target) and not os.path.exists(libgcc_usr_symlink):
-    absolute_libgcc = os.path.abspath(libgcc_target)
-    os.symlink(absolute_libgcc, libgcc_usr_symlink)
-    fixed_count += 1
-  
-  print(f"Fixed {fixed_count} absolute symlinks")
-
-def download_and_extract(name):
-  archive = SYSROOTS[name]
-  base.download(URL + archive, "./" + archive)
-  base.cmd("tar", ["-xzf", "./" + archive])
-
-  sysroot_name = archive.replace(".tar.gz", "")
-  patch_linker_scripts(sysroot_name, name)
-
-def main():
-  if len(sys.argv) != 2:
-    print("Usage: fetch.py [amd64|arm64|all]")
-    sys.exit(1)
-
-  target = sys.argv[1]
-
-  if target == "all":
-    for name in SYSROOTS:
-      download_and_extract(name)
-  elif target in SYSROOTS:
-    download_and_extract(target)
-  else:
-    print(f"Unknown target: {target}")
-    print("Valid values: amd64, arm64, all")
-    sys.exit(1)
-
-if __name__ == "__main__":
-    main()

tools/linux/sysroot/fix_symlinks.py

@@ -0,0 +1,49 @@
+import os
+import sys
+import uuid
+
+# change symbolic link to relative paths
+def fix_symlinks(top_dir='./sysroot_ubuntu_1604'):
+    top_dir += '/usr/lib/x86_64-linux-gnu'
+    for root, dirs, files in os.walk(top_dir):
+        for name in files:
+            path = os.path.join(root, name)
+            if not os.path.islink(path):
+                continue
+
+            try:
+                target = os.readlink(path)
+            except OSError as e:
+                print(f"Error reading link '{path}': {e}", file=sys.stderr)
+                continue
+
+            if not target.startswith('/lib/'):
+                continue
+
+            new_target = "../../../lib" + target[4:]
+            temp_name = f".tmp.{uuid.uuid4().hex}"
+            temp_path = os.path.join(root, temp_name)
+
+            try:
+                os.symlink(new_target, temp_path)
+            except OSError as e:
+                print(f"Failed to create temporary symlink for '{path}': {e}", file=sys.stderr)
+                continue
+
+            try:
+                os.replace(temp_path, path)
+                print(f"Updated: {path} -> {new_target}")
+            except OSError as e:
+                print(f"Failed to replace symlink '{path}': {e}", file=sys.stderr)
+                try:
+                    os.unlink(temp_path)
+                except OSError:
+                    pass
+        break # no subfolders
+
+if __name__ == "__main__":
+    if len(sys.argv) > 1:
+        directory = sys.argv[1]
+    else:
+        directory = './sysroot_ubuntu_1604'
+    fix_symlinks(directory)

tools/linux/sysroot/sources.list

@@ -0,0 +1,51 @@
+#deb cdrom:[Ubuntu 16.04.2 LTS _Xenial Xerus_ - Release amd64 (20170215.2)]/ xenial main restricted
+
+# See http://help.ubuntu.com/community/UpgradeNotes for how to upgrade to
+# newer versions of the distribution.
+deb http://us.archive.ubuntu.com/ubuntu/ xenial main restricted
+# deb-src http://us.archive.ubuntu.com/ubuntu/ xenial main restricted
+
+## Major bug fix updates produced after the final release of the
+## distribution.
+deb http://us.archive.ubuntu.com/ubuntu/ xenial-updates main restricted
+# deb-src http://us.archive.ubuntu.com/ubuntu/ xenial-updates main restricted
+
+## N.B. software from this repository is ENTIRELY UNSUPPORTED by the Ubuntu
+## team. Also, please note that software in universe WILL NOT receive any
+## review or updates from the Ubuntu security team.
+deb http://us.archive.ubuntu.com/ubuntu/ xenial universe
+# deb-src http://us.archive.ubuntu.com/ubuntu/ xenial universe
+deb http://us.archive.ubuntu.com/ubuntu/ xenial-updates universe
+# deb-src http://us.archive.ubuntu.com/ubuntu/ xenial-updates universe
+
+## N.B. software from this repository is ENTIRELY UNSUPPORTED by the Ubuntu 
+## team, and may not be under a free licence. Please satisfy yourself as to 
+## your rights to use the software. Also, please note that software in 
+## multiverse WILL NOT receive any review or updates from the Ubuntu
+## security team.
+deb http://us.archive.ubuntu.com/ubuntu/ xenial multiverse
+# deb-src http://us.archive.ubuntu.com/ubuntu/ xenial multiverse
+deb http://us.archive.ubuntu.com/ubuntu/ xenial-updates multiverse
+# deb-src http://us.archive.ubuntu.com/ubuntu/ xenial-updates multiverse
+
+## N.B. software from this repository may not have been tested as
+## extensively as that contained in the main release, although it includes
+## newer versions of some applications which may provide useful features.
+## Also, please note that software in backports WILL NOT receive any review
+## or updates from the Ubuntu security team.
+deb http://us.archive.ubuntu.com/ubuntu/ xenial-backports main restricted universe multiverse
+# deb-src http://us.archive.ubuntu.com/ubuntu/ xenial-backports main restricted universe multiverse
+
+## Uncomment the following two lines to add software from Canonical's
+## 'partner' repository.
+## This software is not part of Ubuntu, but is offered by Canonical and the
+## respective vendors as a service to Ubuntu users.
+# deb http://archive.canonical.com/ubuntu xenial partner
+# deb-src http://archive.canonical.com/ubuntu xenial partner
+
+deb http://security.ubuntu.com/ubuntu xenial-security main restricted
+# deb-src http://security.ubuntu.com/ubuntu xenial-security main restricted
+deb http://security.ubuntu.com/ubuntu xenial-security universe
+# deb-src http://security.ubuntu.com/ubuntu xenial-security universe
+deb http://security.ubuntu.com/ubuntu xenial-security multiverse
+# deb-src http://security.ubuntu.com/ubuntu xenial-security multiverse

tools/linux/sysroot/system-aarch64.toolchain.cmake

@@ -1,17 +0,0 @@
-set(CMAKE_SYSTEM_NAME Linux)
-set(CMAKE_SYSTEM_PROCESSOR aarch64)
-
-set(CMAKE_C_COMPILER aarch64-linux-gnu-gcc)
-set(CMAKE_CXX_COMPILER aarch64-linux-gnu-g++)
-
-set(CMAKE_C_LINKER aarch64-linux-gnu-ld)
-set(CMAKE_CXX_LINKER aarch64-linux-gnu-ld)
-
-set(CMAKE_AR aarch64-linux-gnu-ar)
-set(CMAKE_RANLIB aarch64-linux-gnu-ranlib)
-set(CMAKE_STRIP aarch64-linux-gnu-strip)
-
-set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
-set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
-set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
-set(CMAKE_FIND_ROOT_PATH_MODE_PACKAGE ONLY)

tools/win/qemu/.gitignore

@@ -1,5 +0,0 @@
-*
-!.gitignore
-!README.md
-!automate.bat
-!start.bat

tools/win/qemu/README.md

@@ -1,102 +0,0 @@
-# **Setting up QEMU Windows 11**
-
-## **0. Preparing for Installation**
-
-1) Install [**MSYS2**](https://www.msys2.org/). The following commands assume that the installation directory remains the default.
-2) ```pacman -S mingw-w64-x86_64-qemu```
-3) Verify installation: ```C:\msys64\mingw64\bin\qemu-system-aarch64.exe --version```
-4) Create an image: ```C:\msys64\mingw64\bin\qemu-img create win11-arm64.img 40G```
-5) Download the Windows 11 ARM64 ISO (a VPN may be required): https://www.microsoft.com/en-us/software-download/windows11arm64
-6) Download the drivers: https://github.com/virtio-win/virtio-win-pkg-scripts/blob/master/README.md
-7) Download the bootloader: https://packages.debian.org/sid/qemu-efi-aarch64  
-
-```ar x qemu-efi-aarch64*.deb```
-
-```tar xvf data.tar.xz```
-
-```mv ./usr/share/qemu-efi-aarch64/QEMU_EFI.fd .```
-
-8) Run _start.bat_  
-
-**Note:** If you plan to install the VM elsewhere, copy _start.bat_ to that same location.
-
----
-
-## **1. Installing and Configuring QEMU**
-
-1. To install QEMU and run a Windows ARM64 virtual machine, follow this tutorial:  
-   [Windows ARM64 VM using qemu-system](https://linaro.atlassian.net/wiki/spaces/WOAR/pages/28914909194/windows-arm64+VM+using+qemu-system).  
-   During installation, there may be no “Back” button (as was my case); if so, you need to set the required registry variables beforehand.  
-   It is strongly recommended to select the **Pro** version — functionality is not guaranteed on the Home edition.
-2. Installing connection drivers is essential; details are provided at the end of the tutorial. Other drivers are optional.
-
----
-
-## **2. Creating a Shared Folder**
-
-To share files between the host Windows and the guest OS, create a folder, for example **D:\shared**.  
-The _shared_ folder can also be a working repository folder; in that case, replace _shared_ with your folder name later on.
-
-1. Right-click the folder → **Properties**.  
-2. Go to **Sharing** → **Share**.  
-3. In the list, select **Everyone** (or a specific user), click **Add**, grant **Read/Write** permissions, and then click **Share**.
-
-You may also need to allow guest connections both on the host and in the guest OS. Instructions are available [here](https://learn.microsoft.com/en-us/windows-server/storage/file-server/enable-insecure-guest-logons-smb2-and-smb3?tabs=powershell).  
-Now the folder is accessible from the guest machine.
-
----
-
-## **3. Verification**
-
-After starting the virtual machine, open **Command Prompt** or **PowerShell** **without** administrator rights and run:
-
-```
-net use Z: \\10.0.2.2\shared /user:guest ""
-dir Z:
-```
-
-These commands should complete without errors and display a list of directories and files in the shared folder.
-
----
-
-## **4. Installing VC_redist**
-
-Additional packages are required for running software. You can download them inside the guest machine, but that may take a long time, so it’s recommended to download them on the host, place them in the shared folder, and install them from there.  
-
-Download from:  
-https://learn.microsoft.com/en-us/cpp/windows/latest-supported-vc-redist?view=msvc-170 (choose ARM64 version).  
-
-To install from the command line after connecting the shared folder:
-
-```
-.\Z:\VC_redist.arm64.exe
-```
-
----
-
-## **5. Setting Up Automatic Script Execution via Task Scheduler**
-
-Before creating a task, remove the password from your user account so that the system logs in automatically when the VM starts.
-
-### **Creating the Task**
-
-1. Open **Task Scheduler** → **Create Task...**
-2. **General** tab:
-   - Name: Automate  
-   - Run only when user is logged on  
-   - Run with highest privileges  
-3. **Triggers** tab:
-   - New → **At log on**
-4. **Actions** tab:
-   - Action: **Start a program**  
-   - Program/script:  
-     `\\10.0.2.2\shared\build_tools\tools\win\qemu\automate.bat`
-
----
-
-## **6. Config Setup**
-
-Finally, specify the path to the folder containing the VM and the _start.bat_ script in the configuration under  
-```qemu-win-arm64-dir```.  
-
-You can do this either through `configure.py` or by editing the configuration file directly.

tools/win/qemu/automate.bat

@@ -1,52 +0,0 @@
-setlocal enabledelayedexpansion
-
-set "script_dir=%~dp0"
-set "config_file=%script_dir%..\..\..\config"
-set "git_dir=%script_dir%..\..\..\..\
-
-set "module_list="
-set "branding_value="
-set "themesparams="
-
-for /f "delims=" %%a in ('type "%config_file%"') do (
-    set "line=%%a"
-    if "!line:~0,7!"=="module=" (
-        set "module_list=!line:~7!"
-        set "module_list=!module_list:"=!"
-    )
-    if "!line:~0,14!"=="branding-name=" (
-        set "branding_value=!line:~14!"
-        set "branding_value=!branding_value:"=!"
-    )
-	if "!line:~0,13!"=="themesparams=" (
-        set "themesparams=!line:~13!"
-        set "themesparams=!branding_value:"=!"
-    )
-)
-
-if "!branding_value!"=="" (
-    set "branding_value=onlyoffice"
-)
-
-set "base_out_dir=%script_dir%..\..\..\out\win_arm64\%branding_value%"
-
-for %%m in (!module_list!) do (
-	if "%%m"=="desktop" (
-		call %base_out_dir%\DesktopEditors\converter\x2t.exe -create-js-snapshots
-		call %base_out_dir%\DesktopEditors\converter\allfontsgen.exe --use-system="1" --input="%base_out_dir%\DesktopEditors\fonts" --input="%git_dir%\core-fonts" --allfonts="%base_out_dir%\DesktopEditors\converter\AllFonts.js" --selection="%base_out_dir%\DesktopEditors\converter\font_selection.bin"
-		call %base_out_dir%\DesktopEditors\converter\allthemesgen.exe --converter-dir="%base_out_dir%\DesktopEditors\converter" --src="%base_out_dir%\DesktopEditors\editors\sdkjs\slide\themes" --allfonts="AllFonts.js" --output="%base_out_dir%\DesktopEditors\editors\sdkjs\common\Images" --params="%themesparams%"
-		del %base_out_dir%\DesktopEditors\converter\allfontsgen.exe
-		del %base_out_dir%\DesktopEditors\converter\allthemesgen.exe
-
-	)
-	if "%%m"=="server" (
-		call %base_out_dir%\documentserver\server\FileConverter\bin\x2t -create-js-snapshots
-	)
-	if "%%m"=="builder" (
-		call %base_out_dir%\DocumentBuilder\x2t -create-js-snapshots
-	)
-	if "%%m"=="core" (
-		call %base_out_dir%\core\x2t -create-js-snapshots
-	)
-)
-shutdown /s /f /t 10

tools/win/qemu/start.bat

@@ -1,17 +0,0 @@
-@echo off
-REM ========================================================
-REM  INSTALL Windows ARM64 VM (QEMU on Windows x64)
-REM ========================================================
-
-C:\msys64\mingw64\bin\qemu-system-aarch64 ^
- -M virt -m 8G -cpu max,pauth-impdef=on -smp 8 ^
- -bios ./QEMU_EFI.fd ^
- -accel tcg,thread=multi ^
- -device ramfb ^
- -device qemu-xhci -device usb-kbd -device usb-tablet ^
- -nic user,model=virtio-net-pci ^
- -device usb-storage,drive=install ^
- -drive if=none,id=install,format=raw,media=cdrom,file=./Win11_24H2_English_Arm64.iso ^
- -device usb-storage,drive=virtio-drivers ^
- -drive if=none,id=virtio-drivers,format=raw,media=cdrom,file=./virtio-win-0.1.271.iso ^
- -drive if=virtio,id=system,format=raw,file=./win11-arm64.img

version

@@ -1 +1 @@
-9.3.1
+9.0.4