jlengrand/compose-multiplatform
1
0
Fork 0
mirror of https://github.com/jlengrand/compose-multiplatform.git synced 2026-03-10 08:11:20 +00:00
Code Issues Packages Projects Releases Wiki Activity

Check tutorials (#237)

Browse Source
This commit is contained in:
Nikolay Igotti
2020-12-29 16:52:59 +03:00
committed by GitHub
parent b08b9ed17d
commit a664d07c1a
13 changed files with 410 additions and 23 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
tutorials/Getting_Started/README.md
View File

@@ -48,7 +48,7 @@ cd sample
```
Create `settings.gradle.kts` as follows:
```kotlin
``` kotlin
pluginManagement {
repositories {
gradlePluginPortal()
@@ -57,7 +57,7 @@ pluginManagement {
}
```
Then create `build.gradle.kts` with the following content:
```kotlin
``` kotlin
import org.jetbrains.compose.compose
plugins {

1
tutorials/Getting_Started/main.md
View File

@@ -1 +0,0 @@
README.md

3
tutorials/Keyboard/README.md
View File

@@ -33,7 +33,7 @@ It works the same as Compose for Android, for details see [API Reference](https:
The most common use case is to define keyboard handlers for active controls like `TextField`. Here is an example:
``` kotlin
```kotlin
import androidx.compose.desktop.Window
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Column
@@ -51,7 +51,6 @@ import androidx.compose.runtime.getValue
import androidx.compose.runtime.setValue
import androidx.compose.ui.input.key.shortcuts
@OptIn(ExperimentalKeyInput::class)
fun main() = Window(title = "Compose for Desktop", size = IntSize(300, 300)) {
MaterialTheme {
var consumedText by remember { mutableStateOf(0) }

18
tutorials/Native_distributions_and_local_execution/README.md
View File

@@ -18,7 +18,7 @@ In other words, an `application` in DSL allows you to pack a bunch of files,
together with a JDK distribution, into a set of compressed binary installers
in various formats (`.dmg`, `.deb`, `.msi`, `.exe`, etc).
```kotlin
``` kotlin
import org.jetbrains.compose.compose
import org.jetbrains.compose.desktop.application.dsl.TargetFormat
@@ -77,7 +77,7 @@ The plugin uses `jpackage`, which is available since [JDK 14](https://openjdk.ja
Make sure you meet at least one of the following requirements:
* `JAVA_HOME` environment variable points to the compatible JDK version.
* `javaHome` is set via DSL:
```kotlin
``` kotlin
compose.desktop {
application {
javaHome = System.getenv("JDK_14")
@@ -87,7 +87,7 @@ compose.desktop {
## Customizing output dir
```kotlin
``` kotlin
compose.desktop {
application {
nativeDistributions {
@@ -104,7 +104,7 @@ The following properties are available for customizing the application startup:
* `args` — arguments for the application's main method;
* `jvmArgs` — arguments for the application's JVM.
```kotlin
``` kotlin
compose.desktop {
application {
mainClass = "MainKt"
@@ -123,7 +123,7 @@ The following properties are available in the `nativeDistributions` DSL block:
* `copyright` — application's copyright (default value: none);
* `vendor` — application's vendor (default value: none).
```kotlin
``` kotlin
compose.desktop {
application {
nativeDistributions {
@@ -149,7 +149,7 @@ manually, or a single target should be specified (see below).
If the default configuration is ambiguous or not sufficient, the plugin can be configured:
* Using a Gradle [source set](https://docs.gradle.org/current/userguide/java_plugin.html#source_sets)
```kotlin
``` kotlin
plugins {
kotlin("jvm")
id("org.jetbrains.compose")
@@ -163,7 +163,7 @@ compose.desktop {
}
```
* Using a Kotlin [JVM target](https://kotlinlang.org/docs/reference/mpp-dsl-reference.html#targets):
```kotlin
``` kotlin
plugins {
kotlin("multiplatform")
id("org.jetbrains.compose")
@@ -184,7 +184,7 @@ compose.desktop {
* `dependsOn` can be used to add task dependencies to all plugin's tasks;
* `fromFiles` can be used to specify files to include;
* `mainJar` file property can be specified to point to a jar, containing a main class.
```kotlin
``` kotlin
compose.desktop {
application {
disableDefaultConfiguration()
@@ -202,7 +202,7 @@ The app icon needs to be provided in OS-specific formats:
* `.ico` for Windows;
* `.png` for Linux.
```kotlin
``` kotlin
compose.desktop {
application {
nativeDistributions {

18
tutorials/Window_API/README.md
View File

@@ -189,11 +189,11 @@ To get the properties of a window, it is enough to have a link to the current or
```kotlin
import androidx.compose.desktop.AppWindowAmbient
import androidx.compose.desktop.Window
import androidx.compose.foundation.Text
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.material.Button
import androidx.compose.material.Text
import androidx.compose.runtime.mutableStateOf
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
@@ -208,7 +208,7 @@ fun main() {
// Content
Box(
modifier = Modifier.fillMaxSize(),
alignment = Alignment.Center
contentAlignment = Alignment.Center
) {
Column {
Text(text = "Location: ${windowPos.value}")
@@ -288,11 +288,11 @@ import androidx.compose.material.Button
fun main() {
Window {
val window = AppWindowAmbient.current!!
// Content
Button(
onClick = {
AppWindowAmbient.current?.setWindowCentered()
window.setWindowCentered()
}
) {
Text(text = "Center the window")
@@ -430,28 +430,28 @@ fun main() {
The AppManager singleton is used to customize the behavior of the entire application. Its main features:
1. Description of common application events
```kotlin
``` kotlin
AppManager.setEvents(
onAppStart = { println("onAppStart") }, // Invoked before the first window is created
onAppExit = { println("onAppExit") } // Invoked after all windows are closed
)
```
2. Customization of common application context menu
```kotlin
``` kotlin
AppManager.setMenu(
getCommonAppMenuBar() // Custom function that returns MenuBar
)
```
3. Access to the application windows list
```kotlin
``` kotlin
val windows = AppManager.windows
```
4. Getting the current focused window
```kotlin
``` kotlin
val current = AppManager.focusedWindow
```
5. Application exit
```kotlin
``` kotlin
AppManager.exit() // Closes all windows
```

2
tutorials/checker/.gitignore vendored Normal file
View File

@@ -0,0 +1,2 @@
build
.gradle

90
tutorials/checker/build.gradle.kts Normal file
View File

@@ -0,0 +1,90 @@
data class SnippetData(
val file: File,
val lineNumber: Int,
val content: String,
var tempDir: File? = null
)
fun findSnippets(dirs: List<String>): List<SnippetData> {
val snippets = mutableListOf<SnippetData>()
dirs.forEach { dirName ->
rootProject
.projectDir
.parentFile
.resolve(dirName)
.listFiles()
.filter { it.name.endsWith(".md") }
.forEach { file ->
val currentSnippet = kotlin.text.StringBuilder()
var snippetStart = 0
var lineNumber = 0
file.forEachLine { line ->
lineNumber++
if (line == "```kotlin")
snippetStart = lineNumber + 1
else if (line == "```" && snippetStart != 0) {
snippets.add(SnippetData(file, snippetStart, currentSnippet.toString()))
snippetStart = 0
currentSnippet.clear()
} else {
if (snippetStart != 0) {
currentSnippet.appendln(line)
}
}
}
}
}
return snippets
}
fun cloneTemplate(index: Int, content: String): File {
val tempDir = file("${project.buildDir.absolutePath}/temp/cloned-$index")
tempDir.deleteRecursively()
tempDir.mkdirs()
file("${projectDir.parentFile.parentFile.absolutePath}/templates/desktop-template").copyRecursively(tempDir)
// tempDir.deleteOnExit()
File("$tempDir/src/main/kotlin/main.kt").printWriter().use { out ->
out.println(content)
}
return tempDir
}
fun checkDirs(dirs: List<String>) {
val snippets = findSnippets(dirs)
snippets.forEachIndexed { index, snippet ->
println("process snippet $index at ${snippet.file}:${snippet.lineNumber}")
snippet.tempDir = cloneTemplate(index, snippet.content)
val isWin = System.getProperty("os.name").startsWith("Win")
val procBuilder = if (isWin) {
ProcessBuilder("gradlew.bat", "build")
} else {
ProcessBuilder("bash", "./gradlew", "build")
}
val proc = procBuilder
.directory(snippet.tempDir)
.redirectOutput(ProcessBuilder.Redirect.PIPE)
.redirectError(ProcessBuilder.Redirect.PIPE)
.start()
proc.waitFor(5, TimeUnit.MINUTES)
if (proc.exitValue() != 0) {
println(proc.inputStream.bufferedReader().readText())
println(proc.errorStream.bufferedReader().readText())
throw GradleException("Error in snippet at ${snippet.file}:${snippet.lineNumber}")
}
}
}
// NOTICE: currently we use a bit hacky approach, when "```kotlin" marks code that shall be checked, while "``` kotlin"
// with whitespace marks code that shall not be checked.
tasks.register("check") {
doLast {
val dirs = project
.projectDir
.parentFile
.listFiles()
.filter {
it.isDirectory && it.name[0].isUpperCase() }
.map { it.name }
checkDirs(dirs)
}
}

1
tutorials/checker/gradle.properties Normal file
View File

@@ -0,0 +1 @@
kotlin.code.style=official

BIN
tutorials/checker/gradle/wrapper/gradle-wrapper.jar vendored Normal file
View File

Binary file not shown.

5
tutorials/checker/gradle/wrapper/gradle-wrapper.properties vendored Normal file
View File

@@ -0,0 +1,5 @@
distributionBase=GRADLE_USER_HOME
distributionPath=wrapper/dists
distributionUrl=https\://services.gradle.org/distributions/gradle-6.7-bin.zip
zipStoreBase=GRADLE_USER_HOME
zipStorePath=wrapper/dists

185
tutorials/checker/gradlew vendored Executable file
View File

@@ -0,0 +1,185 @@
#!/usr/bin/env sh
#
# Copyright 2015 the original author or authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
##############################################################################
##
## Gradle start up script for UN*X
##
##############################################################################
# Attempt to set APP_HOME
# Resolve links: $0 may be a link
PRG="$0"
# Need this for relative symlinks.
while [ -h "$PRG" ] ; do
ls=`ls -ld "$PRG"`
link=`expr "$ls" : '.*-> \(.*\)$'`
if expr "$link" : '/.*' > /dev/null; then
PRG="$link"
else
PRG=`dirname "$PRG"`"/$link"
fi
done
SAVED="`pwd`"
cd "`dirname \"$PRG\"`/" >/dev/null
APP_HOME="`pwd -P`"
cd "$SAVED" >/dev/null
APP_NAME="Gradle"
APP_BASE_NAME=`basename "$0"`
# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
# Use the maximum available, or set MAX_FD != -1 to use that value.
MAX_FD="maximum"
warn () {
echo "$*"
}
die () {
echo
echo "$*"
echo
exit 1
}
# OS specific support (must be 'true' or 'false').
cygwin=false
msys=false
darwin=false
nonstop=false
case "`uname`" in
CYGWIN* )
cygwin=true
;;
Darwin* )
darwin=true
;;
MINGW* )
msys=true
;;
NONSTOP* )
nonstop=true
;;
esac
CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
# Determine the Java command to use to start the JVM.
if [ -n "$JAVA_HOME" ] ; then
if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
# IBM's JDK on AIX uses strange locations for the executables
JAVACMD="$JAVA_HOME/jre/sh/java"
else
JAVACMD="$JAVA_HOME/bin/java"
fi
if [ ! -x "$JAVACMD" ] ; then
die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
Please set the JAVA_HOME variable in your environment to match the
location of your Java installation."
fi
else
JAVACMD="java"
which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
Please set the JAVA_HOME variable in your environment to match the
location of your Java installation."
fi
# Increase the maximum file descriptors if we can.
if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then
MAX_FD_LIMIT=`ulimit -H -n`
if [ $? -eq 0 ] ; then
if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
MAX_FD="$MAX_FD_LIMIT"
fi
ulimit -n $MAX_FD
if [ $? -ne 0 ] ; then
warn "Could not set maximum file descriptor limit: $MAX_FD"
fi
else
warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
fi
fi
# For Darwin, add options to specify how the application appears in the dock
if $darwin; then
GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
fi
# For Cygwin or MSYS, switch paths to Windows format before running java
if [ "$cygwin" = "true" -o "$msys" = "true" ] ; then
APP_HOME=`cygpath --path --mixed "$APP_HOME"`
CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
JAVACMD=`cygpath --unix "$JAVACMD"`
# We build the pattern for arguments to be converted via cygpath
ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
SEP=""
for dir in $ROOTDIRSRAW ; do
ROOTDIRS="$ROOTDIRS$SEP$dir"
SEP="|"
done
OURCYGPATTERN="(^($ROOTDIRS))"
# Add a user-defined pattern to the cygpath arguments
if [ "$GRADLE_CYGPATTERN" != "" ] ; then
OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
fi
# Now convert the arguments - kludge to limit ourselves to /bin/sh
i=0
for arg in "$@" ; do
CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
CHECK2=`echo "$arg"|egrep -c "^-"` ### Determine if an option
if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then ### Added a condition
eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
else
eval `echo args$i`="\"$arg\""
fi
i=`expr $i + 1`
done
case $i in
0) set -- ;;
1) set -- "$args0" ;;
2) set -- "$args0" "$args1" ;;
3) set -- "$args0" "$args1" "$args2" ;;
4) set -- "$args0" "$args1" "$args2" "$args3" ;;
5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
esac
fi
# Escape application args
save () {
for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done
echo " "
}
APP_ARGS=`save "$@"`
# Collect all arguments for the java command, following the shell quoting and substitution rules
eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS"
exec "$JAVACMD" "$@"

104
tutorials/checker/gradlew.bat vendored Normal file
View File

@@ -0,0 +1,104 @@
@rem
@rem Copyright 2015 the original author or authors.
@rem
@rem Licensed under the Apache License, Version 2.0 (the "License");
@rem you may not use this file except in compliance with the License.
@rem You may obtain a copy of the License at
@rem
@rem https://www.apache.org/licenses/LICENSE-2.0
@rem
@rem Unless required by applicable law or agreed to in writing, software
@rem distributed under the License is distributed on an "AS IS" BASIS,
@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
@rem See the License for the specific language governing permissions and
@rem limitations under the License.
@rem
@if "%DEBUG%" == "" @echo off
@rem ##########################################################################
@rem
@rem Gradle startup script for Windows
@rem
@rem ##########################################################################
@rem Set local scope for the variables with windows NT shell
if "%OS%"=="Windows_NT" setlocal
set DIRNAME=%~dp0
if "%DIRNAME%" == "" set DIRNAME=.
set APP_BASE_NAME=%~n0
set APP_HOME=%DIRNAME%
@rem Resolve any "." and ".." in APP_HOME to make it shorter.
for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi
@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"
@rem Find java.exe
if defined JAVA_HOME goto findJavaFromJavaHome
set JAVA_EXE=java.exe
%JAVA_EXE% -version >NUL 2>&1
if "%ERRORLEVEL%" == "0" goto init
echo.
echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
echo.
echo Please set the JAVA_HOME variable in your environment to match the
echo location of your Java installation.
goto fail
:findJavaFromJavaHome
set JAVA_HOME=%JAVA_HOME:"=%
set JAVA_EXE=%JAVA_HOME%/bin/java.exe
if exist "%JAVA_EXE%" goto init
echo.
echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
echo.
echo Please set the JAVA_HOME variable in your environment to match the
echo location of your Java installation.
goto fail
:init
@rem Get command-line arguments, handling Windows variants
if not "%OS%" == "Windows_NT" goto win9xME_args
:win9xME_args
@rem Slurp the command line arguments.
set CMD_LINE_ARGS=
set _SKIP=2
:win9xME_args_slurp
if "x%~1" == "x" goto execute
set CMD_LINE_ARGS=%*
:execute
@rem Setup the command line
set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
@rem Execute Gradle
"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS%
:end
@rem End local scope for the variables with windows NT shell
if "%ERRORLEVEL%"=="0" goto mainEnd
:fail
rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
rem the _cmd.exe /c_ return code!
if not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
exit /b 1
:mainEnd
if "%OS%"=="Windows_NT" endlocal
:omega

2
tutorials/checker/settings.gradle.kts Normal file
View File

@@ -0,0 +1,2 @@
rootProject.name = "checker"