content
stringlengths 0
3.9M
| path
stringlengths 4
242
| contentHash
stringlengths 1
10
|
|---|---|---|
/*
* Copyright 2017 Google Inc.
*
* 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
*
* http://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.
*/
package com.google.android.apps.muzei.gallery
import android.content.Context
import android.content.Intent
import android.content.pm.PackageManager
import android.net.Uri
import android.os.Binder
import android.os.Build
import android.provider.DocumentsContract
import android.util.Log
import androidx.lifecycle.LiveData
import androidx.paging.PagingSource
import androidx.room.Dao
import androidx.room.Insert
import androidx.room.OnConflictStrategy
import androidx.room.Query
import androidx.room.Transaction
import com.google.android.apps.muzei.api.provider.ProviderContract
import com.google.android.apps.muzei.gallery.BuildConfig.GALLERY_ART_AUTHORITY
import kotlinx.coroutines.async
import kotlinx.coroutines.awaitAll
import kotlinx.coroutines.coroutineScope
import java.io.File
import java.io.FileOutputStream
import java.io.IOException
import java.util.Date
/**
* Dao for [ChosenPhoto]
*/
@Dao
internal abstract class ChosenPhotoDao {
companion object {
private const val TAG = "ChosenPhotoDao"
}
@get:Query("SELECT * FROM chosen_photos ORDER BY _id DESC")
internal abstract val chosenPhotosPaged: PagingSource<Int, ChosenPhoto>
@get:Query("SELECT * FROM chosen_photos ORDER BY _id DESC")
internal abstract val chosenPhotosLiveData: LiveData<List<ChosenPhoto>>
@get:Query("SELECT * FROM chosen_photos ORDER BY _id DESC")
internal abstract val chosenPhotosBlocking: List<ChosenPhoto>
@Insert(onConflict = OnConflictStrategy.REPLACE)
internal abstract suspend fun insertInternal(chosenPhoto: ChosenPhoto): Long
@Transaction
open suspend fun insert(
context: Context,
chosenPhoto: ChosenPhoto,
callingApplication: String?
): Long = if (persistUriAccess(context, chosenPhoto)) {
val id = insertInternal(chosenPhoto)
if (id != 0L && callingApplication != null) {
val metadata = Metadata(ChosenPhoto.getContentUri(id), Date(),
context.getString(R.string.gallery_shared_from, callingApplication))
GalleryDatabase.getInstance(context).metadataDao().insert(metadata)
}
GalleryScanWorker.enqueueInitialScan(context, listOf(id))
id
} else {
0L
}
@Insert(onConflict = OnConflictStrategy.REPLACE)
internal abstract suspend fun insertAllInternal(chosenPhoto: List<ChosenPhoto>): List<Long>
@Transaction
open suspend fun insertAll(context: Context, uris: Collection<Uri>) {
insertAllInternal(uris
.map { ChosenPhoto(it) }
.filter { persistUriAccess(context, it) }
).run {
if (isNotEmpty()) {
GalleryScanWorker.enqueueInitialScan(context, this)
}
}
}
private fun persistUriAccess(context: Context, chosenPhoto: ChosenPhoto): Boolean {
chosenPhoto.isTreeUri = isTreeUri(chosenPhoto.uri)
if (chosenPhoto.isTreeUri) {
try {
context.contentResolver.takePersistableUriPermission(chosenPhoto.uri,
Intent.FLAG_GRANT_READ_URI_PERMISSION)
} catch (ignored: SecurityException) {
// You can't persist URI permissions from your own app, so this fails.
// We'll still have access to it directly
}
} else {
val haveUriPermission = context.checkUriPermission(chosenPhoto.uri,
Binder.getCallingPid(), Binder.getCallingUid(),
Intent.FLAG_GRANT_READ_URI_PERMISSION) == PackageManager.PERMISSION_GRANTED
// If we only have permission to this URI via URI permissions (rather than directly,
// such as if the URI is from our own app), it is from an external source and we need
// to make sure to gain persistent access to the URI's content
if (haveUriPermission) {
var persistedPermission = false
// Try to persist access to the URI, saving us from having to store a local copy
if (DocumentsContract.isDocumentUri(context, chosenPhoto.uri)) {
try {
context.contentResolver.takePersistableUriPermission(chosenPhoto.uri,
Intent.FLAG_GRANT_READ_URI_PERMISSION)
persistedPermission = true
// If we have a persisted URI permission, we don't need a local copy
val cachedFile = GalleryProvider.getCacheFileForUri(context, chosenPhoto.uri)
if (cachedFile?.exists() == true) {
if (!cachedFile.delete()) {
Log.w(TAG, "Unable to delete $cachedFile")
}
}
} catch (ignored: SecurityException) {
// If we don't have FLAG_GRANT_PERSISTABLE_URI_PERMISSION (such as when using ACTION_GET_CONTENT),
// this will fail. We'll need to make a local copy (handled below)
}
}
if (!persistedPermission) {
// We only need to make a local copy if we weren't able to persist the permission
try {
writeUriToFile(context, chosenPhoto.uri,
GalleryProvider.getCacheFileForUri(context, chosenPhoto.uri))
} catch (e: IOException) {
Log.e(TAG, "Error downloading gallery image ${chosenPhoto.uri}", e)
return false
}
}
}
}
return true
}
private fun isTreeUri(possibleTreeUri: Uri): Boolean {
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
return DocumentsContract.isTreeUri(possibleTreeUri)
} else {
try {
// Prior to N we can't directly check if the URI is a tree URI, so we have to just try it
val treeDocumentId = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
DocumentsContract.getTreeDocumentId(possibleTreeUri)
} else {
// No tree URIs prior to Lollipop
return false
}
return treeDocumentId?.isNotEmpty() == true
} catch (e: IllegalArgumentException) {
// Definitely not a tree URI
return false
}
}
}
@Throws(IOException::class)
private fun writeUriToFile(context: Context, uri: Uri, destFile: File?) {
if (destFile == null) {
throw IOException("Invalid destination for $uri")
}
try {
context.contentResolver.openInputStream(uri)?.use { input ->
FileOutputStream(destFile).use { out ->
input.copyTo(out)
}
}
} catch (e: SecurityException) {
throw IOException("Unable to read Uri: $uri", e)
} catch (e: UnsupportedOperationException) {
throw IOException("Unable to read Uri: $uri", e)
}
}
@Query("SELECT * FROM chosen_photos WHERE _id = :id")
internal abstract fun chosenPhotoBlocking(id: Long): ChosenPhoto?
@Query("SELECT * FROM chosen_photos WHERE _id = :id")
abstract suspend fun getChosenPhoto(id: Long): ChosenPhoto?
@Query("SELECT * FROM chosen_photos WHERE _id IN (:ids)")
abstract suspend fun getChosenPhotos(ids: List<Long>): List<ChosenPhoto>
@Query("DELETE FROM chosen_photos WHERE _id IN (:ids)")
internal abstract suspend fun deleteInternal(ids: List<Long>)
@Transaction
open suspend fun delete(context: Context, ids: List<Long>) {
deleteBackingPhotos(context, getChosenPhotos(ids))
deleteInternal(ids)
}
@Query("DELETE FROM chosen_photos")
internal abstract suspend fun deleteAllInternal()
@Transaction
open suspend fun deleteAll(context: Context) {
deleteBackingPhotos(context, chosenPhotosBlocking)
deleteAllInternal()
}
/**
* We can't just simply delete the rows as that won't free up the space occupied by the
* chosen image files for each row being deleted. Instead we have to query
* and manually delete each chosen image file
*/
private suspend fun deleteBackingPhotos(
context: Context,
chosenPhotos: List<ChosenPhoto>
) = coroutineScope {
chosenPhotos.map { chosenPhoto ->
async {
val contentUri = ProviderContract.getContentUri(GALLERY_ART_AUTHORITY)
context.contentResolver.delete(contentUri,
"${ProviderContract.Artwork.METADATA}=?",
arrayOf(chosenPhoto.uri.toString()))
val file = GalleryProvider.getCacheFileForUri(context, chosenPhoto.uri)
if (file?.exists() == true) {
if (!file.delete()) {
Log.w(TAG, "Unable to delete $file")
}
} else {
val uriToRelease = chosenPhoto.uri
val contentResolver = context.contentResolver
val haveUriPermission = context.checkUriPermission(uriToRelease,
Binder.getCallingPid(), Binder.getCallingUid(),
Intent.FLAG_GRANT_READ_URI_PERMISSION) == PackageManager.PERMISSION_GRANTED
if (haveUriPermission) {
// Try to release any persisted URI permission for the imageUri
val persistedUriPermissions = contentResolver.persistedUriPermissions
for (persistedUriPermission in persistedUriPermissions) {
if (persistedUriPermission.uri == uriToRelease) {
try {
contentResolver.releasePersistableUriPermission(
uriToRelease, Intent.FLAG_GRANT_READ_URI_PERMISSION)
} catch (e: SecurityException) {
// Thrown if we don't have permission...despite in being in
// the getPersistedUriPermissions(). Alright then.
}
break
}
}
}
}
}
}.awaitAll()
}
}
| source-gallery/src/main/java/com/google/android/apps/muzei/gallery/ChosenPhotoDao.kt | 653163724 |
// Copyright 2000-2019 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file.
package com.intellij.ide.ui
import com.intellij.navigation.TargetPopupPresentation
import com.intellij.ui.components.JBLabel
import com.intellij.ui.speedSearch.SearchAwareRenderer
import com.intellij.util.ui.JBUI
import com.intellij.util.ui.UIUtil
import org.jetbrains.annotations.ApiStatus.Experimental
import java.awt.Component
import javax.swing.JList
import javax.swing.ListCellRenderer
import javax.swing.SwingConstants
@Experimental
internal abstract class TargetPresentationRightRenderer<T> : ListCellRenderer<T>, SearchAwareRenderer<T> {
companion object {
private val ourBorder = JBUI.Borders.emptyRight(UIUtil.getListCellHPadding())
}
protected abstract fun getPresentation(value: T): TargetPopupPresentation?
private val component = JBLabel().apply {
border = ourBorder
horizontalTextPosition = SwingConstants.LEFT
horizontalAlignment = SwingConstants.RIGHT // align icon to the right
}
final override fun getItemSearchString(item: T): String? = getPresentation(item)?.locationText
final override fun getListCellRendererComponent(list: JList<out T>,
value: T,
index: Int,
isSelected: Boolean,
cellHasFocus: Boolean): Component {
component.apply {
text = ""
icon = null
background = UIUtil.getListBackground(isSelected)
foreground = if (isSelected) UIUtil.getListSelectionForeground() else UIUtil.getInactiveTextColor()
font = list.font
}
getPresentation(value)?.let { presentation ->
presentation.rightText?.let { rightText ->
component.text = rightText
component.icon = presentation.rightIcon
}
}
return component
}
}
| platform/lang-impl/src/com/intellij/ide/ui/TargetPresentationRightRenderer.kt | 405074308 |
/**
* <slate_header>
* url: www.slatekit.com
* git: www.github.com/code-helix/slatekit
* org: www.codehelix.co
* author: Kishore Reddy
* copyright: 2016 CodeHelix Solutions Inc.
* license: refer to website and/or github
* about: A tool-kit, utility library and server-backend
* mantra: Simplicity above all else
* </slate_header>
*/
package slatekit.common
//import java.time.*
import org.threeten.bp.*
import org.threeten.bp.format.DateTimeFormatter
import slatekit.common.ext.atStartOfMonth
import slatekit.common.ext.daysInMonth
import slatekit.common.checks.Check
import java.util.*
/**
* Currently a typealias for the ThreeTenBP ZonedDateTime
* The slatekit.common uses this datetime library instead of Java 8 because:
* 1. slatekit.common is used for android projects
* 2. targets android projects prior to API 26
* 3. Java 8 datetime APIs are not available in android devices older than API 26
*/
typealias DateTime = ZonedDateTime
/**
* DateTimes provides some convenient "static" functions
*
* See the extension methods on the DateTime ( ZonedDateTime )
* which essentially just add additional convenience functions
* for conversion, formatting methods
*
*
* FEATURES
* 1. Zoned : Always uses ZonedDateTime
* 2. Simpler : Simpler usage of Dates/Times/Zones
* 3. Conversion : Simpler conversion to/from time zones
* 4. Idiomatic : Idiomatic way to use DateTime in kotlin
*
*
* EXAMPLES:
* Construction:
* - DateTime.now()
* - DateTime.today()
* - DateTime.of(2017, 7, 1)
*
*
* UTC:
* - val d = DateTime.nowUtc()
* - val d = DateTime.nowAt("Europe/Athens")
*
*
* Conversion
* - val now = DateTime.now()
* - val utc = now.atUtc()
* - val utcl = now.atUtcLocal()
* - val athens = now.at("Europe/Athens")
* - val date = now.date()
* - val time = now.time()
* - val local = now.local()
*
*
* IDIOMATIC
* - val now = DateTime.now()
* - val later = now() + 3.days
* - val before = now() - 3.minutes
* - val duration = now() - later
* - val seconds = now().secondsTo( later )
* - val minutes = now().minutesTo( later )
*
*
* Formatting
* - val now = DateTime.now()
* - val txt = now.toStringYYYYMMDD("-")
* - val txt = now.toStringMMDDYYYY("/")
* - val txt = now.toStringTime(":")
* - val txt = now.toStringNumeric("-")
*
*
*/
class DateTimes {
companion object {
val ZONE = ZoneId.systemDefault()
@JvmStatic
val UTC: ZoneId = ZoneId.of("UTC")
@JvmStatic
val MIN: DateTime = LocalDateTime.MIN.atZone(ZoneId.systemDefault())
@JvmStatic
fun of(d: LocalDateTime): ZonedDateTime = ZonedDateTime.of(d, ZoneId.systemDefault())
@JvmStatic
fun of(d: Date): DateTime = build(d, ZoneId.systemDefault())
@JvmStatic
fun of(d: Date, zoneId: ZoneId): DateTime = build(d, zoneId)
@JvmStatic
fun of(d: LocalDate): DateTime = build(d.year, d.month.value, d.dayOfMonth, zoneId = ZoneId.systemDefault())
/**
* Builds a DateTime ( ZonedDateTime of system zone ) using explicit values.
*/
@JvmStatic
fun of(
year: Int,
month: Int,
day: Int,
hours: Int = 0,
minutes: Int = 0,
seconds: Int = 0,
nano: Int = 0,
zone: String = ""
): DateTime {
val zoneId = if (zone.isNullOrEmpty()) ZoneId.systemDefault() else ZoneId.of(zone)
return build(year, month, day, hours, minutes, seconds, nano, zoneId)
}
/**
* Builds a DateTime ( ZonedDateTime of system zone ) using explicit values.
*/
@JvmStatic
fun of(
year: Int,
month: Int,
day: Int,
hours: Int = 0,
minutes: Int = 0,
seconds: Int = 0,
nano: Int = 0,
zoneId: ZoneId
): DateTime {
return build(year, month, day, hours, minutes, seconds, nano, zoneId)
}
@JvmStatic
fun build(d: LocalDateTime): ZonedDateTime = d.atZone(ZoneId.systemDefault())
@JvmStatic
fun build(date: Date, zone: ZoneId): ZonedDateTime {
//val dateTime = ZonedDateTime.ofInstant(date.toInstant(), zone)
//val date = Instant.ofEpochMilli(date.toInstant().toEpochMilli()))
val calendar = java.util.GregorianCalendar()
calendar.time = date
val year = calendar.get(Calendar.YEAR)
val month = calendar.get(Calendar.MONTH) + 1
val day = calendar.get(Calendar.DAY_OF_MONTH)
val hour = calendar.get(Calendar.HOUR_OF_DAY)
val min = calendar.get(Calendar.MINUTE)
val sec = calendar.get(Calendar.SECOND)
val dateTime = ZonedDateTime.of(year, month, day, hour, min, sec, 0, zone)
return dateTime
}
/**
* Builds a DateTime ( ZonedDateTime of system zone ) using explicit values.
*/
@JvmStatic
fun build(
year: Int,
month: Int,
day: Int,
hours: Int = 0,
minutes: Int = 0,
seconds: Int = 0,
nano: Int = 0,
zoneId: ZoneId
): ZonedDateTime {
return ZonedDateTime.of(year, month, day, hours, minutes, seconds, nano, zoneId)
}
/**
* Builds a DateTime ( ZonedDateTime of system zone ) with current date/time.
*/
@JvmStatic
fun now(): DateTime = ZonedDateTime.now()
/**
* Builds a DateTime ( ZonedDateTime of UTC ) with current date/time.
*/
@JvmStatic
fun nowUtc(): DateTime = ZonedDateTime.now(ZoneId.of("UTC"))
/**
* Builds a DateTime ( ZonedDateTime of UTC ) with current date/time.
*/
@JvmStatic
fun nowAt(zone: String): DateTime = ZonedDateTime.now(ZoneId.of(zone))
/**
* Builds a DateTime ( ZonedDateTime of UTC ) with current date/time.
*/
@JvmStatic
fun nowAt(zone: ZoneId): DateTime = ZonedDateTime.now(zone)
@JvmStatic
fun today(): DateTime {
val now = ZonedDateTime.now()
return of(now.year, now.month.value, now.dayOfMonth)
}
@JvmStatic
fun tomorrow(): DateTime = today().plusDays(1)
@JvmStatic
fun yesterday(): DateTime = today().plusDays(-1)
@JvmStatic
fun daysAgo(days: Long): DateTime = today().plusDays(-1 * days)
@JvmStatic
fun daysFromNow(days: Long): DateTime = today().plusDays(days)
@JvmStatic
fun parse(value: String): DateTime {
// 20190101 ( jan 1 ) 8 chars
// 201901011200 ( jan 1 @12pm ) 12 chars
// 20190101123045 ( jan 1 @12:30:45 pm) 14 chars
if((value.length == 8 || value.length == 12 || value.length == 14) && Check.isNumeric(value)){
return parseNumeric(value)
}
val dt = DateTime.parse(value)
return dt
}
@JvmStatic
fun parseISO(value: String): DateTime {
return DateTime.parse(value, DateTimeFormatter.ISO_OFFSET_DATE_TIME)
}
fun daysInMonth(month:Int, year:Int) : Int {
return Month.of(month).daysInMonth(year)
}
fun startOfCurrentMonth():DateTime {
return DateTimes.now().atStartOfMonth()
}
/** Gets the start of the current days month.
* @return
*/
@JvmStatic
fun closestNextHour(): DateTime {
val now = DateTime.now()
if (now.minute < 30) {
return DateTime.of(now.year, now.monthValue, now.dayOfMonth, now.hour, 30, 0, 0, now.zone)
}
val next = DateTime.of(now.year, now.monthValue, now.dayOfMonth, now.hour, 0, 0, 0, now.zone)
return next.plusHours(1)
}
@JvmStatic
fun parse(text: String, formatter: DateTimeFormatter): DateTime {
val zonedDt = ZonedDateTime.parse(text, formatter)
return zonedDt
}
@JvmStatic
fun parseNumeric(value: String): DateTime {
val text = value.trim()
// Check 1: Empty string ?
val res = if (text.isNullOrEmpty()) {
DateTimes.MIN
} else if (text == "0") {
DateTimes.MIN
}
// Check 2: Date only - no time ?
// yyyymmdd = 8 chars
else if (text.length == 8) {
DateTimes.of(LocalDate.parse(text, DateTimeFormatter.ofPattern("yyyyMMdd")))
}
// Check 3: Date with time
// yyyymmddhhmm = 12chars
else if (text.length == 12) {
val years = text.substring(0, 4).toInt()
val months = text.substring(4, 6).toInt()
val days = text.substring(6, 8).toInt()
val hrs = text.substring(8, 10).toInt()
val mins = text.substring(10, 12).toInt()
val date = of(years, months, days, hrs, mins, 0)
date
}
// Check 4: Date with time with seconds
// yyyymmddhhmmss = 14chars
else if (text.length == 14) {
val years = text.substring(0, 4).toInt()
val months = text.substring(4, 6).toInt()
val days = text.substring(6, 8).toInt()
val hrs = text.substring(8, 10).toInt()
val mins = text.substring(10, 12).toInt()
val secs = text.substring(12, 14).toInt()
val date = of(years, months, days, hrs, mins, secs)
date
} else {
// Unexpected
DateTimes.MIN
}
return res
}
}
}
| src/lib/kotlin/slatekit-common/src/main/kotlin/slatekit/common/DateTime.kt | 4120021880 |
abstract class A<T> {
abstract fun test(a: T, b:Boolean = false) : String
}
class B : A<String>() {
override fun test(a: String, b: Boolean): String {
return a
}
}
fun box(): String {
return B().test("OK")
} | backend.native/tests/external/codegen/box/defaultArguments/signature/kt9924.kt | 2820058179 |
// WITH_RUNTIME
import kotlin.test.assertEquals
enum class BigEnum {
ITEM1, ITEM2, ITEM3, ITEM4, ITEM5, ITEM6, ITEM7, ITEM8, ITEM9, ITEM10,
ITEM11, ITEM12, ITEM13, ITEM14, ITEM15, ITEM16, ITEM17, ITEM18, ITEM19, ITEM20
}
fun bar1(x : BigEnum) : String {
when (x) {
BigEnum.ITEM1, BigEnum.ITEM2, BigEnum.ITEM3 -> return "123"
BigEnum.ITEM4, BigEnum.ITEM5, BigEnum.ITEM6 -> return "456"
}
return "-1";
}
fun bar2(x : BigEnum) : String {
when (x) {
BigEnum.ITEM7, BigEnum.ITEM8, BigEnum.ITEM9 -> return "789"
BigEnum.ITEM10 -> return "10"
BigEnum.ITEM11, BigEnum.ITEM12 -> return "1112"
else -> return "-1"
}
}
fun box() : String {
//bar1
assertEquals("123", bar1(BigEnum.ITEM1))
assertEquals("123", bar1(BigEnum.ITEM2))
assertEquals("123", bar1(BigEnum.ITEM3))
assertEquals("456", bar1(BigEnum.ITEM4))
assertEquals("456", bar1(BigEnum.ITEM5))
assertEquals("456", bar1(BigEnum.ITEM6))
assertEquals("-1", bar1(BigEnum.ITEM7))
//bar2
assertEquals("789", bar2(BigEnum.ITEM7))
assertEquals("789", bar2(BigEnum.ITEM8))
assertEquals("789", bar2(BigEnum.ITEM9))
assertEquals("10", bar2(BigEnum.ITEM10))
assertEquals("1112", bar2(BigEnum.ITEM11))
assertEquals("1112", bar2(BigEnum.ITEM12))
return "OK"
}
| backend.native/tests/external/codegen/box/when/enumOptimization/bigEnum.kt | 3367501362 |
// IGNORE_BACKEND: NATIVE
class A : HashMap<String, Double>()
fun box(): String {
val a = A()
val b = A()
a.put("", 0.0)
a.remove("")
a.putAll(b)
a.clear()
a.keys
a.values
a.entries
return "OK"
}
| backend.native/tests/external/codegen/box/builtinStubMethods/extendJavaCollections/hashMap.kt | 325180584 |
// Copyright 2000-2019 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file.
package com.intellij.xdebugger.impl.pinned.items
import org.jetbrains.annotations.ApiStatus
@ApiStatus.Experimental
interface PinToTopMemberValue : PinToTopValue {
fun canBePinned() : Boolean
/**
* When not null the name will be used as member name in PinToTop instead of node name. May be useful in a case when
* a value name presentation differs from its real name
*/
@JvmDefault
val customMemberName: String?
get() = null
/**
* When not null this tag will be used instead of getting tag from parent node
*/
@JvmDefault
val customParentTag: String?
get() = null
/**
* When not null the value will be used as 'pinned' status instead of checking the status inside [XDebuggerPinToTopManager] maps.
* It may be useful if you want to implement pinning logic inside your values by listening [XDebuggerPinToTopListener]
*/
@JvmDefault
val isPinned: Boolean?
get() = null
} | platform/xdebugger-impl/src/com/intellij/xdebugger/impl/pinned/items/PinToTopMemberValue.kt | 1453490416 |
// Copyright 2000-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file.
package org.editorconfig.language.util
import org.editorconfig.language.psi.EditorConfigSection
import org.editorconfig.language.psi.interfaces.EditorConfigDescribableElement
import org.editorconfig.language.util.core.EditorConfigIdentifierUtilCore
import org.editorconfig.language.util.core.EditorConfigPsiTreeUtilCore
object EditorConfigIdentifierUtil {
fun findIdentifiers(section: EditorConfigSection, id: String? = null, text: String? = null): List<EditorConfigDescribableElement> =
findDeclarations(section, id, text) + findReferences(section, id, text)
fun findDeclarations(section: EditorConfigSection, id: String? = null, text: String? = null): List<EditorConfigDescribableElement> {
val result = mutableListOf<EditorConfigDescribableElement>()
fun process(element: EditorConfigDescribableElement) {
if (EditorConfigIdentifierUtilCore.matchesDeclaration(element, id, text)) result.add(element)
element.children.mapNotNull { it as? EditorConfigDescribableElement }.forEach { process(it) }
}
EditorConfigPsiTreeUtilCore
.findMatchingSections(section)
.flatMap(EditorConfigSection::getOptionList)
.forEach(::process)
return result
}
fun findReferences(section: EditorConfigSection, id: String? = null, text: String? = null): List<EditorConfigDescribableElement> {
val result = mutableListOf<EditorConfigDescribableElement>()
fun process(element: EditorConfigDescribableElement) {
if (EditorConfigIdentifierUtilCore.matchesReference(element, id, text)) result.add(element)
element.children.mapNotNull { it as? EditorConfigDescribableElement }.forEach { process(it) }
}
EditorConfigPsiTreeUtilCore
.findMatchingSections(section)
.flatMap(EditorConfigSection::getOptionList)
.forEach(::process)
return result
}
}
| plugins/editorconfig/src/org/editorconfig/language/util/EditorConfigIdentifierUtil.kt | 3443464298 |
package com.jetbrains.packagesearch.intellij.plugin.ui.toolwindow.models
import com.intellij.openapi.project.Project
import kotlinx.coroutines.flow.Flow
internal interface RootDataModelProvider {
val project: Project
val dataModelFlow: Flow<RootDataModel>
val dataStatusState: Flow<DataStatus>
}
| plugins/package-search/src/com/jetbrains/packagesearch/intellij/plugin/ui/toolwindow/models/RootDataModelProvider.kt | 583993552 |
open class A {
open fun Int.<caret>foo(n: Int): Int {
return 1
}
}
class B : A() {
override fun Int.foo(n: Int): Int {
return 2
}
} | plugins/kotlin/idea/tests/testData/refactoring/changeSignature/SetErrorReturnTypeBefore.kt | 2934744383 |
public class OneLineKotlin {
var <caret>subject = 1
var aux = 1
public fun simple0() { subject }
public fun simple1() { subject = 2 }
public fun simple2() { aux = subject }
} | plugins/kotlin/idea/tests/testData/refactoring/rename/inplace/NoReformat.kt | 2114343317 |
infix fun String.concat(other: String): String = this
fun binaryContext(anchor: String?) {
val v1 = "1234567890... add many chars ...1234567890" concat "b"
val v2 = anchor ?: "1234567890... add many chars ...1234567890" concat "b"
val v3 = anchor ?: "1234567890... add many chars ...1234567890" concat "1234567890... add many chars ...1234567890" concat "1234567890... add many chars ...1234567890" concat "b"
}
// SET_INT: WRAP_ELVIS_EXPRESSIONS = 2
| plugins/kotlin/idea/tests/testData/formatter/ElvisWithOperationReference.kt | 2408640511 |
// "class org.jetbrains.kotlin.idea.quickfix.ChangeToStarProjectionFix" "false"
fun <T> get(column: String, map: Map<String, Any>): T {
return map[column] as <caret>T
}
| plugins/kotlin/idea/tests/testData/quickfix/addStarProjections/cast/uncheckedCastOnTypeParameter.kt | 1921440244 |
// Copyright 2000-2019 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file.
package git4idea.light
import com.intellij.ide.lightEdit.LightEdit
import com.intellij.ide.lightEdit.LightEditCompatible
import com.intellij.ide.lightEdit.LightEditService
import com.intellij.openapi.diagnostic.Logger
import com.intellij.openapi.project.Project
import com.intellij.openapi.util.Disposer
import com.intellij.openapi.util.text.HtmlBuilder
import com.intellij.openapi.wm.StatusBar
import com.intellij.openapi.wm.StatusBarWidget
import com.intellij.openapi.wm.StatusBarWidgetFactory
import com.intellij.util.Consumer
import git4idea.i18n.GitBundle
import java.awt.Component
import java.awt.event.MouseEvent
private const val ID = "light.edit.git"
private val LOG = Logger.getInstance("#git4idea.light.LightGitStatusBarWidget")
private class LightGitStatusBarWidget(private val lightGitTracker: LightGitTracker) : StatusBarWidget, StatusBarWidget.TextPresentation {
private var statusBar: StatusBar? = null
init {
lightGitTracker.addUpdateListener(object : LightGitTrackerListener {
override fun update() {
statusBar?.updateWidget(ID())
}
}, this)
}
override fun ID(): String = ID
override fun install(statusBar: StatusBar) {
this.statusBar = statusBar
}
override fun getPresentation(): StatusBarWidget.WidgetPresentation = this
override fun getText(): String {
return lightGitTracker.currentLocation?.let { GitBundle.message("git.light.status.bar.text", it) } ?: ""
}
override fun getTooltipText(): String {
val locationText = lightGitTracker.currentLocation?.let { GitBundle.message("git.light.status.bar.tooltip", it) } ?: ""
if (locationText.isBlank()) return locationText
val selectedFile = LightEditService.getInstance().selectedFile
if (selectedFile != null) {
val statusText = lightGitTracker.getFileStatus(selectedFile).getPresentation()
if (statusText.isNotBlank()) return HtmlBuilder().append(locationText).br().append(statusText).toString()
}
return locationText
}
override fun getAlignment(): Float = Component.LEFT_ALIGNMENT
override fun getClickConsumer(): Consumer<MouseEvent>? = null
override fun dispose() = Unit
}
class LightGitStatusBarWidgetFactory: StatusBarWidgetFactory, LightEditCompatible {
override fun getId(): String = ID
override fun getDisplayName(): String = GitBundle.message("git.light.status.bar.display.name")
override fun isAvailable(project: Project): Boolean = LightEdit.owns(project)
override fun createWidget(project: Project): StatusBarWidget {
LOG.assertTrue(LightEdit.owns(project))
return LightGitStatusBarWidget(LightGitTracker.getInstance())
}
override fun disposeWidget(widget: StatusBarWidget) = Disposer.dispose(widget)
override fun canBeEnabledOn(statusBar: StatusBar): Boolean = true
} | plugins/git4idea/src/git4idea/light/LightGitStatusBarWidget.kt | 2352741885 |
// Copyright 2000-2021 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file.
package org.intellij.plugins.markdown.ui.floating
import com.intellij.codeInsight.hint.HintManager
import com.intellij.codeInsight.hint.HintManagerImpl
import com.intellij.openapi.Disposable
import com.intellij.openapi.actionSystem.ActionGroup
import com.intellij.openapi.actionSystem.ActionManager
import com.intellij.openapi.actionSystem.ActionPlaces
import com.intellij.openapi.actionSystem.ActionToolbar
import com.intellij.openapi.actionSystem.impl.ActionToolbarImpl
import com.intellij.openapi.editor.Editor
import com.intellij.openapi.editor.event.EditorMouseEvent
import com.intellij.openapi.editor.event.EditorMouseListener
import com.intellij.openapi.editor.event.EditorMouseMotionListener
import com.intellij.psi.PsiDocumentManager
import com.intellij.psi.PsiElement
import com.intellij.psi.util.PsiEditorUtil
import com.intellij.psi.util.PsiUtilCore
import com.intellij.psi.util.elementType
import com.intellij.psi.util.parents
import com.intellij.ui.LightweightHint
import org.intellij.plugins.markdown.lang.MarkdownElementTypes
import org.intellij.plugins.markdown.lang.psi.impl.MarkdownFile
import org.jetbrains.annotations.ApiStatus
import java.awt.Point
import java.awt.event.KeyAdapter
import java.awt.event.KeyEvent
import javax.swing.JComponent
import kotlin.properties.Delegates
@ApiStatus.Internal
open class FloatingToolbar(val editor: Editor, private val actionGroupId: String) : Disposable {
private val mouseListener = MouseListener()
private val keyboardListener = KeyboardListener()
private val mouseMotionListener = MouseMotionListener()
private var hint: LightweightHint? = null
private var buttonSize: Int by Delegates.notNull()
private var lastSelection: String? = null
init {
registerListeners()
}
fun isShown() = hint != null
fun hideIfShown() {
hint?.hide()
}
fun showIfHidden() {
if (hint != null || !canBeShownAtCurrentSelection()) {
return
}
val toolbar = createActionToolbar(editor.contentComponent)
buttonSize = toolbar.maxButtonHeight
val newHint = LightweightHint(toolbar.component)
newHint.setForceShowAsPopup(true)
showOrUpdateLocation(newHint)
newHint.addHintListener { this.hint = null }
this.hint = newHint
}
fun updateLocationIfShown() {
showOrUpdateLocation(hint ?: return)
}
override fun dispose() {
unregisterListeners()
hideIfShown()
hint = null
}
private fun createActionToolbar(targetComponent: JComponent): ActionToolbar {
val group = ActionManager.getInstance().getAction(actionGroupId) as ActionGroup
val toolbar = object: ActionToolbarImpl(ActionPlaces.EDITOR_TOOLBAR, group, true) {
override fun addNotify() {
super.addNotify()
updateActionsImmediately(true)
}
}
toolbar.targetComponent = targetComponent
toolbar.setReservePlaceAutoPopupIcon(false)
return toolbar
}
private fun showOrUpdateLocation(hint: LightweightHint) {
HintManagerImpl.getInstanceImpl().showEditorHint(
hint,
editor,
getHintPosition(hint),
HintManager.HIDE_BY_ESCAPE or HintManager.UPDATE_BY_SCROLLING,
0,
true
)
}
private fun registerListeners() {
editor.addEditorMouseListener(mouseListener)
editor.addEditorMouseMotionListener(mouseMotionListener)
editor.contentComponent.addKeyListener(keyboardListener)
}
private fun unregisterListeners() {
editor.removeEditorMouseListener(mouseListener)
editor.removeEditorMouseMotionListener(mouseMotionListener)
editor.contentComponent.removeKeyListener(keyboardListener)
}
private fun canBeShownAtCurrentSelection(): Boolean {
val file = PsiEditorUtil.getPsiFile(editor)
PsiDocumentManager.getInstance(file.project).commitDocument(editor.document)
val selectionModel = editor.selectionModel
val elementAtStart = PsiUtilCore.getElementAtOffset(file, selectionModel.selectionStart)
val elementAtEnd = PsiUtilCore.getElementAtOffset(file, selectionModel.selectionEnd)
return !(hasIgnoredParent(elementAtStart) || hasIgnoredParent(elementAtEnd))
}
protected open fun hasIgnoredParent(element: PsiElement): Boolean {
if (element.containingFile !is MarkdownFile) {
return true
}
return element.parents(withSelf = true).any { it.elementType in elementsToIgnore }
}
private fun getHintPosition(hint: LightweightHint): Point {
val hintPos = HintManagerImpl.getInstanceImpl().getHintPosition(hint, editor, HintManager.DEFAULT)
// because of `hint.setForceShowAsPopup(true)`, HintManager.ABOVE does not place the hint above
// the hint remains on the line, so we need to move it up ourselves
val dy = -(hint.component.preferredSize.height + verticalGap)
val dx = buttonSize * -2
hintPos.translate(dx, dy)
return hintPos
}
private fun updateOnProbablyChangedSelection(onSelectionChanged: (String) -> Unit) {
val newSelection = editor.selectionModel.selectedText
when (newSelection) {
null -> hideIfShown()
lastSelection -> Unit
else -> onSelectionChanged(newSelection)
}
lastSelection = newSelection
}
private inner class MouseListener : EditorMouseListener {
override fun mouseReleased(e: EditorMouseEvent) {
updateOnProbablyChangedSelection {
if (isShown()) {
updateLocationIfShown()
} else {
showIfHidden()
}
}
}
}
private inner class KeyboardListener : KeyAdapter() {
override fun keyReleased(e: KeyEvent) {
super.keyReleased(e)
if (e.source != editor.contentComponent) {
return
}
updateOnProbablyChangedSelection {
hideIfShown()
}
}
}
private inner class MouseMotionListener : EditorMouseMotionListener {
override fun mouseMoved(e: EditorMouseEvent) {
val visualPosition = e.visualPosition
val hoverSelected = editor.caretModel.allCarets.any {
val beforeSelectionEnd = it.selectionEndPosition.after(visualPosition)
val afterSelectionStart = visualPosition.after(it.selectionStartPosition)
beforeSelectionEnd && afterSelectionStart
}
if (hoverSelected) {
showIfHidden()
}
}
}
companion object {
private const val verticalGap = 2
private val elementsToIgnore = listOf(
MarkdownElementTypes.CODE_FENCE,
MarkdownElementTypes.CODE_BLOCK,
MarkdownElementTypes.CODE_SPAN,
MarkdownElementTypes.HTML_BLOCK,
MarkdownElementTypes.LINK_DESTINATION
)
}
}
| plugins/markdown/core/src/org/intellij/plugins/markdown/ui/floating/FloatingToolbar.kt | 1553284435 |
// Copyright 2000-2021 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license.
package com.intellij.util.indexing.roots
import com.intellij.navigation.ItemPresentation
import com.intellij.openapi.application.runReadAction
import com.intellij.openapi.project.Project
import com.intellij.openapi.roots.ContentIterator
import com.intellij.openapi.vfs.VirtualFile
import com.intellij.openapi.vfs.VirtualFileFilter
import com.intellij.util.indexing.IndexableSetContributor
import com.intellij.util.indexing.IndexingBundle
import com.intellij.util.indexing.roots.origin.IndexableSetContributorOriginImpl
import com.intellij.util.indexing.roots.kind.IndexableSetOrigin
internal class IndexableSetContributorFilesIterator(private val indexableSetContributor: IndexableSetContributor,
private val projectAware: Boolean) : IndexableFilesIterator {
override fun getDebugName(): String {
val debugName = getName()?.takeUnless { it.isEmpty() } ?: indexableSetContributor.debugName
return "Indexable set contributor '$debugName' ${if (projectAware) "(project)" else "(non-project)"}"
}
override fun getIndexingProgressText(): String {
val name = getName()
if (!name.isNullOrEmpty()) {
return IndexingBundle.message("indexable.files.provider.indexing.named.provider", name)
}
return IndexingBundle.message("indexable.files.provider.indexing.additional.dependencies")
}
override fun getRootsScanningProgressText(): String {
val name = getName()
if (!name.isNullOrEmpty()) {
return IndexingBundle.message("indexable.files.provider.scanning.files.contributor", name)
}
return IndexingBundle.message("indexable.files.provider.scanning.additional.dependencies")
}
override fun getOrigin(): IndexableSetOrigin = IndexableSetContributorOriginImpl(indexableSetContributor)
private fun getName() = (indexableSetContributor as? ItemPresentation)?.presentableText
override fun iterateFiles(
project: Project,
fileIterator: ContentIterator,
fileFilter: VirtualFileFilter
): Boolean {
val allRoots = collectRoots(project)
return IndexableFilesIterationMethods.iterateRoots(project, allRoots, fileIterator, fileFilter, excludeNonProjectRoots = false)
}
private fun collectRoots(project: Project): MutableSet<VirtualFile> {
val allRoots = runReadAction {
if (projectAware) indexableSetContributor.getAdditionalProjectRootsToIndex(project)
else indexableSetContributor.additionalRootsToIndex
}
return allRoots
}
override fun getRootUrls(project: Project): Set<String> {
return collectRoots(project).map { it.url }.toSet()
}
} | platform/lang-impl/src/com/intellij/util/indexing/roots/IndexableSetContributorFilesIterator.kt | 4223881000 |
package codes.foobar.passwd.domain
object PasswordRegex {
val A_Z_LOWER_REGEX = "a-z"
val A_Z_UPPER_REGEX = "A-Z"
val NUMBER_REGEX = "0-9"
val SPECIAL_REGEX = "!\"#$%&\\U+0027()*+,-./:;<=>?@[\\]^_`{|}~"
val FULL_REGEX = A_Z_LOWER_REGEX + A_Z_UPPER_REGEX + NUMBER_REGEX + SPECIAL_REGEX
fun pattern(options: Options) =
if (options.atLeastOneTrue()) {
regexOrEmpty(options.lowerCase, A_Z_LOWER_REGEX) +
regexOrEmpty(options.upperCase, A_Z_UPPER_REGEX) +
regexOrEmpty(options.numbers, NUMBER_REGEX) +
regexOrEmpty(options.special, SPECIAL_REGEX)
} else {
FULL_REGEX
}
private fun regexOrEmpty(b: Boolean, regex: String) = if (b) regex else ""
} | src/main/kotlin/codes/foobar/passwd/domain/PasswordRegex.kt | 3218235415 |
package flank.scripts.data.github.objects
import com.github.kittinunf.fuel.core.ResponseDeserializable
import flank.scripts.utils.toObject
import kotlinx.serialization.Serializable
@Serializable
data class GitHubCommit(
val sha: String,
val commit: Commit
)
@Serializable
data class Commit(
val author: Author
)
@Serializable
data class Author(
val name: String,
val email: String,
val date: String
)
object GitHubCommitListDeserializer : ResponseDeserializable<List<GitHubCommit>> {
override fun deserialize(content: String): List<GitHubCommit> = content.toObject()
}
| flank-scripts/src/main/kotlin/flank/scripts/data/github/objects/GitHubCommit.kt | 3799130093 |
package info.nightscout.androidaps.plugins.pump.medtronic
import android.content.Intent
import android.graphics.Color
import android.os.Bundle
import android.os.Handler
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import androidx.fragment.app.Fragment
import info.nightscout.androidaps.MainApp
import info.nightscout.androidaps.R
import info.nightscout.androidaps.events.EventExtendedBolusChange
import info.nightscout.androidaps.events.EventPumpStatusChanged
import info.nightscout.androidaps.events.EventTempBasalChange
import info.nightscout.androidaps.logging.L
import info.nightscout.androidaps.plugins.bus.RxBus
import info.nightscout.androidaps.plugins.configBuilder.ConfigBuilderPlugin
import info.nightscout.androidaps.plugins.pump.common.hw.rileylink.RileyLinkUtil
import info.nightscout.androidaps.plugins.pump.common.hw.rileylink.defs.RileyLinkError
import info.nightscout.androidaps.plugins.pump.common.hw.rileylink.defs.RileyLinkServiceState
import info.nightscout.androidaps.plugins.pump.common.hw.rileylink.defs.RileyLinkTargetDevice
import info.nightscout.androidaps.plugins.pump.common.hw.rileylink.dialog.RileyLinkStatusActivity
import info.nightscout.androidaps.plugins.pump.medtronic.defs.BatteryType
import info.nightscout.androidaps.plugins.pump.medtronic.defs.MedtronicCommandType
import info.nightscout.androidaps.plugins.pump.medtronic.defs.PumpDeviceState
import info.nightscout.androidaps.plugins.pump.medtronic.dialog.MedtronicHistoryActivity
import info.nightscout.androidaps.plugins.pump.medtronic.driver.MedtronicPumpStatus
import info.nightscout.androidaps.plugins.pump.medtronic.events.EventMedtronicDeviceStatusChange
import info.nightscout.androidaps.plugins.pump.medtronic.events.EventMedtronicPumpConfigurationChanged
import info.nightscout.androidaps.plugins.pump.medtronic.events.EventMedtronicPumpValuesChanged
import info.nightscout.androidaps.plugins.pump.medtronic.events.EventRefreshButtonState
import info.nightscout.androidaps.plugins.pump.medtronic.util.MedtronicUtil
import info.nightscout.androidaps.plugins.treatments.TreatmentsPlugin
import info.nightscout.androidaps.queue.Callback
import info.nightscout.androidaps.queue.events.EventQueueChanged
import info.nightscout.androidaps.utils.*
import io.reactivex.android.schedulers.AndroidSchedulers
import io.reactivex.disposables.CompositeDisposable
import kotlinx.android.synthetic.main.medtronic_fragment.*
import org.slf4j.LoggerFactory
class MedtronicFragment : Fragment() {
private val log = LoggerFactory.getLogger(L.PUMP)
private var disposable: CompositeDisposable = CompositeDisposable()
private val loopHandler = Handler()
private lateinit var refreshLoop: Runnable
init {
refreshLoop = Runnable {
activity?.runOnUiThread { updateGUI() }
loopHandler.postDelayed(refreshLoop, T.mins(1).msecs())
}
}
override fun onCreateView(inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle?): View? {
return inflater.inflate(R.layout.medtronic_fragment, container, false)
}
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
super.onViewCreated(view, savedInstanceState)
medtronic_pumpstatus.setBackgroundColor(MainApp.gc(R.color.colorInitializingBorder))
medtronic_rl_status.text = MainApp.gs(RileyLinkServiceState.NotStarted.getResourceId(RileyLinkTargetDevice.MedtronicPump))
medtronic_pump_status.setTextColor(Color.WHITE)
medtronic_pump_status.text = "{fa-bed}"
medtronic_history.setOnClickListener {
if (MedtronicUtil.getPumpStatus().verifyConfiguration()) {
startActivity(Intent(context, MedtronicHistoryActivity::class.java))
} else {
MedtronicUtil.displayNotConfiguredDialog(context)
}
}
medtronic_refresh.setOnClickListener {
if (!MedtronicUtil.getPumpStatus().verifyConfiguration()) {
MedtronicUtil.displayNotConfiguredDialog(context)
} else {
medtronic_refresh.isEnabled = false
MedtronicPumpPlugin.getPlugin().resetStatusState()
ConfigBuilderPlugin.getPlugin().commandQueue.readStatus("Clicked refresh", object : Callback() {
override fun run() {
activity?.runOnUiThread { medtronic_refresh?.isEnabled = true }
}
})
}
}
medtronic_stats.setOnClickListener {
if (MedtronicUtil.getPumpStatus().verifyConfiguration()) {
startActivity(Intent(context, RileyLinkStatusActivity::class.java))
} else {
MedtronicUtil.displayNotConfiguredDialog(context)
}
}
}
@Synchronized
override fun onResume() {
super.onResume()
loopHandler.postDelayed(refreshLoop, T.mins(1).msecs())
disposable += RxBus
.toObservable(EventRefreshButtonState::class.java)
.observeOn(AndroidSchedulers.mainThread())
.subscribe({ medtronic_refresh.isEnabled = it.newState }, { FabricPrivacy.logException(it) })
disposable += RxBus
.toObservable(EventMedtronicDeviceStatusChange::class.java)
.observeOn(AndroidSchedulers.mainThread())
.subscribe({
if (L.isEnabled(L.PUMP))
log.info("onStatusEvent(EventMedtronicDeviceStatusChange): {}", it)
setDeviceStatus()
}, { FabricPrivacy.logException(it) })
disposable += RxBus
.toObservable(EventMedtronicPumpValuesChanged::class.java)
.observeOn(AndroidSchedulers.mainThread())
.subscribe({ updateGUI() }, { FabricPrivacy.logException(it) })
disposable += RxBus
.toObservable(EventExtendedBolusChange::class.java)
.observeOn(AndroidSchedulers.mainThread())
.subscribe({ updateGUI() }, { FabricPrivacy.logException(it) })
disposable += RxBus
.toObservable(EventTempBasalChange::class.java)
.observeOn(AndroidSchedulers.mainThread())
.subscribe({ updateGUI() }, { FabricPrivacy.logException(it) })
disposable += RxBus
.toObservable(EventMedtronicPumpConfigurationChanged::class.java)
.observeOn(AndroidSchedulers.mainThread())
.subscribe({
if (L.isEnabled(L.PUMP))
log.debug("EventMedtronicPumpConfigurationChanged triggered")
MedtronicUtil.getPumpStatus().verifyConfiguration()
updateGUI()
}, { FabricPrivacy.logException(it) })
disposable += RxBus
.toObservable(EventPumpStatusChanged::class.java)
.observeOn(AndroidSchedulers.mainThread())
.subscribe({ updateGUI() }, { FabricPrivacy.logException(it) })
disposable += RxBus
.toObservable(EventQueueChanged::class.java)
.observeOn(AndroidSchedulers.mainThread())
.subscribe({ updateGUI() }, { FabricPrivacy.logException(it) })
updateGUI()
}
@Synchronized
override fun onPause() {
super.onPause()
disposable.clear()
loopHandler.removeCallbacks(refreshLoop)
}
@Synchronized
private fun setDeviceStatus() {
val pumpStatus: MedtronicPumpStatus = MedtronicUtil.getPumpStatus()
pumpStatus.rileyLinkServiceState = checkStatusSet(pumpStatus.rileyLinkServiceState,
RileyLinkUtil.getServiceState()) as RileyLinkServiceState?
val resourceId = pumpStatus.rileyLinkServiceState.getResourceId(RileyLinkTargetDevice.MedtronicPump)
val rileyLinkError = RileyLinkUtil.getError()
medtronic_rl_status.text =
when {
pumpStatus.rileyLinkServiceState == RileyLinkServiceState.NotStarted -> MainApp.gs(resourceId)
pumpStatus.rileyLinkServiceState.isConnecting -> "{fa-bluetooth-b spin} " + MainApp.gs(resourceId)
pumpStatus.rileyLinkServiceState.isError && rileyLinkError == null -> "{fa-bluetooth-b} " + MainApp.gs(resourceId)
pumpStatus.rileyLinkServiceState.isError && rileyLinkError != null -> "{fa-bluetooth-b} " + MainApp.gs(rileyLinkError.getResourceId(RileyLinkTargetDevice.MedtronicPump))
else -> "{fa-bluetooth-b} " + MainApp.gs(resourceId)
}
medtronic_rl_status.setTextColor(if (rileyLinkError != null) Color.RED else Color.WHITE)
pumpStatus.rileyLinkError = checkStatusSet(pumpStatus.rileyLinkError, RileyLinkUtil.getError()) as RileyLinkError?
medtronic_errors.text =
pumpStatus.rileyLinkError?.let {
MainApp.gs(it.getResourceId(RileyLinkTargetDevice.MedtronicPump))
} ?: "-"
pumpStatus.pumpDeviceState = checkStatusSet(pumpStatus.pumpDeviceState,
MedtronicUtil.getPumpDeviceState()) as PumpDeviceState?
when (pumpStatus.pumpDeviceState) {
null,
PumpDeviceState.Sleeping -> medtronic_pump_status.text = "{fa-bed} " // + pumpStatus.pumpDeviceState.name());
PumpDeviceState.NeverContacted,
PumpDeviceState.WakingUp,
PumpDeviceState.PumpUnreachable,
PumpDeviceState.ErrorWhenCommunicating,
PumpDeviceState.TimeoutWhenCommunicating,
PumpDeviceState.InvalidConfiguration -> medtronic_pump_status.text = " " + MainApp.gs(pumpStatus.pumpDeviceState.resourceId)
PumpDeviceState.Active -> {
val cmd = MedtronicUtil.getCurrentCommand()
if (cmd == null)
medtronic_pump_status.text = " " + MainApp.gs(pumpStatus.pumpDeviceState.resourceId)
else {
log.debug("Command: " + cmd)
val cmdResourceId = cmd.resourceId
if (cmd == MedtronicCommandType.GetHistoryData) {
medtronic_pump_status.text = MedtronicUtil.frameNumber?.let {
MainApp.gs(cmdResourceId, MedtronicUtil.pageNumber, MedtronicUtil.frameNumber)
}
?: MainApp.gs(R.string.medtronic_cmd_desc_get_history_request, MedtronicUtil.pageNumber)
} else {
medtronic_pump_status.text = " " + (cmdResourceId?.let { MainApp.gs(it) }
?: cmd.getCommandDescription())
}
}
}
else -> log.warn("Unknown pump state: " + pumpStatus.pumpDeviceState)
}
val status = ConfigBuilderPlugin.getPlugin().commandQueue.spannedStatus()
if (status.toString() == "") {
medtronic_queue.visibility = View.GONE
} else {
medtronic_queue.visibility = View.VISIBLE
medtronic_queue.text = status
}
}
private fun checkStatusSet(object1: Any?, object2: Any?): Any? {
return if (object1 == null) {
object2
} else {
if (object1 != object2) {
object2
} else
object1
}
}
// GUI functions
@Synchronized
fun updateGUI() {
if (medtronic_rl_status == null) return
val plugin = MedtronicPumpPlugin.getPlugin()
val pumpStatus = MedtronicUtil.getPumpStatus()
setDeviceStatus()
// last connection
if (pumpStatus.lastConnection != 0L) {
val minAgo = DateUtil.minAgo(pumpStatus.lastConnection)
val min = (System.currentTimeMillis() - pumpStatus.lastConnection) / 1000 / 60
if (pumpStatus.lastConnection + 60 * 1000 > System.currentTimeMillis()) {
medtronic_lastconnection.setText(R.string.combo_pump_connected_now)
medtronic_lastconnection.setTextColor(Color.WHITE)
} else if (pumpStatus.lastConnection + 30 * 60 * 1000 < System.currentTimeMillis()) {
if (min < 60) {
medtronic_lastconnection.text = MainApp.gs(R.string.minago, min)
} else if (min < 1440) {
val h = (min / 60).toInt()
medtronic_lastconnection.text = (MainApp.gq(R.plurals.objective_hours, h, h) + " "
+ MainApp.gs(R.string.ago))
} else {
val h = (min / 60).toInt()
val d = h / 24
// h = h - (d * 24);
medtronic_lastconnection.text = (MainApp.gq(R.plurals.objective_days, d, d) + " "
+ MainApp.gs(R.string.ago))
}
medtronic_lastconnection.setTextColor(Color.RED)
} else {
medtronic_lastconnection.text = minAgo
medtronic_lastconnection.setTextColor(Color.WHITE)
}
}
// last bolus
val bolus = pumpStatus.lastBolusAmount
val bolusTime = pumpStatus.lastBolusTime
if (bolus != null && bolusTime != null) {
val agoMsc = System.currentTimeMillis() - pumpStatus.lastBolusTime.time
val bolusMinAgo = agoMsc.toDouble() / 60.0 / 1000.0
val unit = MainApp.gs(R.string.insulin_unit_shortname)
val ago: String
if (agoMsc < 60 * 1000) {
ago = MainApp.gs(R.string.combo_pump_connected_now)
} else if (bolusMinAgo < 60) {
ago = DateUtil.minAgo(pumpStatus.lastBolusTime.time)
} else {
ago = DateUtil.hourAgo(pumpStatus.lastBolusTime.time)
}
medtronic_lastbolus.text = MainApp.gs(R.string.combo_last_bolus, bolus, unit, ago)
} else {
medtronic_lastbolus.text = ""
}
// base basal rate
medtronic_basabasalrate.text = ("(" + pumpStatus.activeProfileName + ") "
+ MainApp.gs(R.string.pump_basebasalrate, plugin.baseBasalRate))
medtronic_tempbasal.text = TreatmentsPlugin.getPlugin()
.getTempBasalFromHistory(System.currentTimeMillis())?.toStringFull() ?: ""
// battery
if (MedtronicUtil.getBatteryType() == BatteryType.None || pumpStatus.batteryVoltage == null) {
medtronic_pumpstate_battery.text = "{fa-battery-" + pumpStatus.batteryRemaining / 25 + "} "
} else {
medtronic_pumpstate_battery.text = "{fa-battery-" + pumpStatus.batteryRemaining / 25 + "} " + pumpStatus.batteryRemaining + "%" + String.format(" (%.2f V)", pumpStatus.batteryVoltage)
}
SetWarnColor.setColorInverse(medtronic_pumpstate_battery, pumpStatus.batteryRemaining.toDouble(), 25.0, 10.0)
// reservoir
medtronic_reservoir.text = MainApp.gs(R.string.reservoirvalue, pumpStatus.reservoirRemainingUnits, pumpStatus.reservoirFullUnits)
SetWarnColor.setColorInverse(medtronic_reservoir, pumpStatus.reservoirRemainingUnits, 50.0, 20.0)
medtronic_errors.text = pumpStatus.errorInfo
}
}
| app/src/main/java/info/nightscout/androidaps/plugins/pump/medtronic/MedtronicFragment.kt | 298126868 |
// Copyright 2000-2022 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license.
package org.jetbrains.kotlin.idea.completion
import com.intellij.codeInsight.completion.AllClassesGetter
import com.intellij.codeInsight.completion.CompletionParameters
import com.intellij.codeInsight.completion.PrefixMatcher
import com.intellij.psi.PsiClass
import com.intellij.psi.search.PsiShortNamesCache
import org.jetbrains.kotlin.asJava.classes.KtLightClass
import org.jetbrains.kotlin.descriptors.ClassDescriptor
import org.jetbrains.kotlin.descriptors.ClassKind
import org.jetbrains.kotlin.descriptors.ClassifierDescriptorWithTypeParameters
import org.jetbrains.kotlin.idea.base.facet.platform.platform
import org.jetbrains.kotlin.idea.base.psi.kotlinFqName
import org.jetbrains.kotlin.idea.base.utils.fqname.isJavaClassNotToBeUsedInKotlin
import org.jetbrains.kotlin.idea.caches.KotlinShortNamesCache
import org.jetbrains.kotlin.idea.core.KotlinIndicesHelper
import org.jetbrains.kotlin.idea.resolve.ResolutionFacade
import org.jetbrains.kotlin.idea.util.isSyntheticKotlinClass
import org.jetbrains.kotlin.platform.jvm.isJvm
import org.jetbrains.kotlin.psi.KtFile
import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter
import org.jetbrains.kotlin.resolve.scopes.MemberScope
import org.jetbrains.kotlin.resolve.scopes.getDescriptorsFiltered
class AllClassesCompletion(
private val parameters: CompletionParameters,
private val kotlinIndicesHelper: KotlinIndicesHelper,
private val prefixMatcher: PrefixMatcher,
private val resolutionFacade: ResolutionFacade,
private val kindFilter: (ClassKind) -> Boolean,
private val includeTypeAliases: Boolean,
private val includeJavaClassesNotToBeUsed: Boolean
) {
fun collect(classifierDescriptorCollector: (ClassifierDescriptorWithTypeParameters) -> Unit, javaClassCollector: (PsiClass) -> Unit) {
//TODO: this is a temporary solution until we have built-ins in indices
// we need only nested classes because top-level built-ins are all added through default imports
for (builtInPackage in resolutionFacade.moduleDescriptor.builtIns.builtInPackagesImportedByDefault) {
collectClassesFromScope(builtInPackage.memberScope) {
if (it.containingDeclaration is ClassDescriptor) {
classifierDescriptorCollector(it)
}
}
}
kotlinIndicesHelper.processKotlinClasses(
{ prefixMatcher.prefixMatches(it) },
kindFilter = kindFilter,
processor = classifierDescriptorCollector
)
if (includeTypeAliases) {
kotlinIndicesHelper.processTopLevelTypeAliases(prefixMatcher.asStringNameFilter(), classifierDescriptorCollector)
}
if ((parameters.originalFile as KtFile).platform.isJvm()) {
addAdaptedJavaCompletion(javaClassCollector)
}
}
private fun collectClassesFromScope(scope: MemberScope, collector: (ClassDescriptor) -> Unit) {
for (descriptor in scope.getDescriptorsFiltered(DescriptorKindFilter.CLASSIFIERS)) {
if (descriptor is ClassDescriptor) {
if (kindFilter(descriptor.kind) && prefixMatcher.prefixMatches(descriptor.name.asString())) {
collector(descriptor)
}
collectClassesFromScope(descriptor.unsubstitutedInnerClassesScope, collector)
}
}
}
private fun addAdaptedJavaCompletion(collector: (PsiClass) -> Unit) {
val shortNamesCache = PsiShortNamesCache.EP_NAME.getExtensions(parameters.editor.project).firstOrNull {
it is KotlinShortNamesCache
} as KotlinShortNamesCache?
shortNamesCache?.disableSearch?.set(true)
try {
AllClassesGetter.processJavaClasses(parameters, prefixMatcher, true) { psiClass ->
if (psiClass!! !is KtLightClass) { // Kotlin class should have already been added as kotlin element before
if (psiClass.isSyntheticKotlinClass()) return@processJavaClasses // filter out synthetic classes produced by Kotlin compiler
val kind = when {
psiClass.isAnnotationType -> ClassKind.ANNOTATION_CLASS
psiClass.isInterface -> ClassKind.INTERFACE
psiClass.isEnum -> ClassKind.ENUM_CLASS
else -> ClassKind.CLASS
}
if (kindFilter(kind) && !isNotToBeUsed(psiClass)) {
collector(psiClass)
}
}
}
} finally {
shortNamesCache?.disableSearch?.set(false)
}
}
private fun isNotToBeUsed(javaClass: PsiClass): Boolean {
if (includeJavaClassesNotToBeUsed) return false
val fqName = javaClass.kotlinFqName
return fqName?.isJavaClassNotToBeUsedInKotlin() == true
}
}
| plugins/kotlin/completion/src/org/jetbrains/kotlin/idea/completion/AllClassesCompletion.kt | 2954009090 |
// Copyright 2000-2022 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license.
@file:Suppress("ReplaceGetOrSet", "ReplacePutWithAssignment", "OverridingDeprecatedMember", "ReplaceNegatedIsEmptyWithIsNotEmpty")
package com.intellij.openapi.wm.impl
import com.intellij.diagnostic.LoadingState
import com.intellij.diagnostic.PluginException
import com.intellij.icons.AllIcons
import com.intellij.ide.IdeEventQueue
import com.intellij.ide.UiActivity
import com.intellij.ide.UiActivityMonitor
import com.intellij.ide.actions.ActivateToolWindowAction
import com.intellij.ide.actions.MaximizeActiveDialogAction
import com.intellij.internal.statistic.collectors.fus.actions.persistence.ToolWindowCollector
import com.intellij.notification.impl.NotificationsManagerImpl
import com.intellij.openapi.Disposable
import com.intellij.openapi.MnemonicHelper
import com.intellij.openapi.actionSystem.*
import com.intellij.openapi.actionSystem.ex.AnActionListener
import com.intellij.openapi.application.ApplicationManager
import com.intellij.openapi.application.EDT
import com.intellij.openapi.application.ModalityState
import com.intellij.openapi.application.asContextElement
import com.intellij.openapi.components.*
import com.intellij.openapi.diagnostic.debug
import com.intellij.openapi.diagnostic.logger
import com.intellij.openapi.extensions.PluginDescriptor
import com.intellij.openapi.fileEditor.FileEditorManager
import com.intellij.openapi.fileEditor.FileEditorManagerListener
import com.intellij.openapi.fileEditor.ex.FileEditorManagerEx
import com.intellij.openapi.fileEditor.impl.EditorsSplitters
import com.intellij.openapi.keymap.Keymap
import com.intellij.openapi.keymap.KeymapManager
import com.intellij.openapi.keymap.KeymapManagerListener
import com.intellij.openapi.progress.ProcessCanceledException
import com.intellij.openapi.project.*
import com.intellij.openapi.project.ex.ProjectEx
import com.intellij.openapi.ui.FrameWrapper
import com.intellij.openapi.ui.Splitter
import com.intellij.openapi.ui.popup.Balloon
import com.intellij.openapi.ui.popup.JBPopupFactory
import com.intellij.openapi.util.*
import com.intellij.openapi.util.registry.Registry
import com.intellij.openapi.vfs.VirtualFile
import com.intellij.openapi.wm.*
import com.intellij.openapi.wm.ex.ToolWindowEx
import com.intellij.openapi.wm.ex.ToolWindowManagerEx
import com.intellij.openapi.wm.ex.ToolWindowManagerListener
import com.intellij.openapi.wm.ex.ToolWindowManagerListener.ToolWindowManagerEventType
import com.intellij.openapi.wm.ex.ToolWindowManagerListener.ToolWindowManagerEventType.Resized
import com.intellij.serviceContainer.NonInjectable
import com.intellij.toolWindow.*
import com.intellij.ui.BalloonImpl
import com.intellij.ui.ClientProperty
import com.intellij.ui.ComponentUtil
import com.intellij.ui.ExperimentalUI
import com.intellij.ui.awt.RelativePoint
import com.intellij.util.BitUtil
import com.intellij.util.EventDispatcher
import com.intellij.util.SingleAlarm
import com.intellij.util.SystemProperties
import com.intellij.util.concurrency.EdtExecutorService
import com.intellij.util.messages.MessageBusConnection
import com.intellij.util.ui.EDT
import com.intellij.util.ui.PositionTracker
import com.intellij.util.ui.StartupUiUtil
import com.intellij.util.ui.UIUtil
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.withContext
import org.intellij.lang.annotations.JdkConstants
import org.jetbrains.annotations.ApiStatus
import org.jetbrains.annotations.TestOnly
import org.jetbrains.annotations.VisibleForTesting
import java.awt.*
import java.awt.event.*
import java.beans.PropertyChangeListener
import java.util.*
import java.util.concurrent.CancellationException
import java.util.concurrent.TimeUnit
import javax.swing.*
import javax.swing.event.HyperlinkEvent
import javax.swing.event.HyperlinkListener
private val LOG = logger<ToolWindowManagerImpl>()
private typealias Mutation = ((WindowInfoImpl) -> Unit)
@ApiStatus.Internal
open class ToolWindowManagerImpl @NonInjectable @TestOnly internal constructor(val project: Project,
@field:JvmField internal val isNewUi: Boolean,
private val isEdtRequired: Boolean)
: ToolWindowManagerEx(), Disposable {
private val dispatcher = EventDispatcher.create(ToolWindowManagerListener::class.java)
private val state: ToolWindowManagerState
get() = project.service()
private var layoutState
get() = state.layout
set(value) { state.layout = value }
private val idToEntry = HashMap<String, ToolWindowEntry>()
private val activeStack = ActiveStack()
private val sideStack = SideStack()
private val toolWindowPanes = LinkedHashMap<String, ToolWindowPane>()
private var frameState: ProjectFrameHelper?
get() = state.frame
set(value) { state.frame = value }
override var layoutToRestoreLater: DesktopLayout?
get() = state.layoutToRestoreLater
set(value) { state.layoutToRestoreLater = value }
private var currentState = KeyState.WAITING
private val waiterForSecondPress: SingleAlarm?
private val recentToolWindowsState: LinkedList<String>
get() = state.recentToolWindows
@Suppress("LeakingThis")
private val toolWindowSetInitializer = ToolWindowSetInitializer(project, this)
@Suppress("TestOnlyProblems")
constructor(project: Project) : this(project, isNewUi = ExperimentalUI.isNewUI(), isEdtRequired = true)
init {
if (project.isDefault) {
waiterForSecondPress = null
}
else {
waiterForSecondPress = SingleAlarm(
task = Runnable {
if (currentState != KeyState.HOLD) {
resetHoldState()
}
},
delay = SystemProperties.getIntProperty("actionSystem.keyGestureDblClickTime", 650),
parentDisposable = (project as ProjectEx).earlyDisposable
)
if (state.noStateLoaded) {
loadDefault()
}
@Suppress("LeakingThis")
state.scheduledLayout.afterChange(this) { dl ->
dl?.let { toolWindowSetInitializer.scheduleSetLayout(it) }
}
state.scheduledLayout.get()?.let { toolWindowSetInitializer.scheduleSetLayout(it) }
}
}
companion object {
/**
* Setting this [client property][JComponent.putClientProperty] allows specifying 'effective' parent for a component which will be used
* to find a tool window to which component belongs (if any). This can prevent tool windows in non-default view modes (e.g. 'Undock')
* to close when focus is transferred to a component not in tool window hierarchy, but logically belonging to it (e.g. when component
* is added to the window's layered pane).
*
* @see ComponentUtil.putClientProperty
*/
@JvmField
val PARENT_COMPONENT: Key<JComponent> = Key.create("tool.window.parent.component")
@JvmStatic
@ApiStatus.Internal
fun getRegisteredMutableInfoOrLogError(decorator: InternalDecoratorImpl): WindowInfoImpl {
val toolWindow = decorator.toolWindow
return toolWindow.toolWindowManager.getRegisteredMutableInfoOrLogError(toolWindow.id)
}
fun getAdjustedRatio(partSize: Int, totalSize: Int, direction: Int): Float {
var ratio = partSize.toFloat() / totalSize
ratio += (((partSize.toFloat() + direction) / totalSize) - ratio) / 2
return ratio
}
}
fun isToolWindowRegistered(id: String) = idToEntry.containsKey(id)
internal fun getEntry(id: String) = idToEntry.get(id)
internal fun assertIsEdt() {
if (isEdtRequired) {
EDT.assertIsEdt()
}
}
override fun dispose() {
}
@Service(Service.Level.APP)
internal class ToolWindowManagerAppLevelHelper {
companion object {
private fun handleFocusEvent(event: FocusEvent) {
if (event.id == FocusEvent.FOCUS_LOST) {
if (event.oppositeComponent == null || event.isTemporary) {
return
}
val project = IdeFocusManager.getGlobalInstance().lastFocusedFrame?.project ?: return
if (project.isDisposed || project.isDefault) {
return
}
val toolWindowManager = getInstance(project) as ToolWindowManagerImpl
toolWindowManager.revalidateStripeButtons()
val toolWindowId = getToolWindowIdForComponent(event.component) ?: return
val activeEntry = toolWindowManager.idToEntry.get(toolWindowId) ?: return
val windowInfo = activeEntry.readOnlyWindowInfo
// just removed
if (!windowInfo.isVisible) {
return
}
if (!(windowInfo.isAutoHide || windowInfo.type == ToolWindowType.SLIDING)) {
return
}
// let's check that tool window actually loses focus
if (getToolWindowIdForComponent(event.oppositeComponent) != toolWindowId) {
// a toolwindow lost focus
val focusGoesToPopup = JBPopupFactory.getInstance().getParentBalloonFor(event.oppositeComponent) != null
if (!focusGoesToPopup) {
val info = toolWindowManager.getRegisteredMutableInfoOrLogError(toolWindowId)
toolWindowManager.deactivateToolWindow(info, activeEntry)
}
}
}
else if (event.id == FocusEvent.FOCUS_GAINED) {
val component = event.component ?: return
processOpenedProjects { project ->
for (composite in FileEditorManagerEx.getInstanceEx(project).splitters.getAllComposites()) {
if (composite.allEditors.any { SwingUtilities.isDescendingFrom(component, it.component) }) {
(getInstance(project) as ToolWindowManagerImpl).activeStack.clear()
}
}
}
}
}
private inline fun process(processor: (manager: ToolWindowManagerImpl) -> Unit) {
processOpenedProjects { project ->
processor(getInstance(project) as ToolWindowManagerImpl)
}
}
}
private class MyListener : AWTEventListener {
override fun eventDispatched(event: AWTEvent?) {
if (event is FocusEvent) {
handleFocusEvent(event)
}
else if (event is WindowEvent && event.getID() == WindowEvent.WINDOW_LOST_FOCUS) {
process { manager ->
val frame = event.getSource() as? JFrame
if (frame === manager.frameState?.frameOrNull) {
manager.resetHoldState()
}
}
}
}
}
init {
val awtFocusListener = MyListener()
Toolkit.getDefaultToolkit().addAWTEventListener(awtFocusListener, AWTEvent.FOCUS_EVENT_MASK or AWTEvent.WINDOW_FOCUS_EVENT_MASK)
val updateHeadersAlarm = SingleAlarm(Runnable {
processOpenedProjects { project ->
(getInstance(project) as ToolWindowManagerImpl).updateToolWindowHeaders()
}
}, 50, ApplicationManager.getApplication())
val focusListener = PropertyChangeListener { updateHeadersAlarm.cancelAndRequest() }
KeyboardFocusManager.getCurrentKeyboardFocusManager().addPropertyChangeListener("focusOwner", focusListener)
Disposer.register(ApplicationManager.getApplication()) {
KeyboardFocusManager.getCurrentKeyboardFocusManager().removePropertyChangeListener("focusOwner", focusListener)
}
val connection = ApplicationManager.getApplication().messageBus.connect()
connection.subscribe(ProjectManager.TOPIC, object : ProjectManagerListener {
override fun projectClosingBeforeSave(project: Project) {
val manager = (project.serviceIfCreated<ToolWindowManager>() as ToolWindowManagerImpl?) ?: return
for (entry in manager.idToEntry.values) {
manager.saveFloatingOrWindowedState(entry, manager.layoutState.getInfo(entry.id) ?: continue)
}
}
override fun projectClosed(project: Project) {
(project.serviceIfCreated<ToolWindowManager>() as ToolWindowManagerImpl?)?.projectClosed()
}
})
connection.subscribe(KeymapManagerListener.TOPIC, object : KeymapManagerListener {
override fun activeKeymapChanged(keymap: Keymap?) {
process { manager ->
manager.idToEntry.values.forEach {
it.stripeButton?.updatePresentation()
}
}
}
})
connection.subscribe(AnActionListener.TOPIC, object : AnActionListener {
override fun beforeActionPerformed(action: AnAction, event: AnActionEvent) {
process { manager ->
if (manager.currentState != KeyState.HOLD) {
manager.resetHoldState()
}
}
if (ExperimentalUI.isNewUI()) {
if (event.place == ActionPlaces.TOOLWINDOW_TITLE) {
val toolWindowManager = getInstance(event.project!!) as ToolWindowManagerImpl
val toolWindowId = event.dataContext.getData(PlatformDataKeys.TOOL_WINDOW)?.id ?: return
toolWindowManager.activateToolWindow(toolWindowId, null, true)
}
if (event.place == ActionPlaces.TOOLWINDOW_POPUP) {
val toolWindowManager = getInstance(event.project!!) as ToolWindowManagerImpl
val activeEntry = toolWindowManager.idToEntry.get(toolWindowManager.lastActiveToolWindowId ?: return) ?: return
(activeEntry.toolWindow.decorator ?: return).headerToolbar.component.isVisible = true
}
}
}
})
IdeEventQueue.getInstance().addDispatcher(IdeEventQueue.EventDispatcher { event ->
if (event is KeyEvent) {
process { manager ->
manager.dispatchKeyEvent(event)
}
}
false
}, ApplicationManager.getApplication())
}
}
private fun getDefaultToolWindowPane() = toolWindowPanes[WINDOW_INFO_DEFAULT_TOOL_WINDOW_PANE_ID]!!
internal fun getToolWindowPane(paneId: String) = toolWindowPanes[paneId] ?: getDefaultToolWindowPane()
internal fun getToolWindowPane(toolWindow: ToolWindow): ToolWindowPane {
val paneId = if (toolWindow is ToolWindowImpl) {
toolWindow.windowInfo.safeToolWindowPaneId
}
else {
idToEntry.get(toolWindow.id)?.readOnlyWindowInfo?.safeToolWindowPaneId ?: WINDOW_INFO_DEFAULT_TOOL_WINDOW_PANE_ID
}
return getToolWindowPane(paneId)
}
@VisibleForTesting
internal open fun getButtonManager(toolWindow: ToolWindow): ToolWindowButtonManager = getToolWindowPane(toolWindow).buttonManager
internal fun addToolWindowPane(toolWindowPane: ToolWindowPane, parentDisposable: Disposable) {
toolWindowPanes.put(toolWindowPane.paneId, toolWindowPane)
Disposer.register(parentDisposable) {
for (it in idToEntry.values) {
if (it.readOnlyWindowInfo.safeToolWindowPaneId == toolWindowPane.paneId) {
hideToolWindow(id = it.id,
hideSide = false,
moveFocus = false,
removeFromStripe = true,
source = ToolWindowEventSource.CloseAction)
}
}
toolWindowPanes.remove(toolWindowPane.paneId)
}
}
internal fun getToolWindowPanes(): List<ToolWindowPane> = toolWindowPanes.values.toList()
private fun revalidateStripeButtons() {
val buttonManagers = toolWindowPanes.values.mapNotNull { it.buttonManager as? ToolWindowPaneNewButtonManager }
ApplicationManager.getApplication().invokeLater({ buttonManagers.forEach { it.refreshUi() } }, project.disposed)
}
internal fun createNotInHierarchyIterable(paneId: String): Iterable<Component> {
return Iterable {
idToEntry.values.asSequence().mapNotNull {
if (getToolWindowPane(it.toolWindow).paneId == paneId) {
val component = it.toolWindow.decoratorComponent
if (component != null && component.parent == null) component else null
}
else null
}.iterator()
}
}
private fun updateToolWindowHeaders() {
focusManager.doWhenFocusSettlesDown(ExpirableRunnable.forProject(project) {
for (entry in idToEntry.values) {
if (entry.readOnlyWindowInfo.isVisible) {
val decorator = entry.toolWindow.decorator ?: continue
decorator.repaint()
decorator.updateActiveAndHoverState()
}
}
revalidateStripeButtons()
})
}
@Suppress("DEPRECATION")
private fun dispatchKeyEvent(e: KeyEvent): Boolean {
if ((e.keyCode != KeyEvent.VK_CONTROL) && (
e.keyCode != KeyEvent.VK_ALT) && (e.keyCode != KeyEvent.VK_SHIFT) && (e.keyCode != KeyEvent.VK_META)) {
if (e.modifiers == 0) {
resetHoldState()
}
return false
}
if (e.id != KeyEvent.KEY_PRESSED && e.id != KeyEvent.KEY_RELEASED) {
return false
}
val parent = e.component?.let { ComponentUtil.findUltimateParent(it) }
if (parent is IdeFrame) {
if ((parent as IdeFrame).project !== project) {
resetHoldState()
return false
}
}
val vks = getActivateToolWindowVKsMask()
if (vks == 0) {
resetHoldState()
return false
}
val mouseMask = InputEvent.BUTTON1_DOWN_MASK or InputEvent.BUTTON2_DOWN_MASK or InputEvent.BUTTON3_DOWN_MASK
if (BitUtil.isSet(vks, keyCodeToInputMask(e.keyCode)) && (e.modifiersEx and mouseMask) == 0) {
val pressed = e.id == KeyEvent.KEY_PRESSED
val modifiers = e.modifiers
if (areAllModifiersPressed(modifiers, vks) || !pressed) {
processState(pressed)
}
else {
resetHoldState()
}
}
return false
}
private fun resetHoldState() {
currentState = KeyState.WAITING
toolWindowPanes.values.forEach { it.setStripesOverlaid(value = false) }
}
private fun processState(pressed: Boolean) {
if (pressed) {
if (currentState == KeyState.WAITING) {
currentState = KeyState.PRESSED
}
else if (currentState == KeyState.RELEASED) {
currentState = KeyState.HOLD
toolWindowPanes.values.forEach { it.setStripesOverlaid(value = true) }
}
}
else {
if (currentState == KeyState.PRESSED) {
currentState = KeyState.RELEASED
waiterForSecondPress?.cancelAndRequest()
}
else {
resetHoldState()
}
}
}
suspend fun init(frameHelper: ProjectFrameHelper, fileEditorManager: FileEditorManagerEx) {
// Make sure we haven't already created the root tool window pane. We might have created panes for secondary frames, as they get
// registered differently, but we shouldn't have the main pane yet
LOG.assertTrue(!toolWindowPanes.containsKey(WINDOW_INFO_DEFAULT_TOOL_WINDOW_PANE_ID))
doInit(frameHelper, project.messageBus.connect(this), fileEditorManager)
}
@VisibleForTesting
suspend fun doInit(frameHelper: ProjectFrameHelper, connection: MessageBusConnection, fileEditorManager: FileEditorManagerEx) {
connection.subscribe(ToolWindowManagerListener.TOPIC, dispatcher.multicaster)
withContext(Dispatchers.EDT + ModalityState.any().asContextElement()) {
frameState = frameHelper
val toolWindowPane = frameHelper.rootPane!!.toolWindowPane
toolWindowPane.setDocumentComponent(fileEditorManager.component)
// This will be the tool window pane for the default frame, which is not automatically added by the ToolWindowPane constructor. If we're
// reopening other frames, their tool window panes will be already added, but we still need to initialise the tool windows themselves.
toolWindowPanes.put(toolWindowPane.paneId, toolWindowPane)
}
toolWindowSetInitializer.initUi()
connection.subscribe(FileEditorManagerListener.FILE_EDITOR_MANAGER, object : FileEditorManagerListener {
override fun fileClosed(source: FileEditorManager, file: VirtualFile) {
ApplicationManager.getApplication().invokeLater({
focusManager.doWhenFocusSettlesDown(ExpirableRunnable.forProject(project) {
if (!FileEditorManager.getInstance(project).hasOpenFiles()) {
focusToolWindowByDefault()
}
})
}, project.disposed)
}
})
}
@Deprecated("Use {{@link #registerToolWindow(RegisterToolWindowTask)}}")
override fun initToolWindow(bean: ToolWindowEP) {
ApplicationManager.getApplication().assertIsDispatchThread()
initToolWindow(bean, bean.pluginDescriptor)
}
internal fun initToolWindow(bean: ToolWindowEP, plugin: PluginDescriptor) {
val condition = bean.getCondition(plugin)
if (condition != null && !condition.value(project)) {
return
}
val factory = bean.getToolWindowFactory(bean.pluginDescriptor)
if (!factory.isApplicable(project)) {
return
}
// Always add to the default tool window pane
val toolWindowPane = getDefaultToolWindowPaneIfInitialized()
val anchor = getToolWindowAnchor(factory, bean)
@Suppress("DEPRECATION")
val sideTool = (bean.secondary || bean.side) && !isNewUi
val entry = registerToolWindow(RegisterToolWindowTask(
id = bean.id,
icon = findIconFromBean(bean, factory, plugin),
anchor = anchor,
sideTool = sideTool,
canCloseContent = bean.canCloseContents,
canWorkInDumbMode = DumbService.isDumbAware(factory),
shouldBeAvailable = factory.shouldBeAvailable(project),
contentFactory = factory,
stripeTitle = getStripeTitleSupplier(bean.id, plugin)
), toolWindowPane.buttonManager)
project.messageBus.syncPublisher(ToolWindowManagerListener.TOPIC).toolWindowsRegistered(listOf(entry.id), this)
toolWindowPane.buttonManager.getStripeFor(anchor, sideTool).revalidate()
toolWindowPane.validate()
toolWindowPane.repaint()
}
private fun getDefaultToolWindowPaneIfInitialized(): ToolWindowPane {
return toolWindowPanes.get(WINDOW_INFO_DEFAULT_TOOL_WINDOW_PANE_ID)
?: throw IllegalStateException("You must not register toolwindow programmatically so early. " +
"Rework code or use ToolWindowManager.invokeLater")
}
fun projectClosed() {
(frameState ?: return).releaseFrame()
toolWindowPanes.values.forEach { it.putClientProperty(UIUtil.NOT_IN_HIERARCHY_COMPONENTS, null) }
// hide all tool windows - frame maybe reused for another project
for (entry in idToEntry.values) {
try {
removeDecoratorWithoutUpdatingState(entry, layoutState.getInfo(entry.id) ?: continue, dirtyMode = true)
}
catch (e: CancellationException) {
throw e
}
catch (e: ProcessCanceledException) {
throw e
}
catch (e: Throwable) {
LOG.error(e)
}
finally {
Disposer.dispose(entry.disposable)
}
}
toolWindowPanes.values.forEach(ToolWindowPane::reset)
frameState = null
}
private fun loadDefault() {
toolWindowSetInitializer.scheduleSetLayout(ToolWindowDefaultLayoutManager.getInstance().getLayoutCopy())
}
@Deprecated("Use {@link ToolWindowManagerListener#TOPIC}", level = DeprecationLevel.ERROR)
override fun addToolWindowManagerListener(listener: ToolWindowManagerListener) {
dispatcher.addListener(listener)
}
@Deprecated("Use {@link ToolWindowManagerListener#TOPIC}", level = DeprecationLevel.ERROR,
replaceWith = ReplaceWith("project.messageBus.connect(parentDisposable).subscribe(ToolWindowManagerListener.TOPIC, listener)",
"com.intellij.openapi.wm.ex.ToolWindowManagerListener"))
override fun addToolWindowManagerListener(listener: ToolWindowManagerListener, parentDisposable: Disposable) {
project.messageBus.connect(parentDisposable).subscribe(ToolWindowManagerListener.TOPIC, listener)
}
@Deprecated("Use {@link ToolWindowManagerListener#TOPIC}", level = DeprecationLevel.ERROR)
override fun removeToolWindowManagerListener(listener: ToolWindowManagerListener) {
dispatcher.removeListener(listener)
}
override fun activateEditorComponent() {
EditorsSplitters.focusDefaultComponentInSplittersIfPresent(project)
}
open fun activateToolWindow(id: String, runnable: Runnable?, autoFocusContents: Boolean, source: ToolWindowEventSource? = null) {
ApplicationManager.getApplication().assertIsDispatchThread()
val activity = UiActivity.Focus("toolWindow:$id")
UiActivityMonitor.getInstance().addActivity(project, activity, ModalityState.NON_MODAL)
activateToolWindow(idToEntry.get(id)!!, getRegisteredMutableInfoOrLogError(id), autoFocusContents, source)
ApplicationManager.getApplication().invokeLater(Runnable {
runnable?.run()
UiActivityMonitor.getInstance().removeActivity(project, activity)
}, project.disposed)
}
internal fun activateToolWindow(entry: ToolWindowEntry,
info: WindowInfoImpl,
autoFocusContents: Boolean = true,
source: ToolWindowEventSource? = null) {
LOG.debug { "activateToolWindow($entry)" }
if (source != null) {
ToolWindowCollector.getInstance().recordActivation(project, entry.id, info, source)
}
recentToolWindowsState.remove(entry.id)
recentToolWindowsState.add(0, entry.id)
if (!entry.toolWindow.isAvailable) {
// Tool window can be "logically" active but not focused.
// For example, when the user switched to another application. So we just need to bring tool window's window to front.
if (autoFocusContents && !entry.toolWindow.hasFocus) {
entry.toolWindow.requestFocusInToolWindow()
}
return
}
if (!entry.readOnlyWindowInfo.isVisible) {
showToolWindowImpl(entry, info, dirtyMode = false, source = source)
}
if (autoFocusContents && ApplicationManager.getApplication().isActive) {
entry.toolWindow.requestFocusInToolWindow()
}
else {
activeStack.push(entry)
}
fireStateChanged(ToolWindowManagerEventType.ActivateToolWindow)
}
fun getRecentToolWindows(): List<String> = java.util.List.copyOf(recentToolWindowsState)
internal fun updateToolWindow(toolWindow: ToolWindowImpl, component: Component) {
toolWindow.setFocusedComponent(component)
if (toolWindow.isAvailable && !toolWindow.isActive) {
activateToolWindow(toolWindow.id, null, autoFocusContents = true)
}
activeStack.push(idToEntry.get(toolWindow.id) ?: return)
toolWindow.decorator?.headerToolbar?.component?.isVisible = true
}
// mutate operation must use info from layout and not from decorator
internal fun getRegisteredMutableInfoOrLogError(id: String): WindowInfoImpl {
var info = layoutState.getInfo(id)
if (info == null) {
val entry = idToEntry.get(id) ?: throw IllegalStateException("window with id=\"$id\" isn't registered")
// window was registered but stripe button was not shown, so, layout was not added to a list
info = (entry.readOnlyWindowInfo as WindowInfoImpl).copy()
layoutState.addInfo(id, info)
}
return info
}
private fun deactivateToolWindow(info: WindowInfoImpl,
entry: ToolWindowEntry,
dirtyMode: Boolean = false,
mutation: Mutation? = null,
source: ToolWindowEventSource? = null) {
LOG.debug { "deactivateToolWindow(${info.id})" }
setHiddenState(info, entry, source)
mutation?.invoke(info)
updateStateAndRemoveDecorator(info, entry, dirtyMode = dirtyMode)
entry.applyWindowInfo(info.copy())
}
private fun setHiddenState(info: WindowInfoImpl, entry: ToolWindowEntry, source: ToolWindowEventSource?) {
ToolWindowCollector.getInstance().recordHidden(project, info, source)
info.isActiveOnStart = false
info.isVisible = false
activeStack.remove(entry, false)
}
override val toolWindowIds: Array<String>
get() = idToEntry.keys.toTypedArray()
override val toolWindows: List<ToolWindow>
get() = idToEntry.values.map { it.toolWindow }
override val toolWindowIdSet: Set<String>
get() = java.util.Set.copyOf(idToEntry.keys)
override val activeToolWindowId: String?
get() {
EDT.assertIsEdt()
val frame = toolWindowPanes.values.firstOrNull { it.frame.isActive }?.frame ?: frameState?.frameOrNull ?: return null
if (frame.isActive) {
return getToolWindowIdForComponent(frame.mostRecentFocusOwner)
}
else {
// let's check floating and windowed
for (entry in idToEntry.values) {
if (entry.floatingDecorator?.isActive == true || entry.windowedDecorator?.isActive == true) {
return entry.id
}
}
}
return null
}
override val lastActiveToolWindowId: String?
get() = getLastActiveToolWindows().firstOrNull()?.id
internal fun getLastActiveToolWindows(): Sequence<ToolWindow> {
EDT.assertIsEdt()
return (0 until activeStack.persistentSize).asSequence()
.map { activeStack.peekPersistent(it).toolWindow }
.filter { it.isAvailable }
}
/**
* @return windowed decorator for the tool window with specified `ID`.
*/
private fun getWindowedDecorator(id: String) = idToEntry.get(id)?.windowedDecorator
override fun getIdsOn(anchor: ToolWindowAnchor) = getVisibleToolWindowsOn(WINDOW_INFO_DEFAULT_TOOL_WINDOW_PANE_ID, anchor).map { it.id }.toList()
internal fun getToolWindowsOn(paneId: String, anchor: ToolWindowAnchor, excludedId: String): MutableList<ToolWindowEx> {
return getVisibleToolWindowsOn(paneId, anchor)
.filter { it.id != excludedId }
.map { it.toolWindow }
.toMutableList()
}
internal fun getDockedInfoAt(paneId: String, anchor: ToolWindowAnchor?, side: Boolean): WindowInfo? {
return idToEntry.values.asSequence()
.map { it.readOnlyWindowInfo }
.find { it.isVisible && it.isDocked && it.safeToolWindowPaneId == paneId && it.anchor == anchor && it.isSplit == side }
}
override fun getLocationIcon(id: String, fallbackIcon: Icon): Icon {
val info = layoutState.getInfo(id) ?: return fallbackIcon
val type = info.type
if (type == ToolWindowType.FLOATING || type == ToolWindowType.WINDOWED) {
return AllIcons.Actions.MoveToWindow
}
val anchor = info.anchor
val splitMode = info.isSplit
return when (anchor) {
ToolWindowAnchor.BOTTOM -> if (splitMode) AllIcons.Actions.MoveToBottomRight else AllIcons.Actions.MoveToBottomLeft
ToolWindowAnchor.LEFT -> if (splitMode) AllIcons.Actions.MoveToLeftBottom else AllIcons.Actions.MoveToLeftTop
ToolWindowAnchor.RIGHT -> if (splitMode) AllIcons.Actions.MoveToRightBottom else AllIcons.Actions.MoveToRightTop
ToolWindowAnchor.TOP -> if (splitMode) AllIcons.Actions.MoveToTopRight else AllIcons.Actions.MoveToTopLeft
else -> fallbackIcon
}
}
private fun getVisibleToolWindowsOn(paneId: String, anchor: ToolWindowAnchor): Sequence<ToolWindowEntry> {
return idToEntry.values
.asSequence()
.filter { it.toolWindow.isAvailable && it.readOnlyWindowInfo.safeToolWindowPaneId == paneId && it.readOnlyWindowInfo.anchor == anchor }
}
// cannot be ToolWindowEx because of backward compatibility
override fun getToolWindow(id: String?): ToolWindow? {
return idToEntry.get(id ?: return null)?.toolWindow
}
open fun showToolWindow(id: String) {
LOG.debug { "showToolWindow($id)" }
EDT.assertIsEdt()
val entry = idToEntry.get(id) ?: throw IllegalThreadStateException("window with id=\"$id\" is not registered")
if (entry.readOnlyWindowInfo.isVisible) {
LOG.assertTrue(entry.toolWindow.getComponentIfInitialized() != null)
return
}
val info = getRegisteredMutableInfoOrLogError(id)
if (showToolWindowImpl(entry, info, dirtyMode = false)) {
checkInvariants(id)
fireStateChanged(ToolWindowManagerEventType.ShowToolWindow)
}
}
override fun hideToolWindow(id: String, hideSide: Boolean) {
hideToolWindow(id = id, hideSide = hideSide, source = null)
}
open fun hideToolWindow(id: String,
hideSide: Boolean = false,
moveFocus: Boolean = true,
removeFromStripe: Boolean = false,
source: ToolWindowEventSource? = null) {
EDT.assertIsEdt()
val entry = idToEntry.get(id)!!
var moveFocusAfter = moveFocus && entry.toolWindow.isActive
if (!entry.readOnlyWindowInfo.isVisible) {
moveFocusAfter = false
}
val info = getRegisteredMutableInfoOrLogError(id)
val mutation: Mutation? = if (removeFromStripe) {
{
info.isShowStripeButton = false
entry.removeStripeButton()
}
}
else {
null
}
executeHide(entry, info, dirtyMode = false, hideSide = hideSide, mutation = mutation, source = source)
if (removeFromStripe) {
// If we're removing the stripe, reset to the root pane ID. Note that the current value is used during hide
info.toolWindowPaneId = WINDOW_INFO_DEFAULT_TOOL_WINDOW_PANE_ID
}
fireStateChanged(ToolWindowManagerEventType.HideToolWindow)
if (moveFocusAfter) {
activateEditorComponent()
}
revalidateStripeButtons()
}
private fun executeHide(entry: ToolWindowEntry,
info: WindowInfoImpl,
dirtyMode: Boolean,
hideSide: Boolean = false,
mutation: Mutation? = null,
source: ToolWindowEventSource? = null) {
// hide and deactivate
deactivateToolWindow(info, entry, dirtyMode = dirtyMode, mutation = mutation, source = source)
if (hideSide && info.type != ToolWindowType.FLOATING && info.type != ToolWindowType.WINDOWED) {
for (each in getVisibleToolWindowsOn(info.safeToolWindowPaneId, info.anchor)) {
activeStack.remove(each, false)
}
if (isStackEnabled) {
while (!sideStack.isEmpty(info.anchor)) {
sideStack.pop(info.anchor)
}
}
for (otherEntry in idToEntry.values) {
val otherInfo = layoutState.getInfo(otherEntry.id) ?: continue
if (otherInfo.isVisible && otherInfo.safeToolWindowPaneId == info.safeToolWindowPaneId && otherInfo.anchor == info.anchor) {
deactivateToolWindow(otherInfo, otherEntry, dirtyMode = dirtyMode, source = ToolWindowEventSource.HideSide)
}
}
}
else {
// first we have to find tool window that was located at the same side and was hidden
if (isStackEnabled) {
var info2: WindowInfoImpl? = null
while (!sideStack.isEmpty(info.anchor)) {
val storedInfo = sideStack.pop(info.anchor)
if (storedInfo.isSplit != info.isSplit) {
continue
}
val currentInfo = getRegisteredMutableInfoOrLogError(storedInfo.id!!)
// SideStack contains copies of real WindowInfos. It means that
// these stored infos can be invalid. The following loop removes invalid WindowInfos.
if (storedInfo.safeToolWindowPaneId == currentInfo.safeToolWindowPaneId && storedInfo.anchor == currentInfo.anchor
&& storedInfo.type == currentInfo.type && storedInfo.isAutoHide == currentInfo.isAutoHide) {
info2 = storedInfo
break
}
}
if (info2 != null) {
val entry2 = idToEntry[info2.id!!]!!
if (!entry2.readOnlyWindowInfo.isVisible) {
showToolWindowImpl(entry2, info2, dirtyMode = dirtyMode)
}
}
}
activeStack.remove(entry, false)
}
}
/**
* @param dirtyMode if `true` then all UI operations are performed in dirty mode.
*/
private fun showToolWindowImpl(entry: ToolWindowEntry,
toBeShownInfo: WindowInfoImpl,
dirtyMode: Boolean,
source: ToolWindowEventSource? = null): Boolean {
if (!entry.toolWindow.isAvailable) {
return false
}
ToolWindowCollector.getInstance().recordShown(project, source, toBeShownInfo)
toBeShownInfo.isVisible = true
toBeShownInfo.isShowStripeButton = true
val snapshotInfo = toBeShownInfo.copy()
entry.applyWindowInfo(snapshotInfo)
doShowWindow(entry, snapshotInfo, dirtyMode)
if (entry.readOnlyWindowInfo.type == ToolWindowType.WINDOWED && entry.toolWindow.getComponentIfInitialized() != null) {
UIUtil.toFront(ComponentUtil.getWindow(entry.toolWindow.component))
}
return true
}
private fun doShowWindow(entry: ToolWindowEntry, info: WindowInfo, dirtyMode: Boolean) {
if (entry.readOnlyWindowInfo.type == ToolWindowType.FLOATING) {
addFloatingDecorator(entry, info)
}
else if (entry.readOnlyWindowInfo.type == ToolWindowType.WINDOWED) {
addWindowedDecorator(entry, info)
}
else {
// docked and sliding windows
// If there is tool window on the same side then we have to hide it, i.e.
// clear place for tool window to be shown.
//
// We store WindowInfo of hidden tool window in the SideStack (if the tool window
// is docked and not auto-hide one). Therefore, it's possible to restore the
// hidden tool window when showing tool window will be closed.
for (otherEntry in idToEntry.values) {
if (entry.id == otherEntry.id) {
continue
}
val otherInfo = otherEntry.readOnlyWindowInfo
if (otherInfo.isVisible && otherInfo.type == info.type && otherInfo.isSplit == info.isSplit
&& otherInfo.safeToolWindowPaneId == info.safeToolWindowPaneId && otherInfo.anchor == info.anchor) {
val otherLayoutInto = layoutState.getInfo(otherEntry.id)!!
// hide and deactivate tool window
setHiddenState(otherLayoutInto, otherEntry, ToolWindowEventSource.HideOnShowOther)
val otherInfoCopy = otherLayoutInto.copy()
otherEntry.applyWindowInfo(otherInfoCopy)
otherEntry.toolWindow.decoratorComponent?.let { decorator ->
val toolWindowPane = getToolWindowPane(otherInfoCopy.safeToolWindowPaneId)
toolWindowPane.removeDecorator(otherInfoCopy, decorator, false, this)
}
// store WindowInfo into the SideStack
if (isStackEnabled && otherInfo.isDocked && !otherInfo.isAutoHide) {
sideStack.push(otherInfoCopy)
}
}
}
// This check is for testability. The tests don't create UI, so there are no actual panes
if (toolWindowPanes.containsKey(WINDOW_INFO_DEFAULT_TOOL_WINDOW_PANE_ID)) {
val toolWindowPane = getToolWindowPane(info.safeToolWindowPaneId)
toolWindowPane.addDecorator(entry.toolWindow.getOrCreateDecoratorComponent(), info, dirtyMode, this)
}
// remove tool window from the SideStack
if (isStackEnabled) {
sideStack.remove(entry.id)
}
}
if (entry.stripeButton == null) {
val buttonManager = getButtonManager(entry.toolWindow)
entry.stripeButton = buttonManager.createStripeButton(entry.toolWindow, info, task = null)
}
entry.toolWindow.scheduleContentInitializationIfNeeded()
fireToolWindowShown(entry.toolWindow)
}
override fun registerToolWindow(task: RegisterToolWindowTask): ToolWindow {
ApplicationManager.getApplication().assertIsDispatchThread()
// Try to get a previously saved tool window pane, if possible
val toolWindowPane = this.getLayout().getInfo(task.id)?.toolWindowPaneId?.let { getToolWindowPane(it) }
?: getDefaultToolWindowPaneIfInitialized()
val entry = registerToolWindow(task, buttonManager = toolWindowPane.buttonManager)
project.messageBus.syncPublisher(ToolWindowManagerListener.TOPIC).toolWindowsRegistered(listOf(entry.id), this)
toolWindowPane.buttonManager.getStripeFor(entry.toolWindow.anchor, entry.toolWindow.isSplitMode).revalidate()
toolWindowPane.validate()
toolWindowPane.repaint()
fireStateChanged(ToolWindowManagerEventType.RegisterToolWindow)
return entry.toolWindow
}
internal fun registerToolWindow(task: RegisterToolWindowTask, buttonManager: ToolWindowButtonManager): ToolWindowEntry {
LOG.debug { "registerToolWindow($task)" }
if (idToEntry.containsKey(task.id)) {
throw IllegalArgumentException("window with id=\"${task.id}\" is already registered")
}
var info = layoutState.getInfo(task.id)
val isButtonNeeded = task.shouldBeAvailable && (info?.isShowStripeButton ?: !isNewUi)
// do not create layout for New UI - button is not created for toolwindow by default
if (info == null) {
info = layoutState.create(task, isNewUi = isNewUi)
if (isButtonNeeded) {
// we must allocate order - otherwise, on drag-n-drop, we cannot move some tool windows to the end
// because sibling's order is equal to -1, so, always in the end
info.order = layoutState.getMaxOrder(info.safeToolWindowPaneId, task.anchor)
layoutState.addInfo(task.id, info)
}
}
val disposable = Disposer.newDisposable(task.id)
Disposer.register(project, disposable)
val factory = task.contentFactory
val infoSnapshot = info.copy()
if (infoSnapshot.isVisible && (factory == null || !task.shouldBeAvailable)) {
// isVisible cannot be true if contentFactory is null, because we cannot show toolwindow without content
infoSnapshot.isVisible = false
}
val stripeTitle = task.stripeTitle?.get() ?: task.id
val toolWindow = ToolWindowImpl(toolWindowManager = this,
id = task.id,
canCloseContent = task.canCloseContent,
dumbAware = task.canWorkInDumbMode,
component = task.component,
parentDisposable = disposable,
windowInfo = infoSnapshot,
contentFactory = factory,
isAvailable = task.shouldBeAvailable,
stripeTitle = stripeTitle)
if (task.hideOnEmptyContent) {
toolWindow.setToHideOnEmptyContent(true)
}
toolWindow.windowInfoDuringInit = infoSnapshot
try {
factory?.init(toolWindow)
}
catch (e: IllegalStateException) {
LOG.error(PluginException(e, task.pluginDescriptor?.pluginId))
}
finally {
toolWindow.windowInfoDuringInit = null
}
// contentFactory.init can set icon
if (toolWindow.icon == null) {
task.icon?.let {
toolWindow.doSetIcon(it)
}
}
ActivateToolWindowAction.ensureToolWindowActionRegistered(toolWindow, ActionManager.getInstance())
val stripeButton = if (isButtonNeeded) {
buttonManager.createStripeButton(toolWindow, infoSnapshot, task)
}
else {
LOG.debug {
"Button is not created for `${task.id}`" +
"(isShowStripeButton: ${info.isShowStripeButton}, isAvailable: ${task.shouldBeAvailable})"
}
null
}
val entry = ToolWindowEntry(stripeButton, toolWindow, disposable)
idToEntry.put(task.id, entry)
// If preloaded info is visible or active then we have to show/activate the installed
// tool window. This step has sense only for windows which are not in the auto hide
// mode. But if tool window was active but its mode doesn't allow to activate it again
// (for example, tool window is in auto hide mode) then we just activate editor component.
if (stripeButton != null && factory != null /* not null on init tool window from EP */ && infoSnapshot.isVisible) {
showToolWindowImpl(entry, info, dirtyMode = false)
// do not activate tool window that is the part of project frame - default component should be focused
if (infoSnapshot.isActiveOnStart &&
(infoSnapshot.type == ToolWindowType.WINDOWED || infoSnapshot.type == ToolWindowType.FLOATING) &&
ApplicationManager.getApplication().isActive) {
entry.toolWindow.requestFocusInToolWindow()
}
}
return entry
}
@Deprecated("Use ToolWindowFactory and toolWindow extension point")
@Suppress("OverridingDeprecatedMember")
override fun unregisterToolWindow(id: String) {
doUnregisterToolWindow(id)
fireStateChanged(ToolWindowManagerEventType.UnregisterToolWindow)
}
internal fun doUnregisterToolWindow(id: String) {
LOG.debug { "unregisterToolWindow($id)" }
ApplicationManager.getApplication().assertIsDispatchThread()
ActivateToolWindowAction.unregister(id)
val entry = idToEntry.remove(id) ?: return
val toolWindow = entry.toolWindow
val info = layoutState.getInfo(id)
if (info != null) {
// remove decorator and tool button from the screen - removing will also save current bounds
updateStateAndRemoveDecorator(info, entry, false)
// save recent appearance of tool window
activeStack.remove(entry, true)
if (isStackEnabled) {
sideStack.remove(id)
}
entry.removeStripeButton()
val toolWindowPane = getToolWindowPane(info.safeToolWindowPaneId)
toolWindowPane.validate()
toolWindowPane.repaint()
}
if (!project.isDisposed) {
project.messageBus.syncPublisher(ToolWindowManagerListener.TOPIC).toolWindowUnregistered(id, (toolWindow))
}
Disposer.dispose(entry.disposable)
}
private fun updateStateAndRemoveDecorator(state: WindowInfoImpl, entry: ToolWindowEntry, dirtyMode: Boolean) {
saveFloatingOrWindowedState(entry, state)
removeDecoratorWithoutUpdatingState(entry, state, dirtyMode)
}
private fun removeDecoratorWithoutUpdatingState(entry: ToolWindowEntry, state: WindowInfoImpl, dirtyMode: Boolean) {
entry.windowedDecorator?.let {
entry.windowedDecorator = null
Disposer.dispose(it)
return
}
entry.floatingDecorator?.let {
entry.floatingDecorator = null
it.dispose()
return
}
entry.toolWindow.decoratorComponent?.let {
val toolWindowPane = getToolWindowPane(state.safeToolWindowPaneId)
toolWindowPane.removeDecorator(state, it, dirtyMode, this)
return
}
}
private fun saveFloatingOrWindowedState(entry: ToolWindowEntry, info: WindowInfoImpl) {
entry.floatingDecorator?.let {
info.floatingBounds = it.bounds
info.isActiveOnStart = it.isActive
return
}
entry.windowedDecorator?.let { windowedDecorator ->
info.isActiveOnStart = windowedDecorator.isActive
val frame = windowedDecorator.getFrame()
if (frame.isShowing) {
val maximized = (frame as JFrame).extendedState == Frame.MAXIMIZED_BOTH
if (maximized) {
frame.extendedState = Frame.NORMAL
frame.invalidate()
frame.revalidate()
}
val bounds = getRootBounds(frame)
info.floatingBounds = bounds
info.isMaximized = maximized
}
return
}
}
override fun getLayout(): DesktopLayout {
ApplicationManager.getApplication().assertIsDispatchThread()
return layoutState
}
@VisibleForTesting
fun setLayoutOnInit(newLayout: DesktopLayout) {
if (!idToEntry.isEmpty()) {
LOG.error("idToEntry must be empty (idToEntry={\n${idToEntry.entries.joinToString(separator = "\n") { (k, v) -> "$k: $v" }})")
}
layoutState = newLayout
}
override fun setLayout(newLayout: DesktopLayout) {
ApplicationManager.getApplication().assertIsDispatchThread()
if (idToEntry.isEmpty()) {
layoutState = newLayout
return
}
data class LayoutData(val old: WindowInfoImpl, val new: WindowInfoImpl, val entry: ToolWindowEntry)
val list = mutableListOf<LayoutData>()
for (entry in idToEntry.values) {
val old = layoutState.getInfo(entry.id) ?: entry.readOnlyWindowInfo as WindowInfoImpl
val new = newLayout.getInfo(entry.id)
// just copy if defined in the old layout but not in the new
if (new == null) {
newLayout.addInfo(entry.id, old.copy())
}
else if (old != new) {
list.add(LayoutData(old = old, new = new, entry = entry))
}
}
this.layoutState = newLayout
if (list.isEmpty()) {
return
}
for (item in list) {
item.entry.applyWindowInfo(item.new)
if (item.old.isVisible && !item.new.isVisible) {
updateStateAndRemoveDecorator(item.new, item.entry, dirtyMode = true)
}
if (item.old.safeToolWindowPaneId != item.new.safeToolWindowPaneId
|| item.old.anchor != item.new.anchor
|| item.old.order != item.new.order) {
setToolWindowAnchorImpl(item.entry, item.old, item.new, item.new.safeToolWindowPaneId, item.new.anchor, item.new.order)
}
var toShowWindow = false
if (item.old.isSplit != item.new.isSplit) {
val wasVisible = item.old.isVisible
// we should hide the window and show it in a 'new place' to automatically hide possible window that is already located in a 'new place'
if (wasVisible) {
hideToolWindow(item.entry.id)
}
if (wasVisible) {
toShowWindow = true
}
}
if (item.old.type != item.new.type) {
val dirtyMode = item.old.type == ToolWindowType.DOCKED || item.old.type == ToolWindowType.SLIDING
updateStateAndRemoveDecorator(item.old, item.entry, dirtyMode)
if (item.new.isVisible) {
toShowWindow = true
}
}
else if (!item.old.isVisible && item.new.isVisible) {
toShowWindow = true
}
if (toShowWindow) {
doShowWindow(item.entry, item.new, dirtyMode = true)
}
}
val rootPanes = HashSet<JRootPane>()
list.forEach { layoutData ->
getToolWindowPane(layoutData.entry.toolWindow).let { toolWindowPane ->
toolWindowPane.buttonManager.revalidateNotEmptyStripes()
toolWindowPane.validate()
toolWindowPane.repaint()
toolWindowPane.frame.rootPane?.let { rootPanes.add(it) }
}
}
activateEditorComponent()
rootPanes.forEach {
it.revalidate()
it.repaint()
}
fireStateChanged(ToolWindowManagerEventType.SetLayout)
checkInvariants(null)
}
override fun invokeLater(runnable: Runnable) {
if (!toolWindowSetInitializer.addToPendingTasksIfNotInitialized(runnable)) {
ApplicationManager.getApplication().invokeLater(runnable, ModalityState.NON_MODAL, project.disposed)
}
}
override val focusManager: IdeFocusManager
get() = IdeFocusManager.getInstance(project)!!
override fun canShowNotification(toolWindowId: String): Boolean {
val readOnlyWindowInfo = idToEntry.get(toolWindowId)?.readOnlyWindowInfo
val anchor = readOnlyWindowInfo?.anchor ?: return false
val isSplit = readOnlyWindowInfo.isSplit
return toolWindowPanes.values.firstNotNullOfOrNull { it.buttonManager.getStripeFor(anchor, isSplit).getButtonFor(toolWindowId) } != null
}
override fun notifyByBalloon(options: ToolWindowBalloonShowOptions) {
if (isNewUi) {
notifySquareButtonByBalloon(options)
return
}
val entry = idToEntry.get(options.toolWindowId)!!
entry.balloon?.let {
Disposer.dispose(it)
}
val toolWindowPane = getToolWindowPane(entry.toolWindow)
val stripe = toolWindowPane.buttonManager.getStripeFor(entry.readOnlyWindowInfo.anchor, entry.readOnlyWindowInfo.isSplit)
if (!entry.toolWindow.isAvailable) {
entry.toolWindow.isPlaceholderMode = true
stripe.updatePresentation()
stripe.revalidate()
stripe.repaint()
}
val anchor = entry.readOnlyWindowInfo.anchor
val position = Ref(Balloon.Position.below)
when(anchor) {
ToolWindowAnchor.TOP -> position.set(Balloon.Position.below)
ToolWindowAnchor.BOTTOM -> position.set(Balloon.Position.above)
ToolWindowAnchor.LEFT -> position.set(Balloon.Position.atRight)
ToolWindowAnchor.RIGHT -> position.set(Balloon.Position.atLeft)
}
if (!entry.readOnlyWindowInfo.isVisible) {
toolWindowAvailable(entry.toolWindow)
}
val balloon = createBalloon(options, entry)
val button = stripe.getButtonFor(options.toolWindowId)?.getComponent()
LOG.assertTrue(button != null, "Button was not found, popup won't be shown. $options")
if (button == null) {
return
}
val show = Runnable {
val tracker: PositionTracker<Balloon>
if (entry.toolWindow.isVisible &&
(entry.toolWindow.type == ToolWindowType.WINDOWED ||
entry.toolWindow.type == ToolWindowType.FLOATING)) {
tracker = createPositionTracker(entry.toolWindow.component, ToolWindowAnchor.BOTTOM)
}
else if (!button.isShowing) {
tracker = createPositionTracker(toolWindowPane, anchor)
}
else {
tracker = object : PositionTracker<Balloon>(button) {
override fun recalculateLocation(b: Balloon): RelativePoint? {
val otherEntry = idToEntry.get(options.toolWindowId) ?: return null
val stripeButton = otherEntry.stripeButton
if (stripeButton == null || otherEntry.readOnlyWindowInfo.anchor != anchor) {
b.hide()
return null
}
val component = stripeButton.getComponent()
return RelativePoint(component, Point(component.bounds.width / 2, component.height / 2 - 2))
}
}
}
if (!balloon.isDisposed) {
balloon.show(tracker, position.get())
}
}
if (button.isValid) {
show.run()
}
else {
SwingUtilities.invokeLater(show)
}
}
private fun notifySquareButtonByBalloon(options: ToolWindowBalloonShowOptions) {
val entry = idToEntry.get(options.toolWindowId)!!
val existing = entry.balloon
if (existing != null) {
Disposer.dispose(existing)
}
val anchor = entry.readOnlyWindowInfo.anchor
val position = Ref(Balloon.Position.atLeft)
when (anchor) {
ToolWindowAnchor.TOP -> position.set(Balloon.Position.atRight)
ToolWindowAnchor.RIGHT -> position.set(Balloon.Position.atRight)
ToolWindowAnchor.BOTTOM -> position.set(Balloon.Position.atLeft)
ToolWindowAnchor.LEFT -> position.set(Balloon.Position.atLeft)
}
val balloon = createBalloon(options, entry)
val toolWindowPane = getToolWindowPane(entry.readOnlyWindowInfo.safeToolWindowPaneId)
val buttonManager = toolWindowPane.buttonManager as ToolWindowPaneNewButtonManager
var button = buttonManager.getSquareStripeFor(entry.readOnlyWindowInfo.anchor).getButtonFor(options.toolWindowId)?.getComponent()
if (button == null || !button.isShowing) {
button = (buttonManager.getSquareStripeFor(ToolWindowAnchor.LEFT) as? ToolWindowLeftToolbar)?.moreButton!!
position.set(Balloon.Position.atLeft)
}
val show = Runnable {
val tracker: PositionTracker<Balloon>
if (entry.toolWindow.isVisible &&
(entry.toolWindow.type == ToolWindowType.WINDOWED ||
entry.toolWindow.type == ToolWindowType.FLOATING)) {
tracker = createPositionTracker(entry.toolWindow.component, ToolWindowAnchor.BOTTOM)
}
else {
tracker = object : PositionTracker<Balloon>(button) {
override fun recalculateLocation(balloon: Balloon): RelativePoint? {
val otherEntry = idToEntry.get(options.toolWindowId) ?: return null
if (otherEntry.readOnlyWindowInfo.anchor != anchor) {
balloon.hide()
return null
}
return RelativePoint(button,
Point(if (position.get() == Balloon.Position.atRight) 0 else button.bounds.width, button.height / 2))
}
}
}
if (!balloon.isDisposed) {
balloon.show(tracker, position.get())
}
}
if (button.isValid) {
show.run()
}
else {
SwingUtilities.invokeLater(show)
}
}
private fun createPositionTracker(component: Component, anchor: ToolWindowAnchor): PositionTracker<Balloon> {
return object : PositionTracker<Balloon>(component) {
override fun recalculateLocation(balloon: Balloon): RelativePoint {
val bounds = component.bounds
val target = StartupUiUtil.getCenterPoint(bounds, Dimension(1, 1))
when(anchor) {
ToolWindowAnchor.TOP -> target.y = 0
ToolWindowAnchor.BOTTOM -> target.y = bounds.height - 3
ToolWindowAnchor.LEFT -> target.x = 0
ToolWindowAnchor.RIGHT -> target.x = bounds.width
}
return RelativePoint(component, target)
}
}
}
private fun createBalloon(options: ToolWindowBalloonShowOptions, entry: ToolWindowEntry): Balloon {
val listenerWrapper = BalloonHyperlinkListener(options.listener)
val content = options.htmlBody.replace("\n", "<br>")
val balloonBuilder = JBPopupFactory.getInstance()
.createHtmlTextBalloonBuilder(content, options.icon, options.type.titleForeground, options.type.popupBackground, listenerWrapper)
.setBorderColor(options.type.borderColor)
.setHideOnClickOutside(false)
.setHideOnFrameResize(false)
options.balloonCustomizer?.accept(balloonBuilder)
val balloon = balloonBuilder.createBalloon()
if (balloon is BalloonImpl) {
NotificationsManagerImpl.frameActivateBalloonListener(balloon, Runnable {
EdtExecutorService.getScheduledExecutorInstance().schedule({ balloon.setHideOnClickOutside(true) }, 100, TimeUnit.MILLISECONDS)
})
}
listenerWrapper.balloon = balloon
entry.balloon = balloon
Disposer.register(balloon, Disposable {
entry.toolWindow.isPlaceholderMode = false
entry.balloon = null
})
Disposer.register(entry.disposable, balloon)
return balloon
}
override fun getToolWindowBalloon(id: String) = idToEntry[id]?.balloon
override val isEditorComponentActive: Boolean get() = state.isEditorComponentActive
fun setToolWindowAnchor(id: String, anchor: ToolWindowAnchor) {
ApplicationManager.getApplication().assertIsDispatchThread()
setToolWindowAnchor(id, anchor, -1)
}
// used by Rider
@Suppress("MemberVisibilityCanBePrivate")
fun setToolWindowAnchor(id: String, anchor: ToolWindowAnchor, order: Int) {
val entry = idToEntry.get(id)!!
val info = entry.readOnlyWindowInfo
if (anchor == info.anchor && (order == info.order || order == -1)) {
return
}
ApplicationManager.getApplication().assertIsDispatchThread()
setToolWindowAnchorImpl(entry, info, getRegisteredMutableInfoOrLogError(id), info.safeToolWindowPaneId, anchor, order)
getToolWindowPane(info.safeToolWindowPaneId).validateAndRepaint()
fireStateChanged(ToolWindowManagerEventType.SetToolWindowAnchor)
}
fun setVisibleOnLargeStripe(id: String, visible: Boolean) {
val info = getRegisteredMutableInfoOrLogError(id)
info.isShowStripeButton = visible
idToEntry.get(info.id)!!.applyWindowInfo(info.copy())
fireStateChanged(ToolWindowManagerEventType.SetVisibleOnLargeStripe)
}
private fun setToolWindowAnchorImpl(entry: ToolWindowEntry,
currentInfo: WindowInfo,
layoutInfo: WindowInfoImpl,
paneId: String,
anchor: ToolWindowAnchor,
order: Int) {
// Get the current tool window pane, not the one we're aiming for
val toolWindowPane = getToolWindowPane(currentInfo.safeToolWindowPaneId)
// if tool window isn't visible or only order number is changed then just remove/add stripe button
if (!currentInfo.isVisible || (paneId == currentInfo.safeToolWindowPaneId && anchor == currentInfo.anchor) ||
currentInfo.type == ToolWindowType.FLOATING || currentInfo.type == ToolWindowType.WINDOWED) {
doSetAnchor(entry, layoutInfo, paneId, anchor, order)
}
else {
val wasFocused = entry.toolWindow.isActive
// for docked and sliding windows we have to move buttons and window's decorators
layoutInfo.isVisible = false
toolWindowPane.removeDecorator(currentInfo, entry.toolWindow.decoratorComponent, /* dirtyMode = */ true, this)
doSetAnchor(entry, layoutInfo, paneId, anchor, order)
showToolWindowImpl(entry, layoutInfo, false)
if (wasFocused) {
entry.toolWindow.requestFocusInToolWindow()
}
}
}
private fun doSetAnchor(entry: ToolWindowEntry, info: WindowInfoImpl, paneId: String, anchor: ToolWindowAnchor, order: Int) {
entry.removeStripeButton()
for (otherInfo in layoutState.setAnchor(info, paneId, anchor, order)) {
idToEntry.get(otherInfo.id ?: continue)?.toolWindow?.setWindowInfoSilently(otherInfo.copy())
}
entry.toolWindow.applyWindowInfo(info.copy())
entry.stripeButton = getToolWindowPane(paneId).buttonManager.createStripeButton(entry.toolWindow, info, task = null)
}
internal fun setSideTool(id: String, isSplit: Boolean) {
val entry = idToEntry.get(id)
if (entry == null) {
LOG.error("Cannot set side tool: toolwindow $id is not registered")
return
}
if (entry.readOnlyWindowInfo.isSplit != isSplit) {
setSideTool(entry, getRegisteredMutableInfoOrLogError(id), isSplit)
fireStateChanged(ToolWindowManagerEventType.SetSideTool)
}
}
private fun setSideTool(entry: ToolWindowEntry, info: WindowInfoImpl, isSplit: Boolean) {
if (isSplit == info.isSplit) {
return
}
// we should hide the window and show it in a 'new place' to automatically hide possible window that is already located in a 'new place'
hideIfNeededAndShowAfterTask(entry, info) {
info.isSplit = isSplit
for (otherEntry in idToEntry.values) {
otherEntry.applyWindowInfo((layoutState.getInfo(otherEntry.id) ?: continue).copy())
}
}
getToolWindowPane(info.safeToolWindowPaneId).buttonManager.getStripeFor(entry.readOnlyWindowInfo.anchor,
entry.readOnlyWindowInfo.isSplit).revalidate()
}
fun setContentUiType(id: String, type: ToolWindowContentUiType) {
val info = getRegisteredMutableInfoOrLogError(id)
info.contentUiType = type
idToEntry.get(info.id!!)!!.applyWindowInfo(info.copy())
fireStateChanged(ToolWindowManagerEventType.SetContentUiType)
}
internal fun setSideToolAndAnchor(id: String, paneId: String, anchor: ToolWindowAnchor, order: Int, isSplit: Boolean) {
val entry = idToEntry.get(id)!!
val readOnlyInfo = entry.readOnlyWindowInfo
if (paneId == readOnlyInfo.safeToolWindowPaneId && anchor == readOnlyInfo.anchor
&& order == readOnlyInfo.order && readOnlyInfo.isSplit == isSplit) {
return
}
val info = getRegisteredMutableInfoOrLogError(id)
hideIfNeededAndShowAfterTask(entry, info) {
info.isSplit = isSplit
doSetAnchor(entry, info, paneId, anchor, order)
}
fireStateChanged(ToolWindowManagerEventType.SetSideToolAndAnchor)
}
private fun hideIfNeededAndShowAfterTask(entry: ToolWindowEntry,
info: WindowInfoImpl,
source: ToolWindowEventSource? = null,
task: () -> Unit) {
val wasVisible = entry.readOnlyWindowInfo.isVisible
val wasFocused = entry.toolWindow.isActive
if (wasVisible) {
executeHide(entry, info, dirtyMode = true)
}
task()
if (wasVisible) {
ToolWindowCollector.getInstance().recordShown(project, source, info)
info.isVisible = true
val infoSnapshot = info.copy()
entry.applyWindowInfo(infoSnapshot)
doShowWindow(entry, infoSnapshot, dirtyMode = true)
if (wasFocused) {
getShowingComponentToRequestFocus(entry.toolWindow)?.requestFocusInWindow()
}
}
getToolWindowPane(info.safeToolWindowPaneId).validateAndRepaint()
}
protected open fun fireStateChanged(changeType: ToolWindowManagerEventType) {
project.messageBus.syncPublisher(ToolWindowManagerListener.TOPIC).stateChanged(this, changeType)
}
private fun fireToolWindowShown(toolWindow: ToolWindow) {
project.messageBus.syncPublisher(ToolWindowManagerListener.TOPIC).toolWindowShown(toolWindow)
}
internal fun setToolWindowAutoHide(id: String, autoHide: Boolean) {
ApplicationManager.getApplication().assertIsDispatchThread()
val info = getRegisteredMutableInfoOrLogError(id)
if (info.isAutoHide == autoHide) {
return
}
info.isAutoHide = autoHide
val entry = idToEntry.get(id) ?: return
val newInfo = info.copy()
entry.applyWindowInfo(newInfo)
fireStateChanged(ToolWindowManagerEventType.SetToolWindowAutoHide)
}
fun setToolWindowType(id: String, type: ToolWindowType) {
ApplicationManager.getApplication().assertIsDispatchThread()
val entry = idToEntry.get(id)!!
if (entry.readOnlyWindowInfo.type == type) {
return
}
setToolWindowTypeImpl(entry, getRegisteredMutableInfoOrLogError(entry.id), type)
fireStateChanged(ToolWindowManagerEventType.SetToolWindowType)
}
private fun setToolWindowTypeImpl(entry: ToolWindowEntry, info: WindowInfoImpl, type: ToolWindowType) {
if (!entry.readOnlyWindowInfo.isVisible) {
info.type = type
entry.applyWindowInfo(info.copy())
return
}
val dirtyMode = entry.readOnlyWindowInfo.type == ToolWindowType.DOCKED || entry.readOnlyWindowInfo.type == ToolWindowType.SLIDING
updateStateAndRemoveDecorator(info, entry, dirtyMode)
info.type = type
if (type != ToolWindowType.FLOATING && type != ToolWindowType.WINDOWED) {
info.internalType = type
}
val newInfo = info.copy()
entry.applyWindowInfo(newInfo)
doShowWindow(entry, newInfo, dirtyMode)
if (ApplicationManager.getApplication().isActive) {
entry.toolWindow.requestFocusInToolWindow()
}
val frame = frameState!!
val rootPane = frame.rootPane ?: return
rootPane.revalidate()
rootPane.repaint()
}
override fun clearSideStack() {
if (isStackEnabled) {
sideStack.clear()
}
}
internal fun setDefaultState(toolWindow: ToolWindowImpl, anchor: ToolWindowAnchor?, type: ToolWindowType?, floatingBounds: Rectangle?) {
val info = getRegisteredMutableInfoOrLogError(toolWindow.id)
if (info.isFromPersistentSettings) {
return
}
if (floatingBounds != null) {
info.floatingBounds = floatingBounds
}
if (anchor != null) {
toolWindow.setAnchor(anchor, null)
}
if (type != null) {
toolWindow.setType(type, null)
}
}
internal fun setDefaultContentUiType(toolWindow: ToolWindowImpl, type: ToolWindowContentUiType) {
val info = getRegisteredMutableInfoOrLogError(toolWindow.id)
if (info.isFromPersistentSettings) {
return
}
toolWindow.setContentUiType(type, null)
}
internal fun stretchWidth(toolWindow: ToolWindowImpl, value: Int) {
getToolWindowPane(toolWindow).stretchWidth(toolWindow, value)
}
override fun isMaximized(window: ToolWindow) = getToolWindowPane(window).isMaximized(window)
override fun setMaximized(window: ToolWindow, maximized: Boolean) {
if (window.type == ToolWindowType.FLOATING && window is ToolWindowImpl) {
MaximizeActiveDialogAction.doMaximize(idToEntry.get(window.id)?.floatingDecorator)
return
}
if (window.type == ToolWindowType.WINDOWED && window is ToolWindowImpl) {
val decorator = getWindowedDecorator(window.id)
val frame = if (decorator != null && decorator.getFrame() is Frame) decorator.getFrame() as Frame else return
val state = frame.state
if (state == Frame.NORMAL) {
frame.state = Frame.MAXIMIZED_BOTH
}
else if (state == Frame.MAXIMIZED_BOTH) {
frame.state = Frame.NORMAL
}
return
}
getToolWindowPane(window).setMaximized(window, maximized)
}
internal fun stretchHeight(toolWindow: ToolWindowImpl, value: Int) {
getToolWindowPane(toolWindow).stretchHeight(toolWindow, value)
}
private fun addFloatingDecorator(entry: ToolWindowEntry, info: WindowInfo) {
val frame = frameState!!.frameOrNull
val decorator = entry.toolWindow.getOrCreateDecoratorComponent()
val floatingDecorator = FloatingDecorator(frame!!, decorator)
floatingDecorator.apply(info)
entry.floatingDecorator = floatingDecorator
val bounds = info.floatingBounds
if ((bounds != null && bounds.width > 0 && bounds.height > 0 &&
WindowManager.getInstance().isInsideScreenBounds(bounds.x, bounds.y, bounds.width))) {
floatingDecorator.bounds = Rectangle(bounds)
}
else {
// place new frame at the center of main frame if there are no floating bounds
var size = decorator.size
if (size.width == 0 || size.height == 0) {
size = decorator.preferredSize
}
floatingDecorator.size = size
floatingDecorator.setLocationRelativeTo(frame)
}
@Suppress("DEPRECATION")
floatingDecorator.show()
}
private fun addWindowedDecorator(entry: ToolWindowEntry, info: WindowInfo) {
val app = ApplicationManager.getApplication()
if (app.isHeadlessEnvironment || app.isUnitTestMode) {
return
}
val id = entry.id
val decorator = entry.toolWindow.getOrCreateDecoratorComponent()
val windowedDecorator = FrameWrapper(project, title = "${entry.toolWindow.stripeTitle} - ${project.name}", component = decorator)
val window = windowedDecorator.getFrame()
MnemonicHelper.init((window as RootPaneContainer).contentPane)
val shouldBeMaximized = info.isMaximized
val bounds = info.floatingBounds
if ((bounds != null && bounds.width > 0 && (bounds.height > 0) &&
WindowManager.getInstance().isInsideScreenBounds(bounds.x, bounds.y, bounds.width))) {
window.bounds = Rectangle(bounds)
}
else {
// place new frame at the center of main frame if there are no floating bounds
var size = decorator.size
if (size.width == 0 || size.height == 0) {
size = decorator.preferredSize
}
window.size = size
window.setLocationRelativeTo(frameState!!.frameOrNull)
}
entry.windowedDecorator = windowedDecorator
Disposer.register(windowedDecorator, Disposable {
if (idToEntry.get(id)?.windowedDecorator != null) {
hideToolWindow(id, false)
}
})
windowedDecorator.show(false)
val rootPane = (window as RootPaneContainer).rootPane
val rootPaneBounds = rootPane.bounds
val point = rootPane.locationOnScreen
val windowBounds = window.bounds
window.setLocation(2 * windowBounds.x - point.x, 2 * windowBounds.y - point.y)
window.setSize(2 * windowBounds.width - rootPaneBounds.width, 2 * windowBounds.height - rootPaneBounds.height)
if (shouldBeMaximized && window is Frame) {
window.extendedState = Frame.MAXIMIZED_BOTH
}
window.toFront()
}
internal fun toolWindowAvailable(toolWindow: ToolWindowImpl) {
if (!toolWindow.isShowStripeButton) {
return
}
val entry = idToEntry.get(toolWindow.id) ?: return
if (entry.stripeButton == null) {
val buttonManager = getButtonManager(entry.toolWindow)
entry.stripeButton = buttonManager.createStripeButton(entry.toolWindow, entry.readOnlyWindowInfo, task = null)
}
val info = layoutState.getInfo(toolWindow.id)
if (info != null && info.isVisible) {
LOG.assertTrue(!entry.readOnlyWindowInfo.isVisible)
if (showToolWindowImpl(entry = entry, toBeShownInfo = info, dirtyMode = false)) {
fireStateChanged(ToolWindowManagerEventType.ToolWindowAvailable)
}
}
}
internal fun toolWindowUnavailable(toolWindow: ToolWindowImpl) {
val entry = idToEntry.get(toolWindow.id)!!
val moveFocusAfter = toolWindow.isActive && toolWindow.isVisible
val info = getRegisteredMutableInfoOrLogError(toolWindow.id)
executeHide(entry, info, dirtyMode = false, mutation = {
entry.removeStripeButton()
})
fireStateChanged(ToolWindowManagerEventType.ToolWindowUnavailable)
if (moveFocusAfter) {
activateEditorComponent()
}
}
/**
* Spies on IdeToolWindow properties and applies them to the window state.
*/
open fun toolWindowPropertyChanged(toolWindow: ToolWindow, property: ToolWindowProperty) {
val stripeButton = idToEntry.get(toolWindow.id)?.stripeButton
if (stripeButton != null) {
if (property == ToolWindowProperty.ICON) {
stripeButton.updateIcon(toolWindow.icon)
}
else {
stripeButton.updatePresentation()
}
}
ActivateToolWindowAction.updateToolWindowActionPresentation(toolWindow)
}
internal fun activated(toolWindow: ToolWindowImpl, source: ToolWindowEventSource?) {
val info = getRegisteredMutableInfoOrLogError(toolWindow.id)
if (isNewUi) {
val visibleToolWindow = idToEntry.values
.asSequence()
.filter { it.toolWindow.isVisible && it.readOnlyWindowInfo.anchor == info.anchor }
.firstOrNull()
if (visibleToolWindow != null) {
info.weight = visibleToolWindow.readOnlyWindowInfo.weight
}
}
activateToolWindow(entry = idToEntry.get(toolWindow.id)!!, info = info, source = source)
}
/**
* Handles event from decorator and modify weight/floating bounds of the
* tool window depending on decoration type.
*/
fun resized(source: InternalDecoratorImpl) {
if (!source.isShowing) {
// do not recalculate the tool window size if it is not yet shown (and, therefore, has 0,0,0,0 bounds)
return
}
val toolWindow = source.toolWindow
val info = getRegisteredMutableInfoOrLogError(toolWindow.id)
if (info.type == ToolWindowType.FLOATING) {
val owner = SwingUtilities.getWindowAncestor(source)
if (owner != null) {
info.floatingBounds = owner.bounds
}
}
else if (info.type == ToolWindowType.WINDOWED) {
val decorator = getWindowedDecorator(toolWindow.id)
val frame = decorator?.getFrame()
if (frame == null || !frame.isShowing) {
return
}
info.floatingBounds = getRootBounds(frame as JFrame)
info.isMaximized = frame.extendedState == Frame.MAXIMIZED_BOTH
}
else {
// docked and sliding windows
val anchor = if (isNewUi) info.anchor else info.anchor
var another: InternalDecoratorImpl? = null
val wholeSize = getToolWindowPane(toolWindow).rootPane.size
if (source.parent is Splitter) {
var sizeInSplit = if (anchor.isSplitVertically) source.height else source.width
val splitter = source.parent as Splitter
if (splitter.secondComponent === source) {
sizeInSplit += splitter.dividerWidth
another = splitter.firstComponent as InternalDecoratorImpl
}
else {
another = splitter.secondComponent as InternalDecoratorImpl
}
info.sideWeight = getAdjustedRatio(partSize = sizeInSplit,
totalSize = if (anchor.isSplitVertically) splitter.height else splitter.width,
direction = if (splitter.secondComponent === source) -1 else 1)
}
val paneWeight = getAdjustedRatio(partSize = if (anchor.isHorizontal) source.height else source.width,
totalSize = if (anchor.isHorizontal) wholeSize.height else wholeSize.width, direction = 1)
info.weight = paneWeight
if (another != null) {
getRegisteredMutableInfoOrLogError(another.toolWindow.id).weight = paneWeight
}
}
fireStateChanged(Resized)
}
private fun focusToolWindowByDefault() {
var toFocus: ToolWindowEntry? = null
for (each in activeStack.stack) {
if (each.readOnlyWindowInfo.isVisible) {
toFocus = each
break
}
}
if (toFocus == null) {
for (each in activeStack.persistentStack) {
if (each.readOnlyWindowInfo.isVisible) {
toFocus = each
break
}
}
}
if (toFocus != null && !ApplicationManager.getApplication().isDisposed) {
activateToolWindow(toFocus, getRegisteredMutableInfoOrLogError(toFocus.id))
}
}
internal fun setShowStripeButton(id: String, value: Boolean) {
if (isNewUi) {
LOG.info("Ignore setShowStripeButton(id=$id, value=$value) - not applicable for a new UI")
return
}
val entry = idToEntry.get(id) ?: throw IllegalStateException("window with id=\"$id\" isn't registered")
var info = layoutState.getInfo(id)
if (info == null) {
if (!value) {
return
}
// window was registered but stripe button was not shown, so, layout was not added to a list
info = (entry.readOnlyWindowInfo as WindowInfoImpl).copy()
layoutState.addInfo(id, info)
}
if (value == info.isShowStripeButton) {
return
}
info.isShowStripeButton = value
if (!value) {
entry.removeStripeButton()
}
entry.applyWindowInfo(info.copy())
if (value && entry.stripeButton == null) {
val buttonManager = getButtonManager(entry.toolWindow)
entry.stripeButton = buttonManager.createStripeButton(entry.toolWindow, entry.readOnlyWindowInfo, task = null)
}
fireStateChanged(ToolWindowManagerEventType.SetShowStripeButton)
}
private fun checkInvariants(id: String?) {
val app = ApplicationManager.getApplication()
if (!app.isEAP && !app.isInternal) {
return
}
val violations = mutableListOf<String>()
for (entry in idToEntry.values) {
val info = layoutState.getInfo(entry.id) ?: continue
if (!info.isVisible) {
continue
}
if (!app.isHeadlessEnvironment && !app.isUnitTestMode) {
if (info.type == ToolWindowType.FLOATING) {
if (entry.floatingDecorator == null) {
violations.add("Floating window has no decorator: ${entry.id}")
}
}
else if (info.type == ToolWindowType.WINDOWED && entry.windowedDecorator == null) {
violations.add("Windowed window has no decorator: ${entry.id}")
}
}
}
if (violations.isNotEmpty()) {
LOG.error("Invariants failed: \n${violations.joinToString("\n")}\n${if (id == null) "" else "id: $id"}")
}
}
}
private enum class KeyState {
WAITING, PRESSED, RELEASED, HOLD
}
private fun areAllModifiersPressed(@JdkConstants.InputEventMask modifiers: Int, @JdkConstants.InputEventMask mask: Int): Boolean {
return (modifiers xor mask) == 0
}
@Suppress("DEPRECATION")
@JdkConstants.InputEventMask
private fun keyCodeToInputMask(code: Int): Int {
return when (code) {
KeyEvent.VK_SHIFT -> Event.SHIFT_MASK
KeyEvent.VK_CONTROL -> Event.CTRL_MASK
KeyEvent.VK_META -> Event.META_MASK
KeyEvent.VK_ALT -> Event.ALT_MASK
else -> 0
}
}
// We should filter out 'mixed' mask like InputEvent.META_MASK | InputEvent.META_DOWN_MASK
@JdkConstants.InputEventMask
private fun getActivateToolWindowVKsMask(): Int {
if (!LoadingState.COMPONENTS_LOADED.isOccurred) {
return 0
}
if (Registry.`is`("toolwindow.disable.overlay.by.double.key")) {
return 0
}
val baseShortcut = KeymapManager.getInstance().activeKeymap.getShortcuts("ActivateProjectToolWindow")
@Suppress("DEPRECATION")
var baseModifiers = if (SystemInfoRt.isMac) InputEvent.META_MASK else InputEvent.ALT_MASK
for (each in baseShortcut) {
if (each is KeyboardShortcut) {
val keyStroke = each.firstKeyStroke
baseModifiers = keyStroke.modifiers
if (baseModifiers > 0) {
break
}
}
}
// We should filter out 'mixed' mask like InputEvent.META_MASK | InputEvent.META_DOWN_MASK
@Suppress("DEPRECATION")
return baseModifiers and (InputEvent.SHIFT_MASK or InputEvent.CTRL_MASK or InputEvent.META_MASK or InputEvent.ALT_MASK)
}
private val isStackEnabled: Boolean
get() = Registry.`is`("ide.enable.toolwindow.stack")
private fun getRootBounds(frame: JFrame): Rectangle {
val rootPane = frame.rootPane
val bounds = rootPane.bounds
bounds.setLocation(frame.x + rootPane.x, frame.y + rootPane.y)
return bounds
}
private fun getToolWindowIdForComponent(component: Component?): String? {
var c = component
while (c != null) {
if (c is InternalDecoratorImpl) {
return c.toolWindow.id
}
c = ClientProperty.get(c, ToolWindowManagerImpl.PARENT_COMPONENT) ?: c.parent
}
return null
}
private class BalloonHyperlinkListener(private val listener: HyperlinkListener?) : HyperlinkListener {
var balloon: Balloon? = null
override fun hyperlinkUpdate(e: HyperlinkEvent) {
val balloon = balloon
if (balloon != null && e.eventType == HyperlinkEvent.EventType.ACTIVATED) {
balloon.hide()
}
listener?.hyperlinkUpdate(e)
}
} | platform/platform-impl/src/com/intellij/openapi/wm/impl/ToolWindowManagerImpl.kt | 3323943105 |
// WITH_STDLIB
// INTENTION_TEXT: "Replace with '+= takeWhile{}'"
// INTENTION_TEXT_2: "Replace with '+= asSequence().takeWhile{}'"
fun foo(list: List<String>, target: MutableCollection<String>) {
<caret>for (s in list) {
if (s.isEmpty()) break
target.add(s)
}
} | plugins/kotlin/idea/tests/testData/intentions/loopToCallChain/takeWhile/simple.kt | 1701594564 |
// INTENTION_TEXT: "Import members from 'java.util.regex.Pattern'"
// WITH_RUNTIME
// ERROR: Unresolved reference: unresolved
import java.util.regex.Pattern
fun foo() {
Pattern.matches("", "")
val field = <caret>Pattern.CASE_INSENSITIVE
Pattern.compile("")
val fieldFqn = java.util.regex.Pattern.CASE_INSENSITIVE
Pattern.unresolved
}
| plugins/kotlin/idea/tests/testData/intentions/importAllMembers/StaticJavaMembers.kt | 619923629 |
val a = """blah blah blah
| blah blah<caret>
"""
//-----
val a = """blah blah blah
| blah blah
| <caret>
""" | plugins/kotlin/idea/tests/testData/editor/enterHandler/multilineString/withTabs/tabs2/enterMLStartOnSameLineMargin.kt | 3444996325 |
// WITH_RUNTIME
// INTENTION_TEXT: "Replace with 'mapIndexed{}.forEach{}'"
// INTENTION_TEXT_2: "Replace with 'asSequence().mapIndexed{}.forEach{}'"
fun foo(list: List<String>) {
<caret>for ((index, s) in list.withIndex()) {
val x = s.length * index
println(x)
}
} | plugins/kotlin/idea/tests/testData/intentions/loopToCallChain/forEach/notIndexed.kt | 965949139 |
/*
* This file is part of TachiyomiEX.
*
* TachiyomiEX is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* TachiyomiEX is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with TachiyomiEX. If not, see <http://www.gnu.org/licenses/>.
*/
package eu.kanade.tachiyomi.data.source.online.italian
import eu.kanade.tachiyomi.data.database.models.Manga
import eu.kanade.tachiyomi.data.source.IT
import eu.kanade.tachiyomi.data.source.Language
import eu.kanade.tachiyomi.data.source.Sources
import eu.kanade.tachiyomi.data.source.online.multi.Ninemanga
class NinemangaIT(override val source: Sources) : Ninemanga() {
override val lang: Language = IT
override val baseUrl: String = "http://${lang.code}.ninemanga.com"
override fun parseStatus(status: String) = when {
status.contains("In corso") -> Manga.ONGOING
status.contains("Completado") -> Manga.COMPLETED
else -> Manga.UNKNOWN
}
}
| app/src/main/java/eu/kanade/tachiyomi/data/source/online/italian/NinemangaIT.kt | 4009007474 |
/*
* Copyright 2012-2016 Dmitri Pisarenko
*
* WWW: http://altruix.cc
* E-Mail: [email protected]
* Skype: dp118m (voice calls must be scheduled in advance)
*
* Physical address:
*
* 4-i Rostovskii pereulok 2/1/20
* 119121 Moscow
* Russian Federation
*
* This file is part of econsim-tr01.
*
* econsim-tr01 is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* econsim-tr01 is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with econsim-tr01. If not, see <http://www.gnu.org/licenses/>.
*
*/
package cc.altruix.econsimtr01.ch03
import cc.altruix.econsimtr01.DefaultAgent
import cc.altruix.econsimtr01.millisToSimulationDateTime
import org.fest.assertions.Assertions
import org.joda.time.DateTime
import org.junit.Test
import java.io.File
import java.util.*
/**
* Created by pisarenko on 17.05.2016.
*/
class Process2Tests {
@Test
fun timeToRun() {
timeToRunTestLogic(
time = DateTime(0, 7, 4, 23, 59),
expectedResult = false
)
timeToRunTestLogic(
time = DateTime(0, 7, 5, 0, 0),
expectedResult = true
)
timeToRunTestLogic(
time = DateTime(0, 7, 5, 0, 1),
expectedResult = false
)
}
@Test
fun run() {
// Prepare
val simParamProv =
AgriculturalSimParametersProvider(
File(
"src/test/resources/ch03/BasicAgriculturalSimulationRye.properties"
)
)
simParamProv.initAndValidate()
val field = simParamProv.agents.find { it.id() == Field.ID }
as DefaultAgent
Assertions.assertThat(field).isNotNull
field.put(AgriculturalSimParametersProvider.RESOURCE_AREA_WITH_SEEDS
.id,
250000.0)
Assertions.assertThat(field.amount(AgriculturalSimParametersProvider
.RESOURCE_SEEDS.id)).isZero
val time = 0L.millisToSimulationDateTime()
val out = Process2(simParamProv)
// Run method under test
out.run(time)
// Verify
Assertions.assertThat(
field.amount(
AgriculturalSimParametersProvider.
RESOURCE_AREA_WITH_SEEDS.id
)
).isEqualTo(0.0)
Assertions.assertThat(
field.amount(
AgriculturalSimParametersProvider.
RESOURCE_AREA_WITH_CROP.id
)
).isEqualTo(250000.0)
Assertions.assertThat(
field.amount(
AgriculturalSimParametersProvider.
RESOURCE_SEEDS.id
)
).isEqualTo(250000.0*0.3595)
}
private fun timeToRunTestLogic(time: DateTime,
expectedResult: Boolean) {
// Prepare
val data = Properties()
data["Process2End"] = "05.07"
val simParamProv =
AgriculturalSimParametersProviderWithPredefinedData(data)
simParamProv.initAndValidate()
simParamProv.agents.add(Field(simParamProv))
val out = Process2(simParamProv)
// Run method under test
val res = out.timeToRun(time)
// Verify
Assertions.assertThat(res).isEqualTo(expectedResult)
}
} | src/test/java/cc/altruix/econsimtr01/ch03/Process2Tests.kt | 590012772 |
// PROBLEM: none
// WITH_RUNTIME
interface Foo {
fun add(i: Int): Boolean
}
class Bar: ArrayList<Int>(), Foo {
override <caret>fun add(i: Int) = super.add(i)
} | plugins/kotlin/idea/tests/testData/inspectionsLocal/redundantOverride/boxedParameters.kt | 3250672070 |
package torille.fi.lurkforreddit.subreddits
import android.content.res.ColorStateList
import android.graphics.Color
import android.support.v7.widget.RecyclerView
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import android.widget.Button
import android.widget.TextView
import torille.fi.lurkforreddit.R
import torille.fi.lurkforreddit.data.models.view.Subreddit
import java.util.*
/**
* [RecyclerView.Adapter] for showing subreddits
*/
internal class SubredditsAdapter internal constructor(
private val mItemListener: SubredditsFragment.SubredditItemListener,
color: Int
) : RecyclerView.Adapter<SubredditsAdapter.ViewHolder>() {
private val mSubreddits: MutableList<Subreddit> = ArrayList(25)
private val mDefaultColor: ColorStateList = ColorStateList.valueOf(color)
override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): ViewHolder {
val context = parent.context
val inflater = LayoutInflater.from(context)
val subredditsView = inflater.inflate(R.layout.item_subreddit, parent, false)
return ViewHolder(subredditsView)
}
override fun onBindViewHolder(viewHolder: ViewHolder, position: Int) {
val (_, _, displayName, _, keyColor) = mSubreddits[position]
viewHolder.title.text = displayName
if (keyColor.isNullOrEmpty()) {
viewHolder.colorButton.backgroundTintList = mDefaultColor
} else {
viewHolder.colorButton.backgroundTintList =
ColorStateList.valueOf(Color.parseColor(keyColor))
}
}
internal fun replaceData(subreddits: List<Subreddit>) {
mSubreddits.clear()
mSubreddits.addAll(subreddits)
notifyDataSetChanged()
}
override fun getItemCount(): Int {
return mSubreddits.size
}
internal inner class ViewHolder(itemView: View) : RecyclerView.ViewHolder(itemView),
View.OnClickListener {
val title: TextView = itemView.findViewById(R.id.item_subreddit_title)
val colorButton: Button = itemView.findViewById(R.id.item_subreddit_circle)
init {
itemView.setOnClickListener(this)
}
override fun onClick(v: View) {
mItemListener.onSubredditClick(mSubreddits[adapterPosition])
}
}
} | app/src/main/java/torille/fi/lurkforreddit/subreddits/SubredditsAdapter.kt | 4103032228 |
// FIR_IDENTICAL
// FIR_COMPARISON
package b
import b.A.<caret>
class A {
fun bar() {}
companion object {
fun foo() {}
}
}
// INVOCATION_COUNT: 2
// EXIST: Companion
// ABSENT: bar
// ABSENT: foo
| plugins/kotlin/completion/tests/testData/basic/common/staticMembers/ImportsFromNonObject.kt | 648949851 |
/*
* Copyright (C) 2016-2021 Sandip Vaghela
* 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
*
* http://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.
*/
package com.afterroot.allusive2.magisk
import java.io.File
import java.io.FileInputStream
import java.io.FileOutputStream
import java.io.IOException
import java.io.InputStream
import java.util.zip.ZipEntry
import java.util.zip.ZipInputStream
import java.util.zip.ZipOutputStream
@Throws(IOException::class)
fun File.unzip(toFolder: File, path: String = "", junkPath: Boolean = false) {
inputStream().buffered().use {
it.unzip(toFolder, path, junkPath)
}
}
@Throws(IOException::class)
fun InputStream.unzip(folder: File, path: String, junkPath: Boolean) {
try {
val zin = ZipInputStream(this)
var entry: ZipEntry
while (true) {
entry = zin.nextEntry ?: break
if (!entry.name.startsWith(path) || entry.isDirectory) {
// Ignore directories, only create files
continue
}
val name = if (junkPath)
entry.name.substring(entry.name.lastIndexOf('/') + 1)
else
entry.name
val dest = File(folder, name)
dest.parentFile!!.mkdirs()
FileOutputStream(dest).use { zin.copyTo(it) }
}
} catch (e: IOException) {
e.printStackTrace()
throw e
}
}
var filesListInDir: MutableList<String> = ArrayList()
fun zip(sourceFolder: File, exportPath: String): File {
filesListInDir.clear()
runCatching {
populateFilesList(sourceFolder)
val fos = FileOutputStream(exportPath)
val zos = ZipOutputStream(fos)
for (filePath in filesListInDir) {
val ze = ZipEntry(filePath.substring(sourceFolder.absolutePath.length + 1, filePath.length))
zos.putNextEntry(ze)
val fis = FileInputStream(filePath)
fis.copyTo(zos)
zos.closeEntry()
fis.close()
}
zos.close()
fos.close()
}.onFailure {
it.printStackTrace()
}
return File(exportPath)
}
@Throws(IOException::class)
private fun populateFilesList(dir: File) {
val files = dir.listFiles()
files?.forEach { file ->
if (file.isFile) filesListInDir.add(file.absolutePath) else populateFilesList(file)
}
}
| ui/magisk/src/main/java/com/afterroot/allusive2/magisk/ZipUtils.kt | 877666030 |
// Copyright 2000-2022 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license.
package com.intellij.internal.statistic.devkit.actions
import com.intellij.icons.AllIcons
import com.intellij.ide.gdpr.ConsentConfigurable
import com.intellij.idea.ActionsBundle
import com.intellij.internal.statistic.StatisticsBundle
import com.intellij.internal.statistic.devkit.StatisticsDevKitUtil
import com.intellij.internal.statistic.devkit.StatisticsDevKitUtil.DEFAULT_RECORDER
import com.intellij.internal.statistic.devkit.StatisticsDevKitUtil.STATISTICS_NOTIFICATION_GROUP_ID
import com.intellij.internal.statistic.eventLog.StatisticsEventLogProviderUtil
import com.intellij.internal.statistic.eventLog.fus.FeatureUsageLogger.getConfig
import com.intellij.internal.statistic.eventLog.fus.FeatureUsageLogger.rollOver
import com.intellij.internal.statistic.utils.StatisticsRecorderUtil
import com.intellij.notification.Notification
import com.intellij.notification.NotificationAction
import com.intellij.notification.NotificationType
import com.intellij.openapi.actionSystem.AnActionEvent
import com.intellij.openapi.application.ApplicationManager
import com.intellij.openapi.fileEditor.FileEditorManager
import com.intellij.openapi.options.ex.SingleConfigurableEditor
import com.intellij.openapi.progress.ProgressIndicator
import com.intellij.openapi.progress.ProgressManager
import com.intellij.openapi.progress.Task.Backgroundable
import com.intellij.openapi.project.DumbAwareAction
import com.intellij.openapi.project.Project
import com.intellij.openapi.vfs.LocalFileSystem
/**
* Collects the data from all state collectors and record it in event log.
*
* @see com.intellij.internal.statistic.service.fus.collectors.ApplicationUsagesCollector
*
* @see com.intellij.internal.statistic.service.fus.collectors.ProjectUsagesCollector
*/
internal class RecordStateStatisticsEventLogAction(private val recorderId: String = DEFAULT_RECORDER,
private val myShowNotification: Boolean = true) : DumbAwareAction(
ActionsBundle.message("action.RecordStateCollectors.text"),
ActionsBundle.message("action.RecordStateCollectors.description"),
AllIcons.Ide.IncomingChangesOn) {
override fun actionPerformed(e: AnActionEvent) {
val project = e.project ?: return
if (!checkLogRecordingEnabled(project, recorderId)) return
val message = StatisticsBundle.message("stats.collecting.feature.usages.in.event.log")
ProgressManager.getInstance().run(object : Backgroundable(project, message, false) {
override fun run(indicator: ProgressIndicator) {
rollOver()
val state = FusStatesRecorder.recordStateAndWait(project, indicator, recorderId)
if (state == null) {
StatisticsDevKitUtil.showNotification(project, NotificationType.ERROR, StatisticsBundle.message("stats.failed.recording.state"))
}
else if (myShowNotification) {
showNotification(project)
}
}
})
}
private fun showNotification(project: Project) {
val logFile = getConfig().getActiveLogFile()
val virtualFile = if (logFile != null) LocalFileSystem.getInstance().findFileByIoFile(logFile.file) else null
ApplicationManager.getApplication().invokeLater {
val notification = Notification(STATISTICS_NOTIFICATION_GROUP_ID, "Finished collecting and recording events",
NotificationType.INFORMATION)
if (virtualFile != null) {
notification.addAction(NotificationAction.createSimple(
StatisticsBundle.message("stats.open.log.notification.action"),
Runnable { FileEditorManager.getInstance(project).openFile(virtualFile, true) }))
}
notification.notify(project)
}
}
override fun update(e: AnActionEvent) {
super.update(e)
val isTestMode = StatisticsRecorderUtil.isTestModeEnabled(recorderId)
e.presentation.isEnabled = isTestMode && !FusStatesRecorder.isRecordingInProgress()
}
companion object {
fun checkLogRecordingEnabled(project: Project?, recorderId: String?): Boolean {
if (StatisticsEventLogProviderUtil.getEventLogProvider(recorderId!!).isRecordEnabled()) {
return true
}
Notification(STATISTICS_NOTIFICATION_GROUP_ID, StatisticsBundle.message("stats.logging.is.disabled"), NotificationType.WARNING)
.addAction(NotificationAction.createSimple(StatisticsBundle.message("stats.enable.data.sharing"),
Runnable { SingleConfigurableEditor(project, ConsentConfigurable()).show() }))
.notify(project)
return false
}
}
}
| platform/statistics/devkit/src/com/intellij/internal/statistic/devkit/actions/RecordStateStatisticsEventLogAction.kt | 964308482 |
// Copyright 2000-2021 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file.
package com.intellij.ide.bookmark.actions
import com.intellij.ide.bookmark.BookmarkBundle.messagePointer
import com.intellij.ide.bookmark.BookmarkType
import com.intellij.openapi.actionSystem.AnActionEvent
import com.intellij.openapi.project.DumbAwareAction
internal open class GotoBookmarkTypeAction(private val type: BookmarkType, private val isEnabled: (AnActionEvent) -> Boolean)
: DumbAwareAction(messagePointer("goto.bookmark.type.action.text", type.mnemonic)/*, type.icon*/) {
constructor(type: BookmarkType) : this(type, { true })
private fun canNavigate(event: AnActionEvent) = event.bookmarksManager?.getBookmark(type)?.canNavigate() ?: false
override fun update(event: AnActionEvent) {
event.presentation.isEnabledAndVisible = isEnabled(event) && canNavigate(event)
}
override fun actionPerformed(event: AnActionEvent) {
event.bookmarksManager?.getBookmark(type)?.navigate(true)
}
init {
isEnabledInModalContext = true
}
}
internal class GotoBookmark1Action : GotoBookmarkTypeAction(BookmarkType.DIGIT_1)
internal class GotoBookmark2Action : GotoBookmarkTypeAction(BookmarkType.DIGIT_2)
internal class GotoBookmark3Action : GotoBookmarkTypeAction(BookmarkType.DIGIT_3)
internal class GotoBookmark4Action : GotoBookmarkTypeAction(BookmarkType.DIGIT_4)
internal class GotoBookmark5Action : GotoBookmarkTypeAction(BookmarkType.DIGIT_5)
internal class GotoBookmark6Action : GotoBookmarkTypeAction(BookmarkType.DIGIT_6)
internal class GotoBookmark7Action : GotoBookmarkTypeAction(BookmarkType.DIGIT_7)
internal class GotoBookmark8Action : GotoBookmarkTypeAction(BookmarkType.DIGIT_8)
internal class GotoBookmark9Action : GotoBookmarkTypeAction(BookmarkType.DIGIT_9)
internal class GotoBookmark0Action : GotoBookmarkTypeAction(BookmarkType.DIGIT_0)
internal class GotoBookmarkAAction : GotoBookmarkTypeAction(BookmarkType.LETTER_A)
internal class GotoBookmarkBAction : GotoBookmarkTypeAction(BookmarkType.LETTER_B)
internal class GotoBookmarkCAction : GotoBookmarkTypeAction(BookmarkType.LETTER_C)
internal class GotoBookmarkDAction : GotoBookmarkTypeAction(BookmarkType.LETTER_D)
internal class GotoBookmarkEAction : GotoBookmarkTypeAction(BookmarkType.LETTER_E)
internal class GotoBookmarkFAction : GotoBookmarkTypeAction(BookmarkType.LETTER_F)
internal class GotoBookmarkGAction : GotoBookmarkTypeAction(BookmarkType.LETTER_G)
internal class GotoBookmarkHAction : GotoBookmarkTypeAction(BookmarkType.LETTER_H)
internal class GotoBookmarkIAction : GotoBookmarkTypeAction(BookmarkType.LETTER_I)
internal class GotoBookmarkJAction : GotoBookmarkTypeAction(BookmarkType.LETTER_J)
internal class GotoBookmarkKAction : GotoBookmarkTypeAction(BookmarkType.LETTER_K)
internal class GotoBookmarkLAction : GotoBookmarkTypeAction(BookmarkType.LETTER_L)
internal class GotoBookmarkMAction : GotoBookmarkTypeAction(BookmarkType.LETTER_M)
internal class GotoBookmarkNAction : GotoBookmarkTypeAction(BookmarkType.LETTER_N)
internal class GotoBookmarkOAction : GotoBookmarkTypeAction(BookmarkType.LETTER_O)
internal class GotoBookmarkPAction : GotoBookmarkTypeAction(BookmarkType.LETTER_P)
internal class GotoBookmarkQAction : GotoBookmarkTypeAction(BookmarkType.LETTER_Q)
internal class GotoBookmarkRAction : GotoBookmarkTypeAction(BookmarkType.LETTER_R)
internal class GotoBookmarkSAction : GotoBookmarkTypeAction(BookmarkType.LETTER_S)
internal class GotoBookmarkTAction : GotoBookmarkTypeAction(BookmarkType.LETTER_T)
internal class GotoBookmarkUAction : GotoBookmarkTypeAction(BookmarkType.LETTER_U)
internal class GotoBookmarkVAction : GotoBookmarkTypeAction(BookmarkType.LETTER_V)
internal class GotoBookmarkWAction : GotoBookmarkTypeAction(BookmarkType.LETTER_W)
internal class GotoBookmarkXAction : GotoBookmarkTypeAction(BookmarkType.LETTER_X)
internal class GotoBookmarkYAction : GotoBookmarkTypeAction(BookmarkType.LETTER_Y)
internal class GotoBookmarkZAction : GotoBookmarkTypeAction(BookmarkType.LETTER_Z)
| platform/lang-impl/src/com/intellij/ide/bookmark/actions/GotoBookmarkTypeAction.kt | 452446215 |
// Copyright 2000-2020 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file.
package com.intellij.ide.projectView
import com.intellij.ide.projectView.impl.ModuleGroup
import com.intellij.ide.projectView.impl.ModuleGroupingImplementation
import com.intellij.ide.projectView.impl.ModuleGroupingTreeHelper
import com.intellij.openapi.util.Pair
import com.intellij.testFramework.PlatformTestUtil
import com.intellij.testFramework.UsefulTestCase
import com.intellij.ui.tree.TreeTestUtil
import com.intellij.ui.treeStructure.Tree
import com.intellij.util.ui.tree.TreeUtil
import junit.framework.TestCase
import java.util.*
import javax.swing.tree.DefaultMutableTreeNode
import javax.swing.tree.DefaultTreeModel
class ModuleGroupingTreeHelperTest: UsefulTestCase() {
private lateinit var tree: Tree
private lateinit var root: MockModuleTreeNode
private lateinit var model: DefaultTreeModel
override fun setUp() {
super.setUp()
root = MockModuleTreeNode("root")
model = DefaultTreeModel(root)
tree = Tree(model)
TreeTestUtil.assertTreeUI(tree)
}
fun `test disabled grouping`() {
createHelper(false).createModuleNodes("a.main", "a.util")
assertTreeEqual("""
-root
a.main
a.util""")
createHelperFromTree(true).moveAllModuleNodesAndCheckResult("""
-root
-a
a.main
a.util""")
}
fun `test disabled grouping and compacting nodes`() {
createHelper(enableGrouping = false, compactGroupNodes = false).createModuleNodes("a.main", "a.util")
assertTreeEqual("""
-root
a.main
a.util""")
createHelperFromTree(enableGrouping = true, compactGroupNodes = false).moveAllModuleNodesAndCheckResult("""
-root
-a
a.main
a.util""")
}
fun `test single module`() {
createHelper().createModuleNodes("a.main")
assertTreeEqual("""
-root
a.main""")
createHelperFromTree(false).moveAllModuleNodesAndCheckResult("""
-root
a.main""")
}
fun `test single module with disabled compacting`() {
createHelper(compactGroupNodes = false).createModuleNodes("a.main")
assertTreeEqual("""
-root
-a
a.main""")
createHelperFromTree(false).moveAllModuleNodesAndCheckResult("""
-root
a.main""")
}
fun `test two modules`() {
createHelper().createModuleNodes("a.main", "a.util")
assertTreeEqual("""
-root
-a
a.main
a.util
""")
createHelperFromTree(false).moveAllModuleNodesAndCheckResult("""
-root
a.main
a.util""")
}
fun `test two modules with common prefix`() {
createHelper().createModuleNodes("com.a.main", "com.a.util")
assertTreeEqual("""
-root
-a
com.a.main
com.a.util
""")
createHelperFromTree(false).moveAllModuleNodesAndCheckResult("""
-root
com.a.main
com.a.util
""")
}
fun `test two modules with common prefix and parent module as a group`() {
createHelper().createModuleNodes("com.a.main", "com.a.util", "com.a")
assertTreeEqual("""
-root
-com.a
com.a.main
com.a.util
""")
createHelperFromTree(false).moveAllModuleNodesAndCheckResult("""
-root
com.a
com.a.main
com.a.util
""")
}
fun `test create two nested groups`() {
createHelper().createModuleNodes("com.a.foo.bar", "com.a.baz", "com.a.foo.baz")
assertTreeEqual("""
-root
-a
com.a.baz
-foo
com.a.foo.bar
com.a.foo.baz
""")
createHelperFromTree(false).moveAllModuleNodesAndCheckResult("""
-root
com.a.baz
com.a.foo.bar
com.a.foo.baz
""")
}
fun `test two groups`() {
createHelper().createModuleNodes("a.main", "b.util", "a.util", "b.main")
assertTreeEqual("""
-root
-a
a.main
a.util
-b
b.main
b.util
""")
createHelperFromTree(false).moveAllModuleNodesAndCheckResult("""
-root
a.main
a.util
b.main
b.util
""")
}
fun `test module as a group`() {
createHelper().createModuleNodes("a.impl", "a", "a.tests")
assertTreeEqual("""
-root
-a
a.impl
a.tests
""")
createHelperFromTree(false).moveAllModuleNodesAndCheckResult("""
-root
a
a.impl
a.tests""")
}
fun `test module as a group with inner modules`() {
createHelper().createModuleNodes("com.foo", "com.foo.bar", "com.foo.baz.zoo1", "com.foo.baz.zoo2")
assertTreeEqual("""
-root
-com.foo
-baz
com.foo.baz.zoo1
com.foo.baz.zoo2
com.foo.bar
""")
}
fun `test add prefix to module name`() {
val nodes = createHelper().createModuleNodes("main", "util")
assertTreeEqual("""
-root
main
util""")
val node = nodes.find { it.second.name == "main" }!!
node.second.name = "a.main"
moveModuleNodeToProperGroupAndCheckResult(node, """
-root
a.main
util""")
}
fun `test move module node to new group`() {
val nodes = createHelper().createModuleNodes("main", "util", "a.foo")
assertTreeEqual("""
-root
a.foo
main
util""")
val node = nodes.find { it.second.name == "main" }!!
node.second.name = "a.main"
moveModuleNodeToProperGroupAndCheckResult(node, """
-root
-a
a.foo
a.main
util""")
}
fun `test move module node from parent module`() {
val nodes = createHelper().createModuleNodes("a", "a.main")
assertTreeEqual("""
-root
-a
a.main""")
val node = nodes.find { it.second.name == "a.main" }!!
node.second.name = "main"
moveModuleNodeToProperGroupAndCheckResult(node, """
-root
a
main""")
}
fun `test move module node to parent module`() {
val nodes = createHelper().createModuleNodes("a", "main")
val node = nodes.find { it.second.name == "main" }!!
node.second.name = "a.main"
moveModuleNodeToProperGroupAndCheckResult(node, """
-root
-a
a.main""")
}
fun `test insert component into the middle of a module name`() {
val nodes = createHelper().createModuleNodes("a", "a.main")
val node = nodes.find { it.second.name == "a.main" }!!
node.second.name = "a.main.util"
moveModuleNodeToProperGroupAndCheckResult(node, """
-root
-a
a.main.util""")
}
fun `test move module node to child node`() {
val nodes = createHelper().createModuleNodes("a.main", "a.util")
val node = nodes.find { it.second.name == "a.util" }!!
node.second.name = "a.main.util"
moveModuleNodeToProperGroupAndCheckResult(node, """
-root
-a.main
a.main.util""")
}
fun `test remove component from the middle of a module name`() {
val nodes = createHelper().createModuleNodes("a.foo", "a.foo.bar.baz")
val node = nodes.find { it.second.name == "a.foo.bar.baz" }!!
node.second.name = "a.baz"
moveModuleNodeToProperGroupAndCheckResult(node, """
-root
-a
a.baz
a.foo""")
}
fun `test module node become parent module`() {
val nodes = createHelper().createModuleNodes("b", "a.main")
val node = nodes.find { it.second.name == "b" }!!
node.second.name = "a"
moveModuleNodeToProperGroupAndCheckResult(node, """
-root
-a
a.main""")
}
fun `test parent module become ordinary module`() {
val nodes = createHelper().createModuleNodes("a", "a.main")
val node = nodes.find { it.second.name == "a" }!!
node.second.name = "b"
moveModuleNodeToProperGroupAndCheckResult(node, """
-root
a.main
b""")
}
fun `test parent module become ordinary module with disabled compacting`() {
val nodes = createHelper(compactGroupNodes = false).createModuleNodes("a", "a.main")
val node = nodes.find { it.second.name == "a" }!!
node.second.name = "b"
moveModuleNodeToProperGroupAndCheckResult(node, """
-root
-a
a.main
b""", compactGroupNodes = false)
}
fun `test parent module become ordinary module but group remains`() {
val nodes = createHelper().createModuleNodes("a", "a.main", "a.util")
val node = nodes.find { it.second.name == "a" }!!
node.second.name = "b"
moveModuleNodeToProperGroupAndCheckResult(node, """
-root
-a
a.main
a.util
b""")
}
fun `test do not move node if its group wasn't changed`() {
val nodes = createHelper().createModuleNodes("a", "a.main")
nodes.forEach {
val node = it.first
val newNode = createHelperFromTree(nodeToBeMovedFilter = {it == node}).moveModuleNodeToProperGroup(node, it.second, root, model, tree)
assertSame(node, newNode)
}
}
fun `test do not move node if its virtual group wasn't changed`() {
val nodes = createHelper().createModuleNodes("a.util.foo", "a.main.bar")
nodes.forEach {
val node = it.first
val newNode = createHelperFromTree(nodeToBeMovedFilter = {it == node}).moveModuleNodeToProperGroup(node, it.second, root, model, tree)
assertSame(node, newNode)
}
}
fun `test add new module node`() {
val helper = createHelper()
helper.createModuleNodes("a", "a.main")
helper.createModuleNode(MockModule("a.b"), root, model)
assertTreeEqual("""
-root
-a
a.b
a.main
""")
}
fun `test remove module node`() {
val helper = createHelper()
val nodes = helper.createModuleNodes("a.main", "a.util", "b")
assertTreeEqual("""
-root
-a
a.main
a.util
b
""")
helper.removeNode(nodes[0].first, root, model)
assertTreeEqual("""
-root
a.util
b
""")
helper.removeNode(nodes[1].first, root, model)
assertTreeEqual("""
-root
b
""")
}
fun `test remove module node with disabled compacting`() {
val helper = createHelper(compactGroupNodes = false)
val nodes = helper.createModuleNodes("a.main", "a.util", "b")
assertTreeEqual("""
-root
-a
a.main
a.util
b
""")
helper.removeNode(nodes[0].first, root, model)
assertTreeEqual("""
-root
-a
a.util
b
""")
helper.removeNode(nodes[1].first, root, model)
assertTreeEqual("""
-root
b
""")
}
private fun moveModuleNodeToProperGroupAndCheckResult(node: Pair<MockModuleTreeNode, MockModule>,
expected: String, compactGroupNodes: Boolean = true) {
val thisNode: (MockModuleTreeNode) -> Boolean = { it == node.first }
val helper = createHelperFromTree(nodeToBeMovedFilter = thisNode, compactGroupNodes = compactGroupNodes)
helper.checkConsistency(nodeToBeMovedFilter = thisNode)
helper.moveModuleNodeToProperGroup(node.first, node.second, root, model, tree)
assertTreeEqual(expected)
helper.checkConsistency(nodeToBeMovedFilter = {false})
}
private fun ModuleGroupingTreeHelper<MockModule, MockModuleTreeNode>.moveAllModuleNodesAndCheckResult(expected: String) {
checkConsistency(nodeToBeMovedFilter = {true})
moveAllModuleNodesToProperGroups(root, model)
assertTreeEqual(expected)
checkConsistency(nodeToBeMovedFilter = {false})
}
private fun ModuleGroupingTreeHelper<MockModule, MockModuleTreeNode>.createModuleNodes(vararg names: String): List<Pair<MockModuleTreeNode, MockModule>> {
val nodes = createModuleNodes(names.map { MockModule(it) }, root, model)
checkConsistency { false }
return nodes.map { Pair(it, (it as MockModuleNode).module)}
}
private fun assertTreeEqual(expected: String) {
TreeUtil.expandAll(tree)
PlatformTestUtil.assertTreeEqual(tree, expected.trimIndent() + "\n")
}
private fun createHelper(enableGrouping: Boolean = true, compactGroupNodes: Boolean = true): ModuleGroupingTreeHelper<MockModule, MockModuleTreeNode> {
return ModuleGroupingTreeHelper.forEmptyTree(enableGrouping, MockModuleGrouping(compactGroupNodes), ::MockModuleGroupNode, ::MockModuleNode, nodeComparator)
}
private fun createHelperFromTree(enableGrouping: Boolean = true, compactGroupNodes: Boolean = true, nodeToBeMovedFilter: (MockModuleTreeNode) -> Boolean = {true}): ModuleGroupingTreeHelper<MockModule, MockModuleTreeNode> {
return ModuleGroupingTreeHelper.forTree(root, { it.moduleGroup }, { (it as? MockModuleNode)?.module },
enableGrouping, MockModuleGrouping(compactGroupNodes), ::MockModuleGroupNode, ::MockModuleNode, nodeComparator,
nodeToBeMovedFilter)
}
private fun ModuleGroupingTreeHelper<MockModule, MockModuleTreeNode>.checkConsistency(nodeToBeMovedFilter: (MockModuleTreeNode) -> Boolean) {
val expectedNodeForGroup = HashMap<ModuleGroup, MockModuleTreeNode>(getNodeForGroupMap())
val expectedNodeVirtualGroupToChildNode = HashMap<ModuleGroup, MockModuleTreeNode>(getVirtualGroupToChildNodeMap())
val expectedGroupByNode = HashMap<MockModuleTreeNode, ModuleGroup>(getGroupByNodeMap())
val expectedModuleByNode = HashMap<MockModuleTreeNode, MockModule>(getModuleByNodeMap())
TreeUtil.treeNodeTraverser(root).postOrderDfsTraversal().forEach { o ->
val node = o as MockModuleTreeNode
if (node == root) return@forEach
if (node is MockModuleNode) {
TestCase.assertEquals(node.module, expectedModuleByNode[node])
expectedModuleByNode.remove(node)
}
if (!nodeToBeMovedFilter(node)) {
val parentGroupPath = when (node) {
is MockModuleNode -> MockModuleGrouping().getGroupPath(node.module)
is MockModuleGroupNode -> node.moduleGroup.groupPath.dropLast(1)
else -> emptyList()
}
for (i in parentGroupPath.size downTo 1) {
val parentGroup = ModuleGroup(parentGroupPath.subList(0, i))
val childNode = expectedNodeVirtualGroupToChildNode.remove(parentGroup)
if (childNode != null) {
TestCase.assertEquals(childNode, node)
TestCase.assertNull("There are both virtual and real nodes for '${parentGroup.qualifiedName}' group",
expectedNodeForGroup[parentGroup])
}
else if (isGroupingEnabled()) {
TestCase.assertNotNull("There is no virtual or real node for '${parentGroup.qualifiedName}' group",
expectedNodeForGroup[parentGroup])
break
}
}
}
val moduleGroup = node.moduleGroup
TestCase.assertSame(node, expectedNodeForGroup[moduleGroup])
expectedNodeForGroup.remove(moduleGroup)
TestCase.assertEquals(moduleGroup, expectedGroupByNode[node])
expectedGroupByNode.remove(node)
}
assertEmpty("Unexpected nodes in helper", expectedNodeForGroup.entries)
assertEmpty("Unexpected groups in helper", expectedGroupByNode.entries)
assertEmpty("Unexpected modules in helper", expectedModuleByNode.entries)
if (TreeUtil.treeNodeTraverser(root).none { nodeToBeMovedFilter(it as MockModuleTreeNode) }) {
assertEmpty("Unexpected virtual groups in helper", expectedNodeVirtualGroupToChildNode.entries)
}
}
}
private val nodeComparator = Comparator.comparing { node: MockModuleTreeNode -> node.text }
private open class MockModuleTreeNode(userObject: Any, val text: String = userObject.toString()): DefaultMutableTreeNode(text) {
open val moduleGroup: ModuleGroup? = null
override fun toString() = text
}
private class MockModuleGrouping(override val compactGroupNodes: Boolean = true) : ModuleGroupingImplementation<MockModule> {
override fun getGroupPath(m: MockModule) = m.name.split('.').dropLast(1)
override fun getModuleAsGroupPath(m: MockModule) = m.name.split('.')
}
private class MockModule(var name: String)
private class MockModuleNode(val module: MockModule): MockModuleTreeNode(module, module.name) {
override val moduleGroup = ModuleGroup(MockModuleGrouping().getModuleAsGroupPath(module))
}
private class MockModuleGroupNode(override val moduleGroup: ModuleGroup): MockModuleTreeNode(moduleGroup) | platform/lang-impl/testSources/com/intellij/ide/projectView/ModuleGroupingTreeHelperTest.kt | 2833755828 |
// Copyright 2000-2021 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file.
package org.jetbrains.kotlin.idea.codeInsight
import com.intellij.openapi.util.NlsSafe
import org.jetbrains.kotlin.descriptors.CallableDescriptor
import org.jetbrains.kotlin.descriptors.ClassifierDescriptor
import org.jetbrains.kotlin.idea.KotlinBundle
import org.jetbrains.kotlin.idea.base.projectStructure.languageVersionSettings
import org.jetbrains.kotlin.idea.caches.resolve.analyze
import org.jetbrains.kotlin.idea.caches.resolve.findModuleDescriptor
import org.jetbrains.kotlin.idea.caches.resolve.getResolutionFacade
import org.jetbrains.kotlin.idea.parameterInfo.KotlinIdeDescriptorRenderer
import org.jetbrains.kotlin.idea.resolve.dataFlowValueFactory
import org.jetbrains.kotlin.psi.*
import org.jetbrains.kotlin.psi.psiUtil.parents
import org.jetbrains.kotlin.renderer.ClassifierNamePolicy
import org.jetbrains.kotlin.renderer.DescriptorRenderer
import org.jetbrains.kotlin.renderer.ParameterNameRenderingPolicy
import org.jetbrains.kotlin.renderer.RenderingFormat
import org.jetbrains.kotlin.resolve.BindingContext
import org.jetbrains.kotlin.resolve.DescriptorUtils
import org.jetbrains.kotlin.resolve.bindingContextUtil.isUsedAsExpression
import org.jetbrains.kotlin.resolve.calls.util.getParameterForArgument
import org.jetbrains.kotlin.resolve.calls.util.getResolvedCall
import org.jetbrains.kotlin.resolve.calls.util.getType
import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo
import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode
import org.jetbrains.kotlin.types.KotlinType
import org.jetbrains.kotlin.types.expressions.typeInfoFactory.noTypeInfo
class KotlinExpressionTypeProviderDescriptorsImpl : KotlinExpressionTypeProvider() {
private val typeRenderer = KotlinIdeDescriptorRenderer.withOptions {
textFormat = RenderingFormat.HTML
modifiers = emptySet()
parameterNameRenderingPolicy = ParameterNameRenderingPolicy.ONLY_NON_SYNTHESIZED
classifierNamePolicy = object : ClassifierNamePolicy {
override fun renderClassifier(classifier: ClassifierDescriptor, renderer: DescriptorRenderer): String {
if (DescriptorUtils.isAnonymousObject(classifier)) {
return "<" + KotlinBundle.message("type.provider.anonymous.object") + ">"
}
return ClassifierNamePolicy.SHORT.renderClassifier(classifier, renderer)
}
}
}
override fun KtExpression.shouldShowStatementType(): Boolean {
if (parent !is KtBlockExpression) return true
if (parent.children.lastOrNull() == this) {
return isUsedAsExpression(analyze(BodyResolveMode.PARTIAL_WITH_CFA))
}
return false
}
override fun getInformationHint(element: KtExpression): String {
val bindingContext = element.analyze(BodyResolveMode.PARTIAL)
return "<html>${renderExpressionType(element, bindingContext)}</html>"
}
@NlsSafe
private fun renderExpressionType(element: KtExpression, bindingContext: BindingContext): String {
if (element is KtCallableDeclaration) {
val descriptor = bindingContext[BindingContext.DECLARATION_TO_DESCRIPTOR, element] as? CallableDescriptor
if (descriptor != null) {
return descriptor.returnType?.let { typeRenderer.renderType(it) } ?: KotlinBundle.message("type.provider.unknown.type")
}
}
val expressionTypeInfo = bindingContext[BindingContext.EXPRESSION_TYPE_INFO, element] ?: noTypeInfo(DataFlowInfo.EMPTY)
val expressionType = element.getType(bindingContext) ?: getTypeForArgumentName(element, bindingContext)
val result = expressionType?.let { typeRenderer.renderType(it) } ?: return KotlinBundle.message("type.provider.unknown.type")
val dataFlowValueFactory = element.getResolutionFacade().dataFlowValueFactory
val dataFlowValue =
dataFlowValueFactory.createDataFlowValue(element, expressionType, bindingContext, element.findModuleDescriptor())
val types = expressionTypeInfo.dataFlowInfo.getStableTypes(dataFlowValue, element.languageVersionSettings)
if (types.isNotEmpty()) {
return types.joinToString(separator = " & ") { typeRenderer.renderType(it) } +
" " + KotlinBundle.message("type.provider.smart.cast.from", result)
}
val smartCast = bindingContext[BindingContext.SMARTCAST, element]
if (smartCast != null && element is KtReferenceExpression) {
val declaredType = (bindingContext[BindingContext.REFERENCE_TARGET, element] as? CallableDescriptor)?.returnType
if (declaredType != null) {
return result + " " + KotlinBundle.message("type.provider.smart.cast.from", typeRenderer.renderType(declaredType))
}
}
return result
}
private fun getTypeForArgumentName(element: KtExpression, bindingContext: BindingContext): KotlinType? {
val valueArgumentName = (element.parent as? KtValueArgumentName) ?: return null
val argument = valueArgumentName.parent as? KtValueArgument ?: return null
val ktCallExpression = argument.parents.filterIsInstance<KtCallExpression>().firstOrNull() ?: return null
val resolvedCall = ktCallExpression.getResolvedCall(bindingContext) ?: return null
val parameter = resolvedCall.getParameterForArgument(argument) ?: return null
return parameter.type
}
override fun getErrorHint(): String = KotlinBundle.message("type.provider.no.expression.found")
}
| plugins/kotlin/idea/src/org/jetbrains/kotlin/idea/codeInsight/KotlinExpressionTypeProviderDescriptorsImpl.kt | 1501944837 |
package com.simplemobiletools.commons.dialogs
import android.content.Context
import android.support.v7.app.AlertDialog
import android.view.LayoutInflater
import com.simplemobiletools.commons.R
import com.simplemobiletools.commons.extensions.setupDialogStuff
import kotlinx.android.synthetic.main.dialog_message.view.*
class ConfirmationAdvancedDialog(context: Context, message: String = "", messageId: Int = R.string.proceed_with_deletion, positive: Int = R.string.yes,
negative: Int, val callback: (result: Boolean) -> Unit) {
var dialog: AlertDialog
init {
val view = LayoutInflater.from(context).inflate(R.layout.dialog_message, null)
view.message.text = if (message.isEmpty()) context.resources.getString(messageId) else message
dialog = AlertDialog.Builder(context)
.setPositiveButton(positive, { dialog, which -> positivePressed() })
.setNegativeButton(negative, { dialog, which -> negativePressed() })
.create().apply {
context.setupDialogStuff(view, this)
}
}
private fun positivePressed() {
dialog.dismiss()
callback(true)
}
private fun negativePressed() {
dialog.dismiss()
callback(false)
}
}
| commons/src/main/kotlin/com/simplemobiletools/commons/dialogs/ConfirmationAdvancedDialog.kt | 4137174340 |
package charlie.laplacian.output.essential
import charlie.laplacian.output.*
import java.nio.charset.Charset
import java.util.*
import javax.sound.sampled.*
import javax.sound.sampled.FloatControl.Type.MASTER_GAIN
import kotlin.collections.plusAssign
import kotlin.experimental.and
class JavaSoundOutputMethod : OutputMethod {
override fun init() {}
override fun destroy() {}
override fun openDevice(outputSettings: OutputSettings): OutputDevice
= JavaSoundOutputDevice(outputSettings)
override fun getMetadata(): OutputMethodMetadata = JavaSoundMetadata
override fun getDeviceInfos(): Array<out OutputDeviceInfo> =
AudioSystem.getMixerInfo()
.map { JavaSoundOutputDeviceInfo(AudioSystem.getMixer(it)) }
.filter { it.getAvailableSettings().isNotEmpty() }
.toTypedArray()
}
class JavaSoundOutputDevice(outputSettings: OutputSettings): OutputDevice {
private var audioFormat: AudioFormat? = null
override fun openLine(): OutputLine {
return JavaSoundChannel(audioFormat!!)
}
override fun closeLine(channel: OutputLine) {
if (channel !is JavaSoundChannel) throw ClassCastException()
channel.pause()
channel.dataLine.drain()
channel.dataLine.close()
}
init {
AudioSystem.getMixerInfo()
audioFormat = AudioFormat(
outputSettings.sampleRateHz,
outputSettings.bitDepth,
outputSettings.numChannels,
true,
false)
}
}
class JavaSoundOutputDeviceInfo(private val mixer: Mixer): OutputDeviceInfo {
override fun getName(): String = javaSoundRecoverMessyCode(mixer.mixerInfo.name)
override fun getAvailableSettings(): Array<OutputSettings> =
mixer.sourceLineInfo
.map (AudioSystem::getLine)
.filter { it is SourceDataLine }
.flatMap { (it.lineInfo as DataLine.Info).formats.asIterable() }
.filter { !it.isBigEndian && it.encoding == AudioFormat.Encoding.PCM_SIGNED && it.sampleSizeInBits != 24 }
.map { OutputSettings(it.sampleRate, it.sampleSizeInBits, it.channels) }
.toTypedArray()
}
private val HIGH_IDENTIFY = 0b11000000.toByte()
fun javaSoundRecoverMessyCode(string: String): String {
return String(ArrayList<Byte>().apply buf@ {
string.toByteArray().apply {
var i = 0
while (i < this.size) {
if ((this[i] and HIGH_IDENTIFY) == HIGH_IDENTIFY) {
this@buf += (this[i].toInt() shl 6 or (this[i + 1].toInt() shl 2 ushr 2)).toByte()
i++
} else {
this@buf += this[i]
}
i++
}
}
}.toByteArray(), Charset.forName(System.getProperty("file.encoding")))
}
object JavaSoundMetadata: OutputMethodMetadata {
override fun getName(): String = "Java Sound"
override fun getVersion(): String = "rv1"
override fun getVersionID(): Int = 1
}
class JavaSoundChannel(audioFormat: AudioFormat) : OutputLine {
private val BUFFER_SIZE = 1024
internal val dataLine: SourceDataLine
private val dataLineInfo: DataLine.Info
private var volumeController: JavaSoundVolumeController
override fun mix(pcmData: ByteArray, offset: Int, length: Int) {
dataLine.write(pcmData, offset, length)
}
override fun getVolumeController(): VolumeController = volumeController
override fun setVolumeController(volumeController: VolumeController) {
if (volumeController is JavaSoundVolumeController)
this.volumeController = volumeController
else throw ClassCastException()
}
override fun open() {
dataLine.drain()
dataLine.start()
}
override fun pause() {
dataLine.stop()
}
init {
dataLineInfo = DataLine.Info(SourceDataLine::class.java, audioFormat, BUFFER_SIZE)
dataLine = AudioSystem.getLine(dataLineInfo) as SourceDataLine
dataLine.open(audioFormat)
volumeController = JavaSoundVolumeController()
//audioFormat.getProperty()
}
inner class JavaSoundVolumeController: VolumeController {
private val volumeControl: FloatControl = dataLine.getControl(MASTER_GAIN) as FloatControl
override fun max(): Float = volumeControl.maximum
override fun min(): Float = volumeControl.minimum
override fun current(): Float = volumeControl.value
override fun set(value: Float) {
volumeControl.value = value
}
}
}
| Laplacian.Essential.Desktop/src/main/kotlin/charlie/laplacian/output/essential/JavaSoundOutputMethod.kt | 3067236861 |
package li.ruoshi.nextday;
import android.app.Application;
import com.jakewharton.threetenabp.AndroidThreeTen
/**
* Created by ruoshili on 8/1/15.
*/
class NextDayApp : Application() {
companion object {
private lateinit var graph: ApplicationComponent
@JvmStatic fun getObjGraph(): ApplicationComponent = graph
}
override fun onCreate() {
super.onCreate()
AndroidThreeTen.init(this)
graph = DaggerApplicationComponent.builder().appModule(AppModule()).build()
}
}
| app/src/main/kotlin/li/ruoshi/nextday/NextDayApp.kt | 167243328 |
// Copyright 2000-2022 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file.
package org.jetbrains.kotlin.idea.compilerPlugin.kapt.gradleJava
import com.intellij.openapi.diagnostic.Logger
import com.intellij.openapi.externalSystem.model.DataNode
import com.intellij.openapi.externalSystem.model.ProjectKeys
import com.intellij.openapi.externalSystem.model.project.*
import com.intellij.openapi.util.Key
import org.gradle.tooling.model.idea.IdeaModule
import org.jetbrains.kotlin.idea.gradleTooling.model.kapt.KaptGradleModel
import org.jetbrains.kotlin.idea.gradleTooling.model.kapt.KaptModelBuilderService
import org.jetbrains.plugins.gradle.model.data.GradleSourceSetData
import org.jetbrains.plugins.gradle.service.project.AbstractProjectResolverExtension
import org.jetbrains.plugins.gradle.util.GradleConstants
@Suppress("unused")
class KaptProjectResolverExtension : AbstractProjectResolverExtension() {
private companion object {
private val LOG = Logger.getInstance(KaptProjectResolverExtension::class.java)
}
override fun getExtraProjectModelClasses(): Set<Class<KaptGradleModel>> {
val isAndroidPluginRequestingKotlinGradleModelKey = Key.findKeyByName("IS_ANDROID_PLUGIN_REQUESTING_KAPT_GRADLE_MODEL_KEY")
if (isAndroidPluginRequestingKotlinGradleModelKey != null && resolverCtx.getUserData(isAndroidPluginRequestingKotlinGradleModelKey) != null) {
return emptySet()
}
return setOf(KaptGradleModel::class.java)
}
override fun getToolingExtensionsClasses() = setOf(KaptModelBuilderService::class.java, Unit::class.java)
override fun populateModuleExtraModels(gradleModule: IdeaModule, ideModule: DataNode<ModuleData>) {
val kaptModel = resolverCtx.getExtraProject(gradleModule, KaptGradleModel::class.java)
if (kaptModel != null && kaptModel.isEnabled) {
for (sourceSet in kaptModel.sourceSets) {
val parentDataNode = ideModule.findParentForSourceSetDataNode(sourceSet.sourceSetName) ?: continue
fun addSourceSet(path: String, type: ExternalSystemSourceType) {
val contentRootData = ContentRootData(GradleConstants.SYSTEM_ID, path)
contentRootData.storePath(type, path)
parentDataNode.createChild(ProjectKeys.CONTENT_ROOT, contentRootData)
}
val sourceType =
if (sourceSet.isTest) ExternalSystemSourceType.TEST_GENERATED else ExternalSystemSourceType.SOURCE_GENERATED
sourceSet.generatedSourcesDirFile?.let { addSourceSet(it.absolutePath, sourceType) }
sourceSet.generatedKotlinSourcesDirFile?.let { addSourceSet(it.absolutePath, sourceType) }
sourceSet.generatedClassesDirFile?.let { generatedClassesDir ->
val libraryData = LibraryData(GradleConstants.SYSTEM_ID, "kaptGeneratedClasses")
val existingNode =
parentDataNode.children.map { (it.data as? LibraryDependencyData)?.target }
.firstOrNull { it?.externalName == libraryData.externalName }
if (existingNode != null) {
existingNode.addPath(LibraryPathType.BINARY, generatedClassesDir.absolutePath)
} else {
libraryData.addPath(LibraryPathType.BINARY, generatedClassesDir.absolutePath)
val libraryDependencyData = LibraryDependencyData(parentDataNode.data, libraryData, LibraryLevel.MODULE)
parentDataNode.createChild(ProjectKeys.LIBRARY_DEPENDENCY, libraryDependencyData)
}
}
}
}
super.populateModuleExtraModels(gradleModule, ideModule)
}
private fun DataNode<ModuleData>.findParentForSourceSetDataNode(sourceSetName: String): DataNode<ModuleData>? {
val moduleName = data.id
for (child in children) {
val gradleSourceSetData = child.data as? GradleSourceSetData ?: continue
if (gradleSourceSetData.id == "$moduleName:$sourceSetName") {
@Suppress("UNCHECKED_CAST")
return child as? DataNode<ModuleData>
}
}
return this
}
}
| plugins/kotlin/compiler-plugins/kapt/src/org/jetbrains/kotlin/idea/compilerPlugin/kapt/gradleJava/KaptProjectResolverExtension.kt | 1236049851 |
import java.awt.Color
class UseGrayConstantFixInLocalVariable {
fun any() {
@Suppress("UNUSED_VARIABLE")
val myGray = <warning descr="'java.awt.Color' used for gray">Co<caret>lor(25, 25, 25)</warning>
}
}
| plugins/devkit/devkit-kotlin-tests/testData/inspections/useGrayFix/UseGrayConstantFixInLocalVariable.kt | 2187523107 |
// Copyright 2000-2022 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file.
package org.jetbrains.kotlin.psi.patternMatching
import com.intellij.openapi.util.TextRange
import com.intellij.testFramework.LightProjectDescriptor
import org.jetbrains.kotlin.idea.base.psi.unifier.toRange
import org.jetbrains.kotlin.idea.test.DirectiveBasedActionUtils
import org.jetbrains.kotlin.idea.test.KotlinLightCodeInsightFixtureTestCase
import org.jetbrains.kotlin.idea.util.psi.patternMatching.KotlinPsiUnifier
import org.jetbrains.kotlin.idea.util.psi.patternMatching.match
import org.jetbrains.kotlin.psi.*
import org.jetbrains.kotlin.psi.psiUtil.parentsWithSelf
import org.jetbrains.kotlin.idea.test.KotlinTestUtils
import java.io.File
abstract class AbstractPsiUnifierTest : KotlinLightCodeInsightFixtureTestCase() {
fun doTest(unused: String) {
fun findPattern(file: KtFile): KtElement {
val selectionModel = myFixture.editor.selectionModel
val start = selectionModel.selectionStart
val end = selectionModel.selectionEnd
val selectionRange = TextRange(start, end)
return file.findElementAt(start)?.parentsWithSelf?.last {
(it is KtExpression || it is KtTypeReference || it is KtWhenCondition)
&& selectionRange.contains(it.textRange ?: TextRange.EMPTY_RANGE)
} as KtElement
}
val file = myFixture.configureByFile(fileName()) as KtFile
DirectiveBasedActionUtils.checkForUnexpectedErrors(file)
val actualText =
findPattern(file).toRange().match(file, KotlinPsiUnifier.DEFAULT).map { it.range.textRange.substring(file.getText()!!) }
.joinToString("\n\n")
KotlinTestUtils.assertEqualsToFile(File(testDataPath, "${fileName()}.match"), actualText)
}
override fun getProjectDescriptor(): LightProjectDescriptor = getProjectDescriptorFromTestName()
}
| plugins/kotlin/idea/tests/test/org/jetbrains/kotlin/psi/patternMatching/AbstractPsiUnifierTest.kt | 805028508 |
package com.onyx.persistence.annotations
/**
* This annotation is used to indicate an attribute within a ManagedEntity
*
* Currently supported attribute types include (Long, long, Integer, int, Double, double, Float, float, String)
*
* @author Tim Osborn
*
* @since 1.0.0
*
* <pre>
* `
* @Entity
* public class Person extends ManagedEntity
* {
* @Attribute(nullable = false, size = 200)
* public String firstNameAttribute;
* }
*
* </pre>
*/
@Target(AnnotationTarget.FIELD)
annotation class Attribute(
/**
* Determines whether the attribute is nullable
*
* @since 1.0.0
* @return Boolean key indicating nullable or not
*/
val nullable: Boolean = true,
/**
* Size of an attribute. Only applies if the attribute is type string
*
* @since 1.0.0
* @return Attribute max size
*/
val size: Int = -1)
| onyx-database/src/main/kotlin/com/onyx/persistence/annotations/Attribute.kt | 447221730 |
// Copyright 2000-2022 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license.
package org.jetbrains.plugins.groovy.dgm
import com.intellij.openapi.components.service
import com.intellij.util.asSafely
import com.intellij.workspaceModel.ide.WorkspaceModelChangeListener
import com.intellij.workspaceModel.ide.impl.legacyBridge.module.ModuleManagerBridgeImpl.Companion.moduleMap
import com.intellij.workspaceModel.storage.EntityChange
import com.intellij.workspaceModel.storage.VersionedStorageChange
import com.intellij.workspaceModel.storage.bridgeEntities.ModuleEntity
import org.jetbrains.plugins.groovy.transformations.macro.GroovyMacroRegistryService
class GroovyMacroModuleListener : WorkspaceModelChangeListener {
override fun changed(event: VersionedStorageChange) {
val moduleChanges = event.getChanges(ModuleEntity::class.java)
if (moduleChanges.isEmpty()) {
return
}
for (moduleEntity in moduleChanges) {
val entityToFlush = moduleEntity.oldEntity ?: continue
val bridge = event.storageBefore.moduleMap.getDataByEntity(entityToFlush) ?: continue
bridge.project.service<GroovyMacroRegistryService>().asSafely<GroovyMacroRegistryServiceImpl>()?.refreshModule(bridge)
}
}
} | plugins/groovy/src/org/jetbrains/plugins/groovy/dgm/GroovyMacroModuleListener.kt | 3339512741 |
// Copyright 2000-2022 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license.
package org.jetbrains.plugins.gradle.util
import org.gradle.util.GradleVersion
import org.junit.jupiter.api.Assertions.*
import org.junit.jupiter.api.Test
class GradleJvmSupportMatricesTest : GradleJvmSupportMatricesTestCase() {
@Test
fun `test compatibility between gradle and java versions`() {
assertTrue(isSupported("2.0", 6))
assertTrue(isSupported("4.0", 6))
assertFalse(isSupported("5.0", 6))
assertTrue(isSupported("2.0", 7))
assertTrue(isSupported("4.0", 7))
assertTrue(isSupported("4.9", 7))
assertFalse(isSupported("5.0", 7))
assertTrue(isSupported("0.9.2", 8))
assertTrue(isSupported("3.0", 8))
assertTrue(isSupported("4.0", 8))
assertFalse(isSupported("5.1", 8))
assertFalse(isSupported("5.4.1", 8))
assertFalse(isSupported("6.0", 8))
assertFalse(isSupported("7.1", 8))
assertTrue(isSupported("7.2", 8))
assertTrue(isSupported("7.5", 8))
assertFalse(isSupported("4.8", 11))
assertTrue(isSupported("5.0", 11))
assertTrue(isSupported("5.4.1", 11))
assertTrue(isSupported("7.5", 11))
assertFalse(isSupported("7.1", 17))
assertTrue(isSupported("7.2", 17))
assertTrue(isSupported("7.3", 17))
assertTrue(isSupported("7.5", 17))
assertFalse(isSupported("7.4", 18))
assertTrue(isSupported("7.5", 18))
assertTrue(isSupported("7.5.1", 18))
assertFalse(isSupported("7.5", 19))
assertFalse(isSupported("7.5.1", 19))
assertTrue(isSupported("7.6", 19))
}
@Test
fun `test suggesting gradle version for java version`() {
val bundledGradleVersion = GradleVersion.current()
require(bundledGradleVersion >= GradleVersion.version("7.1"))
assertEquals("4.10.3", suggestGradleVersion(6))
assertEquals("4.10.3", suggestGradleVersion(7))
assertEquals(bundledGradleVersion.version, suggestGradleVersion(8))
assertEquals(bundledGradleVersion.version, suggestGradleVersion(11))
assertEquals(bundledGradleVersion.version, suggestGradleVersion(15))
assertEquals(bundledGradleVersion.version, suggestGradleVersion(17))
assertEquals(bundledGradleVersion.version, suggestGradleVersion(18))
//assertEquals(bundledGradleVersion.version, suggestGradleVersion(19))
}
@Test
fun `test suggesting java version for gradle version`() {
assertEquals(8, suggestJavaVersion("0.9.2"))
assertEquals(8, suggestJavaVersion("2.0"))
assertEquals(8, suggestJavaVersion("3.0"))
assertEquals(9, suggestJavaVersion("4.3"))
assertEquals(10, suggestJavaVersion("4.7"))
assertEquals(11, suggestJavaVersion("5.0"))
assertEquals(11, suggestJavaVersion("5.1"))
assertEquals(12, suggestJavaVersion("5.4"))
assertEquals(13, suggestJavaVersion("6.0"))
assertEquals(14, suggestJavaVersion("6.3"))
assertEquals(15, suggestJavaVersion("6.7"))
assertEquals(16, suggestJavaVersion("7.1"))
assertEquals(17, suggestJavaVersion("7.2"))
assertEquals(17, suggestJavaVersion("7.4"))
assertEquals(18, suggestJavaVersion("7.5"))
assertEquals(18, suggestJavaVersion("7.5.1"))
assertEquals(19, suggestJavaVersion("7.6"))
}
@Test
fun `test suggesting oldest compatible gradle version for java version`() {
assertEquals("3.0", suggestOldestCompatibleGradleVersion(6))
assertEquals("3.0", suggestOldestCompatibleGradleVersion(7))
assertEquals("3.0", suggestOldestCompatibleGradleVersion(8))
assertEquals("4.3", suggestOldestCompatibleGradleVersion(9))
assertEquals("4.7", suggestOldestCompatibleGradleVersion(10))
assertEquals("5.0", suggestOldestCompatibleGradleVersion(11))
assertEquals("5.4", suggestOldestCompatibleGradleVersion(12))
assertEquals("6.0", suggestOldestCompatibleGradleVersion(13))
assertEquals("6.3", suggestOldestCompatibleGradleVersion(14))
assertEquals("6.7", suggestOldestCompatibleGradleVersion(15))
assertEquals("7.0", suggestOldestCompatibleGradleVersion(16))
assertEquals("7.2", suggestOldestCompatibleGradleVersion(17))
assertEquals("7.5", suggestOldestCompatibleGradleVersion(18))
//assertEquals("7.6", suggestOldestCompatibleGradleVersion(19))
//assertEquals("7.6", suggestOldestCompatibleGradleVersion(24))
}
@Test
fun `test suggesting oldest compatible java version for gradle version`() {
assertEquals(7, suggestOldestCompatibleJavaVersion("2.0"))
assertEquals(7, suggestOldestCompatibleJavaVersion("3.0"))
assertEquals(8, suggestOldestCompatibleJavaVersion("5.0"))
assertEquals(9, suggestOldestCompatibleJavaVersion("5.1"))
assertEquals(9, suggestOldestCompatibleJavaVersion("7.1"))
assertEquals(8, suggestOldestCompatibleJavaVersion("7.2"))
assertEquals(8, suggestOldestCompatibleJavaVersion("7.5"))
assertEquals(8, suggestOldestCompatibleJavaVersion("7.6"))
}
} | plugins/gradle/testSources/org/jetbrains/plugins/gradle/util/GradleJvmSupportMatricesTest.kt | 2229791039 |
// Copyright 2000-2022 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license.
package org.jetbrains.kotlin.idea.base.fir.analysisApiProviders
import com.intellij.openapi.module.Module
import com.intellij.openapi.project.Project
import com.intellij.openapi.util.ModificationTracker
import com.intellij.openapi.util.SimpleModificationTracker
import org.jetbrains.annotations.TestOnly
import org.jetbrains.kotlin.analysis.project.structure.KtModule
import org.jetbrains.kotlin.analysis.project.structure.KtSourceModule
import org.jetbrains.kotlin.analysis.providers.KotlinModificationTrackerFactory
import org.jetbrains.kotlin.analysis.providers.KtModuleStateTracker
import org.jetbrains.kotlin.idea.base.analysisApiProviders.KotlinModuleStateTrackerProvider
import org.jetbrains.kotlin.idea.base.projectStructure.ideaModule
import org.jetbrains.kotlin.idea.caches.project.LibraryModificationTracker
internal class FirIdeKotlinModificationTrackerFactory(private val project: Project) : KotlinModificationTrackerFactory() {
override fun createProjectWideOutOfBlockModificationTracker(): ModificationTracker {
return KotlinFirOutOfBlockModificationTracker(project)
}
override fun createModuleWithoutDependenciesOutOfBlockModificationTracker(module: KtSourceModule): ModificationTracker {
return KotlinFirOutOfBlockModuleModificationTracker(module.ideaModule)
}
override fun createLibrariesWideModificationTracker(): ModificationTracker {
return LibraryModificationTracker.getInstance(project)
}
override fun createModuleStateTracker(module: KtModule): KtModuleStateTracker {
return KotlinModuleStateTrackerProvider.getInstance(project).getModuleStateTrackerFor(module)
}
@TestOnly
override fun incrementModificationsCount() {
(createLibrariesWideModificationTracker() as SimpleModificationTracker).incModificationCount()
project.getService(FirIdeModificationTrackerService::class.java).increaseModificationCountForAllModules()
KotlinModuleStateTrackerProvider.getInstance(project).incrementModificationCountForAllModules()
}
}
private class KotlinFirOutOfBlockModificationTracker(project: Project) : ModificationTracker {
private val trackerService = project.getService(FirIdeModificationTrackerService::class.java)
override fun getModificationCount(): Long {
return trackerService.projectGlobalOutOfBlockInKotlinFilesModificationCount
}
}
private class KotlinFirOutOfBlockModuleModificationTracker(private val module: Module) : ModificationTracker {
private val trackerService = module.project.getService(FirIdeModificationTrackerService::class.java)
override fun getModificationCount(): Long {
return trackerService.getOutOfBlockModificationCountForModules(module)
}
} | plugins/kotlin/base/fir/analysis-api-providers/src/org/jetbrains/kotlin/idea/base/fir/analysisApiProviders/FirIdeKotlinModificationTrackerFactory.kt | 454068824 |
// Copyright 2000-2022 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license.
package org.jetbrains.kotlin.idea.base.indices.names
import org.jetbrains.kotlin.load.kotlin.KotlinJvmBinaryClass
import org.jetbrains.kotlin.metadata.ProtoBuf
import org.jetbrains.kotlin.metadata.jvm.deserialization.JvmNameResolver
import org.jetbrains.kotlin.metadata.jvm.deserialization.JvmProtoBufUtil
internal fun readProtoPackageData(kotlinJvmBinaryClass: KotlinJvmBinaryClass): Pair<JvmNameResolver, ProtoBuf.Package>? {
val header = kotlinJvmBinaryClass.classHeader
val data = header.data ?: header.incompatibleData ?: return null
val strings = header.strings ?: return null
return JvmProtoBufUtil.readPackageDataFrom(data, strings)
} | plugins/kotlin/base/indices/src/org/jetbrains/kotlin/idea/base/indices/names/internalUtils.kt | 3972580122 |
// Copyright 2000-2021 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file.
package org.jetbrains.kotlin.idea.configuration
import com.intellij.ide.plugins.PluginManagerCore
import com.intellij.ide.util.PropertiesComponent
import com.intellij.notification.Notification
import com.intellij.notification.NotificationAction
import com.intellij.notification.NotificationType
import com.intellij.openapi.actionSystem.AnActionEvent
import com.intellij.openapi.extensions.PluginId
import com.intellij.openapi.project.ProjectManager
import com.intellij.openapi.updateSettings.impl.pluginsAdvertisement.installAndEnable
import com.intellij.openapi.updateSettings.impl.pluginsAdvertisement.notificationGroup
import com.intellij.util.PlatformUtils
import org.jetbrains.annotations.NotNull
import org.jetbrains.kotlin.idea.KotlinIdeaGradleBundle
private var isNativeDebugSuggestionEnabled
get() =
PropertiesComponent.getInstance().getBoolean("isNativeDebugSuggestionEnabled", true)
set(value) {
PropertiesComponent.getInstance().setValue("isNativeDebugSuggestionEnabled", value)
}
fun suggestNativeDebug(projectPath: String) {
if (!PlatformUtils.isIdeaUltimate()) return
val pluginId = PluginId.getId("com.intellij.nativeDebug")
if (PluginManagerCore.isPluginInstalled(pluginId)) return
if (!isNativeDebugSuggestionEnabled) return
val projectManager = ProjectManager.getInstance()
val project = projectManager.openProjects.firstOrNull { it.basePath == projectPath } ?: return
notificationGroup
.createNotification(KotlinIdeaGradleBundle.message("notification.title.plugin.suggestion"), KotlinIdeaGradleBundle.message("notification.text.native.debug.provides.debugger.for.kotlin.native"), NotificationType.INFORMATION)
.addAction(object : NotificationAction(KotlinIdeaGradleBundle.message("action.text.install")) {
override fun actionPerformed(e: AnActionEvent, notification: Notification) {
installAndEnable(project, setOf<@NotNull PluginId>(pluginId)) { notification.expire() }
}
})
.addAction(object : NotificationAction(KotlinIdeaGradleBundle.message("action.text.dontShowAgain")) {
override fun actionPerformed(e: AnActionEvent, notification: Notification) {
isNativeDebugSuggestionEnabled = false
notification.expire()
}
})
.notify(project)
}
| plugins/kotlin/gradle/gradle-idea/src/org/jetbrains/kotlin/idea/configuration/kotlinResolverUtil.kt | 2640559480 |
// Copyright 2000-2022 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license.
package com.intellij.openapi.keymap.impl
import com.intellij.configurationStore.SchemeDataHolder
import com.intellij.configurationStore.SerializableScheme
import com.intellij.ide.IdeBundle
import com.intellij.ide.plugins.PluginManagerConfigurable
import com.intellij.internal.statistic.collectors.fus.actions.persistence.ActionsCollectorImpl
import com.intellij.notification.Notification
import com.intellij.notification.NotificationAction
import com.intellij.notification.NotificationType
import com.intellij.openapi.actionSystem.*
import com.intellij.openapi.actionSystem.ex.ActionManagerEx
import com.intellij.openapi.application.ApplicationManager
import com.intellij.openapi.application.ModalityState
import com.intellij.openapi.diagnostic.logger
import com.intellij.openapi.extensions.PluginId
import com.intellij.openapi.keymap.Keymap
import com.intellij.openapi.keymap.KeymapManagerListener
import com.intellij.openapi.keymap.KeymapUtil
import com.intellij.openapi.keymap.ex.KeymapManagerEx
import com.intellij.openapi.options.ExternalizableSchemeAdapter
import com.intellij.openapi.options.SchemeState
import com.intellij.openapi.options.ShowSettingsUtil
import com.intellij.openapi.project.Project
import com.intellij.openapi.project.ProjectManager
import com.intellij.openapi.project.ProjectManagerListener
import com.intellij.openapi.updateSettings.impl.pluginsAdvertisement.installAndEnable
import com.intellij.openapi.util.InvalidDataException
import com.intellij.openapi.util.NlsContexts
import com.intellij.openapi.util.SystemInfo
import com.intellij.ui.KeyStrokeAdapter
import com.intellij.util.ArrayUtilRt
import com.intellij.util.SmartList
import com.intellij.util.containers.ContainerUtil
import com.intellij.util.containers.mapSmart
import com.intellij.util.containers.nullize
import org.jdom.Element
import java.util.*
import javax.swing.KeyStroke
import kotlin.properties.ReadWriteProperty
import kotlin.reflect.KProperty
private const val KEY_MAP = "keymap"
private const val KEYBOARD_SHORTCUT = "keyboard-shortcut"
private const val KEYBOARD_GESTURE_SHORTCUT = "keyboard-gesture-shortcut"
private const val KEYBOARD_GESTURE_KEY = "keystroke"
private const val KEYBOARD_GESTURE_MODIFIER = "modifier"
private const val KEYSTROKE_ATTRIBUTE = "keystroke"
private const val FIRST_KEYSTROKE_ATTRIBUTE = "first-keystroke"
private const val SECOND_KEYSTROKE_ATTRIBUTE = "second-keystroke"
private const val ACTION = "action"
private const val VERSION_ATTRIBUTE = "version"
private const val PARENT_ATTRIBUTE = "parent"
private const val NAME_ATTRIBUTE = "name"
private const val ID_ATTRIBUTE = "id"
private const val MOUSE_SHORTCUT = "mouse-shortcut"
fun KeymapImpl(name: String, dataHolder: SchemeDataHolder<KeymapImpl>): KeymapImpl {
val result = KeymapImpl(dataHolder)
result.name = name
result.schemeState = SchemeState.UNCHANGED
return result
}
open class KeymapImpl @JvmOverloads constructor(private var dataHolder: SchemeDataHolder<KeymapImpl>? = null)
: ExternalizableSchemeAdapter(), Keymap, SerializableScheme {
private var parent: KeymapImpl? = null
private var unknownParentName: String? = null
open var canModify: Boolean = true
@JvmField
internal var schemeState: SchemeState? = null
override fun getSchemeState(): SchemeState? = schemeState
private val actionIdToShortcuts = HashMap<String, MutableList<Shortcut>>()
get() {
val dataHolder = dataHolder
if (dataHolder != null) {
this.dataHolder = null
readExternal(dataHolder.read())
}
return field
}
private val keymapManager by lazy { KeymapManagerEx.getInstanceEx()!! }
/**
* @return IDs of the action which are specified in the keymap. It doesn't return IDs of action from parent keymap.
*/
val ownActionIds: Array<String>
get() = actionIdToShortcuts.keys.toTypedArray()
private fun <T> cachedShortcuts(mapper: (Shortcut) -> T?): ReadWriteProperty<Any?, Map<T, MutableList<String>>> =
object : ReadWriteProperty<Any?, Map<T, MutableList<String>>> {
private var cache: Map<T, MutableList<String>>? = null
override fun getValue(thisRef: Any?, property: KProperty<*>): Map<T, MutableList<String>> =
cache ?: mapShortcuts(mapper).also { cache = it }
override fun setValue(thisRef: Any?, property: KProperty<*>, value: Map<T, MutableList<String>>) {
cache = null
}
private fun mapShortcuts(mapper: (Shortcut) -> T?): Map<T, MutableList<String>> {
fun addActionToShortcutMap(actionId: String, map: MutableMap<T, MutableList<String>>) {
for (shortcut in getOwnOrBoundShortcuts(actionId)) {
mapper(shortcut)?.let {
val ids = map.getOrPut(it) { SmartList() }
if (!ids.contains(actionId)) {
ids.add(actionId)
}
}
}
}
val map = HashMap<T, MutableList<String>>()
actionIdToShortcuts.keys.forEach { addActionToShortcutMap(it, map) }
keymapManager.boundActions.forEach { addActionToShortcutMap(it, map) }
return map
}
}
private var keystrokeToActionIds: Map<KeyStroke, MutableList<String>> by cachedShortcuts { (it as? KeyboardShortcut)?.firstKeyStroke }
private var mouseShortcutToActionIds: Map<MouseShortcut, MutableList<String>> by cachedShortcuts { it as? MouseShortcut }
private var gestureToActionIds: Map<KeyboardModifierGestureShortcut, MutableList<String>> by cachedShortcuts { it as? KeyboardModifierGestureShortcut }
override fun getPresentableName(): String = name
override fun deriveKeymap(newName: String): KeymapImpl =
if (canModify()) {
val newKeymap = copy()
newKeymap.name = newName
newKeymap
}
else {
val newKeymap = KeymapImpl()
newKeymap.parent = this
newKeymap.name = newName
newKeymap
}
fun copy(): KeymapImpl =
dataHolder?.let { KeymapImpl(name, it) }
?: copyTo(KeymapImpl())
fun copyTo(otherKeymap: KeymapImpl): KeymapImpl {
otherKeymap.cleanShortcutsCache()
otherKeymap.actionIdToShortcuts.clear()
for (entry in actionIdToShortcuts.entries) {
otherKeymap.actionIdToShortcuts[entry.key] = ContainerUtil.copyList(entry.value)
}
// after actionIdToShortcuts (on first access we lazily read itself)
otherKeymap.parent = parent
otherKeymap.name = name
otherKeymap.canModify = canModify()
return otherKeymap
}
override fun getParent(): KeymapImpl? = parent
final override fun canModify(): Boolean = canModify
override fun addShortcut(actionId: String, shortcut: Shortcut) {
val list = actionIdToShortcuts.getOrPut(actionId) {
val result = SmartList<Shortcut>()
val boundShortcuts = keymapManager.getActionBinding(actionId)?.let { actionIdToShortcuts[it] }
if (boundShortcuts != null) {
result.addAll(boundShortcuts)
}
else {
parent?.getMutableShortcutList(actionId)?.mapTo(result) { convertShortcut(it) }
}
result
}
if (!list.contains(shortcut)) {
list.add(shortcut)
}
if (list.areShortcutsEqualToParent(actionId)) {
actionIdToShortcuts.remove(actionId)
}
cleanShortcutsCache()
fireShortcutChanged(actionId)
}
private fun cleanShortcutsCache() {
keystrokeToActionIds = emptyMap()
mouseShortcutToActionIds = emptyMap()
gestureToActionIds = emptyMap()
schemeState = SchemeState.POSSIBLY_CHANGED
}
override fun removeAllActionShortcuts(actionId: String) {
for (shortcut in getShortcuts(actionId)) {
removeShortcut(actionId, shortcut)
}
}
override fun removeShortcut(actionId: String, toDelete: Shortcut) {
val list = actionIdToShortcuts[actionId]
if (list == null) {
val inherited = keymapManager.getActionBinding(actionId)?.let { actionIdToShortcuts[it] }
?: parent?.getMutableShortcutList(actionId)?.mapSmart { convertShortcut(it) }.nullize()
if (inherited != null) {
var newShortcuts: MutableList<Shortcut>? = null
for (itemIndex in 0..inherited.lastIndex) {
val item = inherited[itemIndex]
if (toDelete == item) {
if (newShortcuts == null) {
newShortcuts = SmartList()
for (notAddedItemIndex in 0 until itemIndex) {
newShortcuts.add(inherited[notAddedItemIndex])
}
}
}
else newShortcuts?.add(item)
}
newShortcuts?.let {
actionIdToShortcuts.put(actionId, it)
}
}
}
else {
val index = list.indexOf(toDelete)
if (index >= 0) {
if (parent == null) {
if (list.size == 1) {
actionIdToShortcuts.remove(actionId)
}
else {
list.removeAt(index)
}
}
else {
list.removeAt(index)
if (list.areShortcutsEqualToParent(actionId)) {
actionIdToShortcuts.remove(actionId)
}
}
}
}
cleanShortcutsCache()
fireShortcutChanged(actionId)
}
private fun MutableList<Shortcut>.areShortcutsEqualToParent(actionId: String) =
parent.let { parent -> parent != null && areShortcutsEqual(this, parent.getMutableShortcutList(actionId).mapSmart { convertShortcut(it) }) }
private fun getOwnOrBoundShortcuts(actionId: String): List<Shortcut> {
actionIdToShortcuts[actionId]?.let {
return it
}
val result = SmartList<Shortcut>()
keymapManager.getActionBinding(actionId)?.let {
result.addAll(getOwnOrBoundShortcuts(it))
}
return result
}
private fun getActionIds(shortcut: KeyboardModifierGestureShortcut): List<String> {
// first, get keystrokes from our own map
val list = SmartList<String>()
for ((key, value) in gestureToActionIds) {
if (shortcut.startsWith(key)) {
list.addAll(value)
}
}
if (parent != null) {
val ids = parent!!.getActionIds(shortcut)
if (ids.isNotEmpty()) {
for (id in ids) {
// add actions from the parent keymap only if they are absent in this keymap
if (!actionIdToShortcuts.containsKey(id)) {
list.add(id)
}
}
}
}
sortInRegistrationOrder(list)
return list
}
override fun getActionIds(firstKeyStroke: KeyStroke): Array<String> {
return ArrayUtilRt.toStringArray(getActionIds(firstKeyStroke, { it.keystrokeToActionIds }, KeymapImpl::convertKeyStroke))
}
override fun getActionIds(firstKeyStroke: KeyStroke, secondKeyStroke: KeyStroke?): Array<String> {
val ids = getActionIds(firstKeyStroke)
var actualBindings: MutableList<String>? = null
for (id in ids) {
val shortcuts = getShortcuts(id)
for (shortcut in shortcuts) {
if (shortcut !is KeyboardShortcut) {
continue
}
if (firstKeyStroke == shortcut.firstKeyStroke && secondKeyStroke == shortcut.secondKeyStroke) {
if (actualBindings == null) {
actualBindings = SmartList()
}
actualBindings.add(id)
break
}
}
}
return ArrayUtilRt.toStringArray(actualBindings)
}
override fun getActionIds(shortcut: Shortcut): Array<String> {
return when (shortcut) {
is KeyboardShortcut -> {
val first = shortcut.firstKeyStroke
val second = shortcut.secondKeyStroke
if (second == null) getActionIds(first) else getActionIds(first, second)
}
is MouseShortcut -> ArrayUtilRt.toStringArray(getActionIds(shortcut))
is KeyboardModifierGestureShortcut -> ArrayUtilRt.toStringArray(getActionIds(shortcut))
else -> ArrayUtilRt.EMPTY_STRING_ARRAY
}
}
override fun hasActionId(actionId: String, shortcut: MouseShortcut): Boolean {
var convertedShortcut = shortcut
var keymap = this
do {
val list = keymap.mouseShortcutToActionIds[convertedShortcut]
if (list != null && list.contains(actionId)) {
return true
}
val parent = keymap.parent ?: return false
convertedShortcut = keymap.convertMouseShortcut(shortcut)
keymap = parent
}
while (true)
}
override fun getActionIds(shortcut: MouseShortcut): List<String> {
return getActionIds(shortcut, { it.mouseShortcutToActionIds }, KeymapImpl::convertMouseShortcut)
}
private fun <T> getActionIds(shortcut: T,
shortcutToActionIds: (keymap: KeymapImpl) -> Map<T, MutableList<String>>,
convertShortcut: (keymap: KeymapImpl, shortcut: T) -> T): List<String> {
// first, get keystrokes from our own map
var list = shortcutToActionIds(this)[shortcut]
val parentIds = parent?.getActionIds(convertShortcut(this, shortcut), shortcutToActionIds, convertShortcut) ?: emptyList()
var isOriginalListInstance = list != null
for (id in parentIds) {
// add actions from the parent keymap only if they are absent in this keymap
// do not add parent bind actions, if bind-on action is overwritten in the child
if (actionIdToShortcuts.containsKey(id) || actionIdToShortcuts.containsKey(keymapManager.getActionBinding(id))) {
continue
}
if (list == null) {
list = SmartList()
}
else if (isOriginalListInstance) {
list = SmartList(list)
isOriginalListInstance = false
}
if (!list.contains(id)) {
list.add(id)
}
}
sortInRegistrationOrder(list ?: return emptyList())
return list
}
fun isActionBound(actionId: String): Boolean = keymapManager.boundActions.contains(actionId)
override fun getShortcuts(actionId: String?): Array<Shortcut> =
getMutableShortcutList(actionId).let { if (it.isEmpty()) Shortcut.EMPTY_ARRAY else it.toTypedArray() }
private fun getMutableShortcutList(actionId: String?): List<Shortcut> {
if (actionId == null) {
return emptyList()
}
// it is critical to use convertShortcut - otherwise MacOSDefaultKeymap doesn't convert shortcuts
// todo why not convert on add? why we don't need to convert our own shortcuts?
return actionIdToShortcuts[actionId]
?: keymapManager.getActionBinding(actionId)?.let { actionIdToShortcuts[it] }
?: parent?.getMutableShortcutList(actionId)?.mapSmart { convertShortcut(it) }
?: emptyList()
}
fun getOwnShortcuts(actionId: String): Array<Shortcut> {
val own = actionIdToShortcuts[actionId] ?: return Shortcut.EMPTY_ARRAY
return if (own.isEmpty()) Shortcut.EMPTY_ARRAY else own.toTypedArray()
}
fun hasShortcutDefined(actionId: String): Boolean =
actionIdToShortcuts[actionId] != null || parent?.hasShortcutDefined(actionId) == true
// you must clear `actionIdToShortcuts` before calling
protected open fun readExternal(keymapElement: Element) {
if (KEY_MAP != keymapElement.name) {
throw InvalidDataException("unknown element: $keymapElement")
}
name = keymapElement.getAttributeValue(NAME_ATTRIBUTE)!!
unknownParentName = null
keymapElement.getAttributeValue(PARENT_ATTRIBUTE)?.let { parentSchemeName ->
var parentScheme = findParentScheme(parentSchemeName)
if (parentScheme == null && parentSchemeName == "Default for Mac OS X") {
// https://youtrack.jetbrains.com/issue/RUBY-17767#comment=27-1374197
parentScheme = findParentScheme("Mac OS X")
}
if (parentScheme == null) {
logger<KeymapImpl>().warn("Cannot find parent scheme $parentSchemeName for scheme $name")
unknownParentName = parentSchemeName
notifyAboutMissingKeymap(parentSchemeName, IdeBundle.message("notification.content.cannot.find.parent.keymap", parentSchemeName, name), true)
}
else {
parent = parentScheme as KeymapImpl
canModify = true
}
}
val actionIds = HashSet<String>()
val skipInserts = SystemInfo.isMac && (ApplicationManager.getApplication() == null || !ApplicationManager.getApplication().isUnitTestMode)
for (actionElement in keymapElement.children) {
if (actionElement.name != ACTION) {
throw InvalidDataException("unknown element: $actionElement; Keymap's name=$name")
}
val id = actionElement.getAttributeValue(ID_ATTRIBUTE) ?: throw InvalidDataException("Attribute 'id' cannot be null; Keymap's name=$name")
actionIds.add(id)
val shortcuts = SmartList<Shortcut>()
// creating the list even when there are no shortcuts (empty element means that an action overrides a parent one to clear shortcuts)
actionIdToShortcuts[id] = shortcuts
for (shortcutElement in actionElement.children) {
if (KEYBOARD_SHORTCUT == shortcutElement.name) {
// Parse first keystroke
val firstKeyStrokeStr = shortcutElement.getAttributeValue(FIRST_KEYSTROKE_ATTRIBUTE)
?: throw InvalidDataException("Attribute '$FIRST_KEYSTROKE_ATTRIBUTE' cannot be null; Action's id=$id; Keymap's name=$name")
if (skipInserts && firstKeyStrokeStr.contains("INSERT")) {
continue
}
val firstKeyStroke = KeyStrokeAdapter.getKeyStroke(firstKeyStrokeStr) ?: continue
// Parse second keystroke
var secondKeyStroke: KeyStroke? = null
val secondKeyStrokeStr = shortcutElement.getAttributeValue(SECOND_KEYSTROKE_ATTRIBUTE)
if (secondKeyStrokeStr != null) {
secondKeyStroke = KeyStrokeAdapter.getKeyStroke(secondKeyStrokeStr) ?: continue
}
shortcuts.add(KeyboardShortcut(firstKeyStroke, secondKeyStroke))
}
else if (KEYBOARD_GESTURE_SHORTCUT == shortcutElement.name) {
val strokeText = shortcutElement.getAttributeValue(KEYBOARD_GESTURE_KEY) ?: throw InvalidDataException(
"Attribute '$KEYBOARD_GESTURE_KEY' cannot be null; Action's id=$id; Keymap's name=$name")
val stroke = KeyStrokeAdapter.getKeyStroke(strokeText) ?: continue
val modifierText = shortcutElement.getAttributeValue(KEYBOARD_GESTURE_MODIFIER)
var modifier: KeyboardGestureAction.ModifierType? = null
if (KeyboardGestureAction.ModifierType.dblClick.toString().equals(modifierText, ignoreCase = true)) {
modifier = KeyboardGestureAction.ModifierType.dblClick
}
else if (KeyboardGestureAction.ModifierType.hold.toString().equals(modifierText, ignoreCase = true)) {
modifier = KeyboardGestureAction.ModifierType.hold
}
if (modifier == null) {
throw InvalidDataException("Wrong modifier=$modifierText action id=$id keymap=$name")
}
shortcuts.add(KeyboardModifierGestureShortcut.newInstance(modifier, stroke))
}
else if (MOUSE_SHORTCUT == shortcutElement.name) {
val keystrokeString = shortcutElement.getAttributeValue(KEYSTROKE_ATTRIBUTE)
?: throw InvalidDataException("Attribute 'keystroke' cannot be null; Action's id=$id; Keymap's name=$name")
try {
shortcuts.add(KeymapUtil.parseMouseShortcut(keystrokeString))
}
catch (e: InvalidDataException) {
throw InvalidDataException("Wrong mouse-shortcut: '$keystrokeString'; Action's id=$id; Keymap's name=$name")
}
}
else {
throw InvalidDataException("unknown element: $shortcutElement; Keymap's name=$name")
}
}
}
ActionsCollectorImpl.onActionsLoadedFromKeymapXml(this, actionIds)
cleanShortcutsCache()
}
protected open fun findParentScheme(parentSchemeName: String): Keymap? = keymapManager.schemeManager.findSchemeByName(parentSchemeName)
override fun writeScheme(): Element {
dataHolder?.let {
return it.read()
}
val keymapElement = Element(KEY_MAP)
keymapElement.setAttribute(VERSION_ATTRIBUTE, "1")
keymapElement.setAttribute(NAME_ATTRIBUTE, name)
(parent?.name ?: unknownParentName)?.let {
keymapElement.setAttribute(PARENT_ATTRIBUTE, it)
}
writeOwnActionIds(keymapElement)
schemeState = SchemeState.UNCHANGED
return keymapElement
}
private fun writeOwnActionIds(keymapElement: Element) {
val ownActionIds = ownActionIds
Arrays.sort(ownActionIds)
for (actionId in ownActionIds) {
val shortcuts = actionIdToShortcuts[actionId] ?: continue
val actionElement = Element(ACTION)
actionElement.setAttribute(ID_ATTRIBUTE, actionId)
for (shortcut in shortcuts) {
when (shortcut) {
is KeyboardShortcut -> {
val element = Element(KEYBOARD_SHORTCUT)
element.setAttribute(FIRST_KEYSTROKE_ATTRIBUTE, KeyStrokeAdapter.toString(shortcut.firstKeyStroke))
shortcut.secondKeyStroke?.let {
element.setAttribute(SECOND_KEYSTROKE_ATTRIBUTE, KeyStrokeAdapter.toString(it))
}
actionElement.addContent(element)
}
is MouseShortcut -> {
val element = Element(MOUSE_SHORTCUT)
element.setAttribute(KEYSTROKE_ATTRIBUTE, KeymapUtil.getMouseShortcutString(shortcut))
actionElement.addContent(element)
}
is KeyboardModifierGestureShortcut -> {
val element = Element(KEYBOARD_GESTURE_SHORTCUT)
element.setAttribute(KEYBOARD_GESTURE_SHORTCUT, KeyStrokeAdapter.toString(shortcut.stroke))
element.setAttribute(KEYBOARD_GESTURE_MODIFIER, shortcut.type.name)
actionElement.addContent(element)
}
else -> throw IllegalStateException("unknown shortcut class: $shortcut")
}
}
keymapElement.addContent(actionElement)
}
}
fun clearOwnActionsIds() {
actionIdToShortcuts.clear()
cleanShortcutsCache()
}
fun hasOwnActionId(actionId: String): Boolean = actionIdToShortcuts.containsKey(actionId)
fun clearOwnActionsId(actionId: String) {
actionIdToShortcuts.remove(actionId)
cleanShortcutsCache()
}
override fun getActionIds(): Array<String> = ArrayUtilRt.toStringArray(actionIdList)
override fun getActionIdList(): Set<String> {
val ids = LinkedHashSet<String>()
ids.addAll(actionIdToShortcuts.keys)
var parent = parent
while (parent != null) {
ids.addAll(parent.actionIdToShortcuts.keys)
parent = parent.parent
}
return ids
}
override fun getConflicts(actionId: String, keyboardShortcut: KeyboardShortcut): Map<String, MutableList<KeyboardShortcut>> {
val result = HashMap<String, MutableList<KeyboardShortcut>>()
for (id in getActionIds(keyboardShortcut.firstKeyStroke)) {
if (id == actionId || (actionId.startsWith("Editor") && id == "$${actionId.substring(6)}")) {
continue
}
val useShortcutOf = keymapManager.getActionBinding(id)
if (useShortcutOf != null && useShortcutOf == actionId) {
continue
}
for (shortcut1 in getMutableShortcutList(id)) {
if (shortcut1 !is KeyboardShortcut || shortcut1.firstKeyStroke != keyboardShortcut.firstKeyStroke) {
continue
}
if (keyboardShortcut.secondKeyStroke != null && shortcut1.secondKeyStroke != null && keyboardShortcut.secondKeyStroke != shortcut1.secondKeyStroke) {
continue
}
result.getOrPut(id) { SmartList() }.add(shortcut1)
}
}
return result
}
protected open fun convertKeyStroke(keyStroke: KeyStroke): KeyStroke = keyStroke
protected open fun convertMouseShortcut(shortcut: MouseShortcut): MouseShortcut = shortcut
protected open fun convertShortcut(shortcut: Shortcut): Shortcut = shortcut
private fun fireShortcutChanged(actionId: String) {
ApplicationManager.getApplication().messageBus.syncPublisher(KeymapManagerListener.TOPIC).shortcutChanged(this, actionId)
}
override fun toString(): String = presentableName
override fun equals(other: Any?): Boolean {
if (other !is KeymapImpl) return false
if (other === this) return true
if (name != other.name) return false
if (canModify != other.canModify) return false
if (parent != other.parent) return false
if (actionIdToShortcuts != other.actionIdToShortcuts) return false
return true
}
override fun hashCode(): Int = name.hashCode()
}
private fun sortInRegistrationOrder(ids: MutableList<String>) {
ids.sortWith(ActionManagerEx.getInstanceEx().registrationOrderComparator)
}
// compare two lists in any order
private fun areShortcutsEqual(shortcuts1: List<Shortcut>, shortcuts2: List<Shortcut>): Boolean {
if (shortcuts1.size != shortcuts2.size) {
return false
}
for (shortcut in shortcuts1) {
if (!shortcuts2.contains(shortcut)) {
return false
}
}
return true
}
@Suppress("SpellCheckingInspection") private const val macOSKeymap = "com.intellij.plugins.macoskeymap"
@Suppress("SpellCheckingInspection") private const val gnomeKeymap = "com.intellij.plugins.gnomekeymap"
@Suppress("SpellCheckingInspection") private const val kdeKeymap = "com.intellij.plugins.kdekeymap"
@Suppress("SpellCheckingInspection") private const val xwinKeymap = "com.intellij.plugins.xwinkeymap"
@Suppress("SpellCheckingInspection") private const val eclipseKeymap = "com.intellij.plugins.eclipsekeymap"
@Suppress("SpellCheckingInspection") private const val emacsKeymap = "com.intellij.plugins.emacskeymap"
@Suppress("SpellCheckingInspection") private const val netbeansKeymap = "com.intellij.plugins.netbeanskeymap"
@Suppress("SpellCheckingInspection") private const val qtcreatorKeymap = "com.intellij.plugins.qtcreatorkeymap"
@Suppress("SpellCheckingInspection") private const val resharperKeymap = "com.intellij.plugins.resharperkeymap"
@Suppress("SpellCheckingInspection") private const val sublimeKeymap = "com.intellij.plugins.sublimetextkeymap"
@Suppress("SpellCheckingInspection") private const val visualStudioKeymap = "com.intellij.plugins.visualstudiokeymap"
@Suppress("SpellCheckingInspection") private const val visualStudio2022Keymap = "com.intellij.plugins.visualstudio2022keymap"
@Suppress("SpellCheckingInspection") private const val xcodeKeymap = "com.intellij.plugins.xcodekeymap"
@Suppress("SpellCheckingInspection") private const val visualAssistKeymap = "com.intellij.plugins.visualassistkeymap"
@Suppress("SpellCheckingInspection") private const val riderKeymap = "com.intellij.plugins.riderkeymap"
@Suppress("SpellCheckingInspection") private const val vsCodeKeymap = "com.intellij.plugins.vscodekeymap"
@Suppress("SpellCheckingInspection") private const val vsForMacKeymap = "com.intellij.plugins.vsformackeymap"
internal fun notifyAboutMissingKeymap(keymapName: String, @NlsContexts.NotificationContent message: String, isParent: Boolean) {
val connection = ApplicationManager.getApplication().messageBus.connect()
connection.subscribe(ProjectManager.TOPIC, object : ProjectManagerListener {
override fun projectOpened(project: Project) {
connection.disconnect()
ApplicationManager.getApplication().invokeLater(
{
// TODO remove when PluginAdvertiser implements that
@Suppress("SpellCheckingInspection")
val pluginId = when (keymapName) {
"Mac OS X",
"Mac OS X 10.5+" -> macOSKeymap
"Default for GNOME" -> gnomeKeymap
"Default for KDE" -> kdeKeymap
"Default for XWin" -> xwinKeymap
"Eclipse",
"Eclipse (Mac OS X)" -> eclipseKeymap
"Emacs" -> emacsKeymap
"NetBeans 6.5" -> netbeansKeymap
"QtCreator",
"QtCreator OSX" -> qtcreatorKeymap
"ReSharper",
"ReSharper OSX" -> resharperKeymap
"Sublime Text",
"Sublime Text (Mac OS X)" -> sublimeKeymap
"Visual Studio",
"Visual Studio OSX" -> visualStudioKeymap
"Visual Studio 2022" -> visualStudio2022Keymap
"Visual Assist",
"Visual Assist OSX" -> visualAssistKeymap
"Xcode" -> xcodeKeymap
"Visual Studio for Mac" -> vsForMacKeymap
"Rider",
"Rider OSX"-> riderKeymap
"VSCode",
"VSCode OSX"-> vsCodeKeymap
else -> null
}
val action: AnAction = when (pluginId) {
null -> object : NotificationAction(IdeBundle.message("action.text.search.for.keymap", keymapName)) {
override fun actionPerformed(e: AnActionEvent, notification: Notification) {
//TODO enableSearch("$keymapName /tag:Keymap")?.run()
ShowSettingsUtil.getInstance().showSettingsDialog(e.project, PluginManagerConfigurable::class.java)
}
}
else -> object : NotificationAction(IdeBundle.message("action.text.install.keymap", keymapName)) {
override fun actionPerformed(e: AnActionEvent, notification: Notification) {
val connect = ApplicationManager.getApplication().messageBus.connect()
connect.subscribe(KeymapManagerListener.TOPIC, object: KeymapManagerListener {
override fun keymapAdded(keymap: Keymap) {
ApplicationManager.getApplication().invokeLater {
if (keymap.name == keymapName) {
connect.disconnect()
val successMessage = if (isParent) IdeBundle.message("notification.content.keymap.successfully.installed", keymapName)
else {
KeymapManagerEx.getInstanceEx().activeKeymap = keymap
IdeBundle.message("notification.content.keymap.successfully.activated", keymapName)
}
Notification("KeymapInstalled", successMessage,
NotificationType.INFORMATION).notify(e.project)
}
}
}
})
val plugins = mutableSetOf(PluginId.getId(pluginId))
when (pluginId) {
gnomeKeymap, kdeKeymap -> plugins += PluginId.getId(xwinKeymap)
resharperKeymap -> plugins += PluginId.getId(visualStudioKeymap)
visualAssistKeymap -> plugins += PluginId.getId(visualStudioKeymap)
visualStudio2022Keymap -> plugins += PluginId.getId(visualStudioKeymap)
xcodeKeymap, vsForMacKeymap -> plugins += PluginId.getId(macOSKeymap)
}
installAndEnable(project, plugins) { }
notification.expire()
}
}
}
Notification("KeymapMissing", IdeBundle.message("notification.group.missing.keymap"),
message, NotificationType.ERROR)
.addAction(action)
.notify(project)
},
ModalityState.NON_MODAL)
}
})
}
| platform/platform-impl/src/com/intellij/openapi/keymap/impl/KeymapImpl.kt | 1849377636 |
// Copyright 2000-2021 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file.
package org.jetbrains.kotlin.idea.codeInsight.shorten
import com.intellij.openapi.application.ApplicationManager
import com.intellij.openapi.diagnostic.Logger
import com.intellij.openapi.project.Project
import com.intellij.openapi.util.Key
import com.intellij.psi.*
import org.jetbrains.kotlin.asJava.unwrapped
import org.jetbrains.kotlin.idea.caches.resolve.unsafeResolveToDescriptor
import org.jetbrains.kotlin.idea.caches.resolve.util.getJavaMemberDescriptor
import org.jetbrains.kotlin.idea.core.ShortenReferences
import org.jetbrains.kotlin.idea.core.ShortenReferences.Options
import org.jetbrains.kotlin.idea.util.ImportInsertHelper
import org.jetbrains.kotlin.psi.*
import org.jetbrains.kotlin.psi.psiUtil.createSmartPointer
import org.jetbrains.kotlin.psi.psiUtil.forEachDescendantOfType
import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode
import java.util.*
interface DelayedRefactoringRequest
class ShorteningRequest(val pointer: SmartPsiElementPointer<KtElement>, val options: Options) : DelayedRefactoringRequest
class ImportRequest(
val elementToImportPointer: SmartPsiElementPointer<PsiElement>,
val filePointer: SmartPsiElementPointer<KtFile>
) : DelayedRefactoringRequest
private var Project.delayedRefactoringRequests: MutableSet<DelayedRefactoringRequest>?
by UserDataProperty(Key.create("DELAYED_REFACTORING_REQUESTS"))
/*
* When one refactoring invokes another this value must be set to false so that shortening wait-set is not cleared
* and previously collected references are processed correctly. Afterwards it must be reset to original value
*/
var Project.ensureNoRefactoringRequestsBeforeRefactoring: Boolean
by NotNullableUserDataProperty(Key.create("ENSURE_NO_REFACTORING_REQUESTS_BEFORE_REFACTORING"), true)
fun Project.runRefactoringAndKeepDelayedRequests(action: () -> Unit) {
val ensureNoRefactoringRequests = ensureNoRefactoringRequestsBeforeRefactoring
try {
ensureNoRefactoringRequestsBeforeRefactoring = false
action()
} finally {
ensureNoRefactoringRequestsBeforeRefactoring = ensureNoRefactoringRequests
}
}
private fun Project.getOrCreateRefactoringRequests(): MutableSet<DelayedRefactoringRequest> {
var requests = delayedRefactoringRequests
if (requests == null) {
requests = LinkedHashSet()
delayedRefactoringRequests = requests
}
return requests
}
fun KtElement.addToShorteningWaitSet(options: Options = Options.DEFAULT) {
assert(ApplicationManager.getApplication()!!.isWriteAccessAllowed) { "Write access needed" }
val project = project
val elementPointer = SmartPointerManager.getInstance(project).createSmartPsiElementPointer(this)
project.getOrCreateRefactoringRequests().add(ShorteningRequest(elementPointer, options))
}
fun addDelayedImportRequest(elementToImport: PsiElement, file: KtFile) {
assert(ApplicationManager.getApplication()!!.isWriteAccessAllowed) { "Write access needed" }
file.project.getOrCreateRefactoringRequests() += ImportRequest(elementToImport.createSmartPointer(), file.createSmartPointer())
}
fun performDelayedRefactoringRequests(project: Project) {
project.delayedRefactoringRequests?.let { requests ->
project.delayedRefactoringRequests = null
PsiDocumentManager.getInstance(project).commitAllDocuments()
val shorteningRequests = ArrayList<ShorteningRequest>()
val importRequests = ArrayList<ImportRequest>()
requests.forEach {
when (it) {
is ShorteningRequest -> shorteningRequests += it
is ImportRequest -> importRequests += it
}
}
val elementToOptions = shorteningRequests.mapNotNull { req -> req.pointer.element?.let { it to req.options } }.toMap()
val elements = elementToOptions.keys
//TODO: this is not correct because it should not shorten deep into the elements!
ShortenReferences { elementToOptions[it] ?: Options.DEFAULT }.process(elements)
val importInsertHelper = ImportInsertHelper.getInstance(project)
for ((file, requestsForFile) in importRequests.groupBy { it.filePointer.element }) {
if (file == null) continue
for (requestForFile in requestsForFile) {
val elementToImport = requestForFile.elementToImportPointer.element?.unwrapped ?: continue
val descriptorToImport = when (elementToImport) {
is KtDeclaration -> elementToImport.unsafeResolveToDescriptor(BodyResolveMode.PARTIAL)
is PsiMember -> elementToImport.getJavaMemberDescriptor()
else -> null
} ?: continue
importInsertHelper.importDescriptor(file, descriptorToImport)
}
}
}
}
private val LOG = Logger.getInstance(Project::class.java.canonicalName)
fun prepareDelayedRequests(project: Project) {
val requests = project.delayedRefactoringRequests
if (project.ensureNoRefactoringRequestsBeforeRefactoring && !requests.isNullOrEmpty()) {
LOG.warn("Waiting set for reference shortening is not empty")
project.delayedRefactoringRequests = null
}
}
var KtElement.isToBeShortened: Boolean? by CopyablePsiUserDataProperty(Key.create("IS_TO_BE_SHORTENED"))
fun KtElement.addToBeShortenedDescendantsToWaitingSet() {
forEachDescendantOfType<KtElement> {
if (it.isToBeShortened == true) {
it.isToBeShortened = null
it.addToShorteningWaitSet()
}
}
} | plugins/kotlin/analysis/src/org/jetbrains/kotlin/idea/codeInsight/shorten/delayedRequestsWaitingSet.kt | 1472504391 |
// Copyright 2000-2022 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license.
package com.intellij.workspaceModel.storage.impl
import com.intellij.openapi.util.SystemInfoRt
import com.intellij.openapi.util.registry.Registry
import com.intellij.util.containers.CollectionFactory
import com.intellij.util.containers.HashingStrategy
import it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap
import org.jetbrains.annotations.TestOnly
internal class VirtualFileNameStore {
private val generator = IntIdGenerator()
private val id2NameStore = Int2ObjectOpenHashMap<String>()
private val name2IdStore = run {
val checkSensitivityEnabled = Registry.`is`("ide.new.project.model.index.case.sensitivity", false)
if (checkSensitivityEnabled && !SystemInfoRt.isFileSystemCaseSensitive) return@run CollectionFactory.createCustomHashingStrategyMap<String, IdPerCount>(HashingStrategy.caseInsensitive())
return@run CollectionFactory.createSmallMemoryFootprintMap<String, IdPerCount>()
}
fun generateIdForName(name: String): Int {
val idPerCount = name2IdStore[name]
if (idPerCount != null) {
idPerCount.usageCount++
return idPerCount.id
}
else {
val id = generator.generateId()
name2IdStore[name] = IdPerCount(id, 1)
// Don't convert to links[key] = ... because it *may* became autoboxing
id2NameStore.put(id, name)
return id
}
}
fun removeName(name: String) {
val idPerCount = name2IdStore[name] ?: return
if (idPerCount.usageCount == 1L) {
name2IdStore.remove(name)
id2NameStore.remove(idPerCount.id)
}
else {
idPerCount.usageCount--
}
}
fun getNameForId(id: Int): String? = id2NameStore.get(id)
fun getIdForName(name: String) = name2IdStore[name]?.id
@TestOnly
fun clear() {
name2IdStore.clear()
id2NameStore.clear()
generator.clear()
}
}
private data class IdPerCount(val id: Int, var usageCount: Long) {
override fun equals(other: Any?): Boolean {
if (this === other) return true
if (javaClass != other?.javaClass) return false
other as IdPerCount
if (id != other.id) return false
return true
}
override fun hashCode() = 31 * id.hashCode()
}
internal class IntIdGenerator {
private var generator: Int = 0
fun generateId() = ++generator
@TestOnly
fun clear() {
generator = 0
}
} | platform/workspaceModel/storage/src/com/intellij/workspaceModel/storage/impl/VirtualFileNameStore.kt | 807247268 |
// WITH_STDLIB
fun foo(klass: Class<*>) {
klass.getEnclosingClass()<caret>
} | plugins/kotlin/idea/tests/testData/intentions/usePropertyAccessSyntax/genericClassMethod.kt | 2675224225 |
// Copyright 2000-2021 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file.
package org.jetbrains.kotlin.idea.stubindex
import com.intellij.psi.stubs.StubIndexKey
import org.jetbrains.kotlin.psi.KtObjectDeclaration
/**
* An index to enable faster search of named objects with non-empty superclass lists.
*
* The main purpose of the index is to enable automatic import and code completion
* for functions and properties declared in classed but importable from their child objects.
*
* See [org.jetbrains.kotlin.idea.core.KotlinIndicesHelper.processAllCallablesFromSubclassObjects]
* for a usage example.
*/
class KotlinSubclassObjectNameIndex : AbstractStringStubIndexExtension<KtObjectDeclaration>(KtObjectDeclaration::class.java) {
override fun getKey(): StubIndexKey<String, KtObjectDeclaration> = KEY
companion object {
private val KEY = KotlinIndexUtil.createIndexKey(KotlinSubclassObjectNameIndex::class.java)
val INSTANCE: KotlinSubclassObjectNameIndex = KotlinSubclassObjectNameIndex()
@JvmStatic
fun getInstance(): KotlinSubclassObjectNameIndex = INSTANCE
}
}
| plugins/kotlin/analysis/src/org/jetbrains/kotlin/idea/stubindex/KotlinSubclassObjectNameIndex.kt | 3437390790 |
// AFTER-WARNING: Parameter 'a' is never used
fun <T> doSomething(a: T) {}
fun test(n: Int): String {
<caret>return when(n) {
1 -> {
doSomething("***")
"one"
}
else -> {
doSomething("***")
"two"
}
}
| plugins/kotlin/idea/tests/testData/intentions/branched/unfolding/returnToWhen/simpleWhenWithBlocks.kt | 4081328030 |
// Copyright 2000-2021 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file.
package com.intellij.internal.ml
import com.google.gson.Gson
import com.google.gson.reflect.TypeToken
class FeaturesInfo(override val knownFeatures: Set<String>,
override val binaryFeatures: List<BinaryFeature>,
override val floatFeatures: List<FloatFeature>,
override val categoricalFeatures: List<CategoricalFeature>,
override val featuresOrder: Array<FeatureMapper>,
override val version: String?) : ModelMetadata {
companion object {
private val gson = Gson()
private const val DEFAULT: String = "default"
private const val USE_UNDEFINED: String = "use_undefined"
private fun List<String>.withSafeWeighers(): Set<String> {
val result = this.toMutableSet()
result.add("prox_directoryType")
result.add("kt_prox_directoryType")
result.add("kotlin.unwantedElement")
return result
}
fun buildInfo(reader: ModelMetadataReader): FeaturesInfo {
val knownFeatures = reader.allKnown().fromJson<List<String>>().withSafeWeighers()
val binaryFactors: List<BinaryFeature> = reader.binaryFeatures().fromJson<Map<String, Map<String, Any>>>()
.map { binary(it.key, it.value) }
val doubleFactors = reader.floatFeatures().fromJson<Map<String, Map<String, Any>>>()
.map { float(it.key, it.value) }
val categoricalFactors = reader.categoricalFeatures().fromJson<Map<String, List<String>>>()
.map { categorical(it.key, it.value) }
val order = reader.featureOrderDirect()
val featuresIndex = buildFeaturesIndex(binaryFactors, doubleFactors, categoricalFactors)
return FeaturesInfo(knownFeatures, binaryFactors, doubleFactors, categoricalFactors, buildMappers(featuresIndex, order),
reader.extractVersion())
}
fun binary(name: String, description: Map<String, Any>): BinaryFeature {
val (first, second) = extractBinaryValuesMappings(description)
val default = extractDefaultValue(name, description)
return BinaryFeature(name, first, second, default, allowUndefined(description))
}
fun float(name: String, description: Map<String, Any>): FloatFeature {
val default = extractDefaultValue(name, description)
return FloatFeature(name, default, allowUndefined(description))
}
fun categorical(name: String, categories: List<String>): CategoricalFeature {
return CategoricalFeature(name, categories.toSet())
}
private fun <T> String.fromJson(): T {
val typeToken = object : TypeToken<T>() {}
return gson.fromJson<T>(this, typeToken.type)
}
fun buildFeaturesIndex(vararg featureGroups: List<Feature>): Map<String, Feature> {
fun <T : Feature> MutableMap<String, Feature>.addFeatures(features: List<T>): MutableMap<String, Feature> {
for (feature in features) {
if (feature.name in keys) throw InconsistentMetadataException(
"Ambiguous feature description '${feature.name}': $feature and ${this[feature.name]}")
this[feature.name] = feature
}
return this
}
val index = mutableMapOf<String, Feature>()
for (features in featureGroups) {
index.addFeatures(features)
}
return index
}
private fun allowUndefined(description: Map<String, Any>): Boolean {
val value = description[USE_UNDEFINED]
if (value is Boolean) {
return value
}
return true
}
private fun extractDefaultValue(name: String, description: Map<String, Any>): Double {
return description[DEFAULT].toString().toDoubleOrNull()
?: throw InconsistentMetadataException("Default value not found. Feature name: $name")
}
private fun extractBinaryValuesMappings(description: Map<String, Any>)
: Pair<ValueMapping, ValueMapping> {
val result = mutableListOf<ValueMapping>()
for ((name, value) in description) {
if (name == DEFAULT || name == USE_UNDEFINED) continue
val mappedValue = value.toString().toDoubleOrNull()
if (mappedValue == null) throw InconsistentMetadataException("Mapped value for binary feature should be double")
result += name to mappedValue
}
assert(result.size == 2) { "Binary feature must contains 2 values, but found $result" }
result.sortBy { it.first }
return Pair(result[0], result[1])
}
fun buildMappers(features: Map<String, Feature>,
order: List<String>): Array<FeatureMapper> {
val mappers = mutableListOf<FeatureMapper>()
for (arrayFeatureName in order) {
val name = arrayFeatureName.substringBefore('=')
val suffix = arrayFeatureName.indexOf('=').let { if (it == -1) null else arrayFeatureName.substring(it + 1) }
val mapper = features[name]?.createMapper(suffix) ?: throw InconsistentMetadataException(
"Unexpected feature name in array: $arrayFeatureName")
mappers.add(mapper)
}
return mappers.toTypedArray()
}
}
} | platform/platform-impl/src/com/intellij/internal/ml/FeaturesInfo.kt | 3239955368 |
/*
* Charlatano: Free and open-source (FOSS) cheat for CS:GO/CS:CO
* Copyright (C) 2017 - Thomas G. P. Nappo, Jonathan Beaudoin
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package com.charlatano.scripts.aim
import com.charlatano.game.*
import com.charlatano.game.entity.*
import com.charlatano.game.entity.EntityType.Companion.ccsPlayer
import com.charlatano.settings.*
import com.charlatano.utils.*
import java.util.concurrent.atomic.AtomicBoolean
import java.util.concurrent.atomic.AtomicInteger
import java.util.concurrent.atomic.AtomicLong
import kotlin.math.max
val target = AtomicLong(-1)
val bone = AtomicInteger(HEAD_BONE)
val perfect = AtomicBoolean() // only applicable for safe aim
internal fun reset() {
target.set(-1L)
bone.set(HEAD_BONE)
perfect.set(false)
}
internal fun findTarget(position: Angle, angle: Angle, allowPerfect: Boolean,
lockFOV: Int = AIM_FOV, boneID: Int = HEAD_BONE,
yawOnly: Boolean): Player {
var closestFOV = Double.MAX_VALUE
var closestDelta = Double.MAX_VALUE
var closestPlayer = -1L
forEntities(ccsPlayer) result@{
val entity = it.entity
if (entity <= 0 || entity == me || !entity.canShoot()) {
return@result false
}
val ePos: Angle = entity.bones(boneID)
val distance = position.distanceTo(ePos)
val dest = calculateAngle(me, ePos)
val pitchDiff = Math.abs(angle.x - dest.x)
val yawDiff = Math.abs(angle.y - dest.y)
val fov = Math.abs(Math.sin(Math.toRadians(yawDiff)) * distance)
val delta = Math.abs((Math.sin(Math.toRadians(pitchDiff)) + Math.sin(Math.toRadians(yawDiff))) * distance)
if (if (yawOnly) fov <= lockFOV && delta < closestDelta else delta <= lockFOV && delta <= closestDelta) {
closestFOV = fov
closestDelta = delta
closestPlayer = entity
return@result true
} else {
return@result false
}
}
if (closestDelta == Double.MAX_VALUE || closestDelta < 0 || closestPlayer < 0) return -1
if (PERFECT_AIM && allowPerfect && closestFOV <= PERFECT_AIM_FOV && randInt(100 + 1) <= PERFECT_AIM_CHANCE)
perfect.set(true)
return closestPlayer
}
internal fun Entity.inMyTeam() =
!TEAMMATES_ARE_ENEMIES && if (DANGER_ZONE) {
me.survivalTeam().let { it > -1 && it == this.survivalTeam() }
} else me.team() == team()
internal fun Entity.canShoot() = spotted()
&& !dormant()
&& !dead()
&& !inMyTeam()
&& !me.dead()
internal inline fun <R> aimScript(duration: Int, crossinline precheck: () -> Boolean,
crossinline doAim: (destinationAngle: Angle,
currentAngle: Angle, aimSpeed: Int) -> R) = every(duration) {
if (!precheck()) return@every
if (!me.weaponEntity().canFire()) {
reset()
return@every
}
val aim = ACTIVATE_FROM_FIRE_KEY && keyPressed(FIRE_KEY)
val forceAim = keyPressed(FORCE_AIM_KEY)
val pressed = aim or forceAim
var currentTarget = target.get()
if (!pressed) {
reset()
return@every
}
val weapon = me.weapon()
if (!weapon.pistol && !weapon.automatic && !weapon.shotgun && !weapon.sniper) {
reset()
return@every
}
val currentAngle = clientState.angle()
val position = me.position()
if (currentTarget < 0) {
currentTarget = findTarget(position, currentAngle, aim, yawOnly = true)
if (currentTarget <= 0) {
return@every
}
target.set(currentTarget)
}
if (currentTarget == me || !currentTarget.canShoot()) {
reset()
if (TARGET_SWAP_MAX_DELAY > 0) {
Thread.sleep(randLong(TARGET_SWAP_MIN_DELAY, TARGET_SWAP_MAX_DELAY))
}
} else if (currentTarget.onGround() && me.onGround()) {
val boneID = bone.get()
val bonePosition = currentTarget.bones(boneID)
val destinationAngle = calculateAngle(me, bonePosition)
if (AIM_ASSIST_MODE) destinationAngle.finalize(currentAngle, AIM_ASSIST_STRICTNESS / 100.0)
val aimSpeed = AIM_SPEED_MIN + randInt(AIM_SPEED_MAX - AIM_SPEED_MIN)
doAim(destinationAngle, currentAngle, aimSpeed / max(1, CACHE_EXPIRE_MILLIS.toInt() / 4))
}
} | src/main/kotlin/com/charlatano/scripts/aim/General.kt | 903763535 |
package fr.free.nrw.commons.upload
import androidx.exifinterface.media.ExifInterface.*
import junit.framework.Assert.assertTrue
import org.junit.Test
import java.util.*
/**
* Test cases for FileMetadataUtils
*/
class FileMetadataUtilsTest {
/**
* Test method to verify EXIF tags for "Author"
*/
@Test
fun getTagsFromPrefAuthor() {
val author = FileMetadataUtils.getTagsFromPref("Author")
val authorRef = arrayOf(TAG_ARTIST, TAG_CAMERA_OWNER_NAME);
assertTrue(Arrays.deepEquals(author, authorRef))
}
/**
* Test method to verify EXIF tags for "Location"
*/
@Test
fun getTagsFromPrefLocation() {
val author = FileMetadataUtils.getTagsFromPref("Location")
val authorRef = arrayOf(TAG_GPS_LATITUDE, TAG_GPS_LATITUDE_REF,
TAG_GPS_LONGITUDE, TAG_GPS_LONGITUDE_REF,
TAG_GPS_ALTITUDE, TAG_GPS_ALTITUDE_REF)
assertTrue(Arrays.deepEquals(author, authorRef))
}
/**
* Test method to verify EXIF tags for "Copyright"
*/
@Test
fun getTagsFromPrefCopyWright() {
val author = FileMetadataUtils.getTagsFromPref("Copyright")
val authorRef = arrayOf(TAG_COPYRIGHT)
assertTrue(Arrays.deepEquals(author, authorRef))
}
/**
* Test method to verify EXIF tags for "Camera Model"
*/
@Test
fun getTagsFromPrefCameraModel() {
val author = FileMetadataUtils.getTagsFromPref("Camera Model")
val authorRef = arrayOf(TAG_MAKE, TAG_MODEL)
assertTrue(Arrays.deepEquals(author, authorRef))
}
/**
* Test method to verify EXIF tags for "Lens Model"
*/
@Test
fun getTagsFromPrefLensModel() {
val author = FileMetadataUtils.getTagsFromPref("Lens Model")
val authorRef = arrayOf(TAG_LENS_MAKE, TAG_LENS_MODEL, TAG_LENS_SPECIFICATION)
assertTrue(Arrays.deepEquals(author, authorRef))
}
/**
* Test method to verify EXIF tags for "Serial Numbers"
*/
@Test
fun getTagsFromPrefSerialNumbers() {
val author = FileMetadataUtils.getTagsFromPref("Serial Numbers")
val authorRef = arrayOf(TAG_BODY_SERIAL_NUMBER, TAG_LENS_SERIAL_NUMBER)
assertTrue(Arrays.deepEquals(author, authorRef))
}
/**
* Test method to verify EXIF tags for "Software"
*/
@Test
fun getTagsFromPrefSoftware() {
val author = FileMetadataUtils.getTagsFromPref("Software")
val authorRef = arrayOf(TAG_SOFTWARE)
assertTrue(Arrays.deepEquals(author, authorRef))
}
} | app/src/test/kotlin/fr/free/nrw/commons/upload/FileMetadataUtilsTest.kt | 566252787 |
package sk.styk.martin.apkanalyzer.model.statistics
import android.os.Parcel
import android.os.Parcelable
import sk.styk.martin.apkanalyzer.util.BigDecimalFormatter
import java.math.BigDecimal
class PercentagePair : Parcelable {
var count: Number
var percentage: BigDecimal
constructor(count: Number, total: Int) {
this.count = count
this.percentage = getPercentage(count.toDouble(), total.toDouble())
}
override fun toString(): String {
return count.toString() + " (" + BigDecimalFormatter.getCommonFormat().format(percentage) + "%)"
}
override fun describeContents(): Int {
return 0
}
override fun writeToParcel(dest: Parcel, flags: Int) {
dest.writeSerializable(this.count)
dest.writeSerializable(this.percentage)
}
override fun equals(other: Any?): Boolean {
if (this === other) return true
if (javaClass != other?.javaClass) return false
other as PercentagePair
if (count != other.count) return false
if (percentage != other.percentage) return false
return true
}
override fun hashCode(): Int {
var result = count.hashCode()
result = 31 * result + percentage.hashCode()
return result
}
private constructor(`in`: Parcel) {
this.count = `in`.readSerializable() as Number
this.percentage = `in`.readSerializable() as BigDecimal
}
companion object {
@JvmField
val CREATOR: Parcelable.Creator<PercentagePair> = object : Parcelable.Creator<PercentagePair> {
override fun createFromParcel(source: Parcel): PercentagePair {
return PercentagePair(source)
}
override fun newArray(size: Int): Array<PercentagePair?> {
return arrayOfNulls(size)
}
}
fun getPercentage(part: Double, whole: Double): BigDecimal {
return BigDecimal(part * 100 / whole)
}
}
} | app/src/main/java/sk/styk/martin/apkanalyzer/model/statistics/PercentagePair.kt | 2072249114 |
// GENERATED
package com.fkorotkov.kubernetes.admissionregistration.v1beta1
import io.fabric8.kubernetes.api.model.LabelSelector as model_LabelSelector
import io.fabric8.kubernetes.api.model.admissionregistration.v1beta1.MutatingWebhook as v1beta1_MutatingWebhook
import io.fabric8.kubernetes.api.model.admissionregistration.v1beta1.ValidatingWebhook as v1beta1_ValidatingWebhook
fun v1beta1_MutatingWebhook.`objectSelector`(block: model_LabelSelector.() -> Unit = {}) {
if(this.`objectSelector` == null) {
this.`objectSelector` = model_LabelSelector()
}
this.`objectSelector`.block()
}
fun v1beta1_ValidatingWebhook.`objectSelector`(block: model_LabelSelector.() -> Unit = {}) {
if(this.`objectSelector` == null) {
this.`objectSelector` = model_LabelSelector()
}
this.`objectSelector`.block()
}
| DSLs/kubernetes/dsl/src/main/kotlin-gen/com/fkorotkov/kubernetes/admissionregistration/v1beta1/objectSelector.kt | 1842955392 |
package io.kotest.core.test
import io.kotest.mpp.bestName
import io.kotest.mpp.isStable
/**
* Used to generate stable identifiers for data tests and to ensure test names are unique.
*/
object Identifiers {
/**
* Each test name must be unique. We can use the toString if we determine the instance is stable.
*
* An instance is considered stable if it is a data class where each parameter is either a data class itself,
* or one of the [primitiveTypes]. Or if the type of instance is annotated with [IsStableType].
*
* If instance is a type which implements [WithDataTestName], then test name return by [dataTestName] method
* will be consider as stableIdentifier.
*
* Note: If the user has overridden toString() and the returned value is not stable, tests may not appear.
*/
fun stableIdentifier(t: Any): String {
return if (isStable(t::class)) {
t.toString()
} else {
t::class.bestName()
}
}
fun uniqueTestName(name: String, testNames: Set<String>): String {
if (!testNames.contains(name)) return name
var n = 1
fun nextName() = "($n) $name"
while (testNames.contains(nextName()))
n++
return nextName()
}
}
| kotest-framework/kotest-framework-api/src/commonMain/kotlin/io/kotest/core/test/Identifiers.kt | 634364628 |
package study
/**
* Created by zhangll on 2018/1/22.
*/
class Wing : Flyable {
override fun stop() {
println("stop by wing")
}
override fun fly() {
println("fly by wing")
}
} | src/study/Wing.kt | 2465582941 |
package me.kirimin.mitsumine.mybookmark
import android.content.Context
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import android.widget.ArrayAdapter
import android.widget.TextView
import me.kirimin.mitsumine.R
import me.kirimin.mitsumine._common.domain.model.MyBookmark
class MyBookmarkSearchAdapter(context: Context,
private val onMyBookmarkClick: (v: View, myBookmark: MyBookmark) -> Unit,
private val onMyBookmarkLongClick: (v: View, myBookmark: MyBookmark) -> Unit) : ArrayAdapter<MyBookmark>(context, 0) {
override fun getView(position: Int, convertView: View?, parent: ViewGroup): View {
val view: View
val holder: ViewHolder
if (convertView == null) {
view = LayoutInflater.from(context).inflate(R.layout.row_my_bookmarks, null)
holder = ViewHolder(view.findViewById(R.id.card_view),
view.findViewById(R.id.MyBookmarksTitleTextView) as TextView,
view.findViewById(R.id.MyBookmarksContentTextView) as TextView,
view.findViewById(R.id.MyBookmarksUsersTextView) as TextView,
view.findViewById(R.id.MyBookmarksUrlTextView) as TextView)
view.tag = holder
} else {
view = convertView
holder = view.tag as ViewHolder
}
val bookmark = getItem(position)
holder.cardView.tag = bookmark
holder.cardView.setOnClickListener { v -> onMyBookmarkClick(v, v.tag as MyBookmark) }
holder.cardView.setOnLongClickListener { v ->
onMyBookmarkLongClick(v, v.tag as MyBookmark)
false
}
holder.title.text = bookmark.title
holder.contents.text = bookmark.snippet
holder.userCount.text = bookmark.bookmarkCount.toString() + context.getString(R.string.users_lower_case)
holder.url.text = bookmark.linkUrl
return view
}
class ViewHolder(
val cardView: View,
val title: TextView,
val contents: TextView,
val userCount: TextView,
val url: TextView) {
}
}
| app/src/main/java/me/kirimin/mitsumine/mybookmark/MyBookmarkSearchAdapter.kt | 2617096121 |
package org.sanpra.checklist.activity
import androidx.test.espresso.Espresso.onView
import androidx.test.espresso.action.ViewActions.click
import androidx.test.espresso.action.ViewActions.pressImeActionButton
import androidx.test.espresso.action.ViewActions.replaceText
import androidx.test.espresso.action.ViewActions.typeText
import androidx.test.espresso.matcher.ViewMatchers.withId
import androidx.test.ext.junit.runners.AndroidJUnit4
import org.apache.commons.collections4.IterableUtils
import org.junit.Assert
import org.junit.Test
import org.junit.runner.RunWith
import org.sanpra.checklist.R
@RunWith(AndroidJUnit4::class)
class AddItemFragmentTests : BaseTests() {
@Test
fun testEmptyText() {
launchFragment()
onView(withId(R.id.new_item_text)).perform(replaceText(""))
onView(withId(R.id.new_item_add_button)).perform(click())
Assert.assertEquals(0, mockItemsController.listItems().size)
}
@Test
fun testAddItemWithButton() {
launchFragment()
val testString = "Hello world"
onView(withId(R.id.new_item_text)).perform(replaceText(testString))
onView(withId(R.id.new_item_add_button)).perform(click())
val item = IterableUtils.get(mockItemsController.listItems(), 0)
Assert.assertEquals(testString, item.description)
}
@Test
fun testAddItemWithImeAction() {
launchFragment()
val testString = "Test string"
onView(withId(R.id.new_item_text)).perform(typeText(testString))
onView(withId(R.id.new_item_text)).perform(pressImeActionButton())
val item = IterableUtils.get(mockItemsController.listItems(), 0)
Assert.assertEquals(testString, item.description)
}
@Test
fun testBlankText() {
launchFragment()
onView(withId(R.id.new_item_text)).perform(replaceText(" "))
onView(withId(R.id.new_item_add_button)).perform(click())
Assert.assertEquals(0, mockItemsController.listItems().size)
}
private fun launchFragment() {
launchFragment(AddItemFragment::class.java, R.style.AppTheme)
}
}
| app/src/androidTest/java/org/sanpra/checklist/activity/AddItemFragmentTests.kt | 794478873 |
/*
* Copyright (C) 2017-2019 Hazuki
*
* 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
*
* http://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.
*/
package jp.hazuki.yuzubrowser.bookmark.repository
import android.content.Context
import com.squareup.moshi.JsonReader
import com.squareup.moshi.JsonWriter
import jp.hazuki.yuzubrowser.bookmark.item.BookmarkFolder
import jp.hazuki.yuzubrowser.bookmark.item.BookmarkItem
import jp.hazuki.yuzubrowser.bookmark.item.BookmarkSite
import jp.hazuki.yuzubrowser.core.utility.log.ErrorReport
import okio.buffer
import okio.sink
import okio.source
import java.io.File
import java.io.IOException
import java.io.Serializable
import java.util.regex.Pattern
class BookmarkManager private constructor(context: Context) : Serializable {
val file = File(context.getDir("bookmark1", Context.MODE_PRIVATE), "bookmark1.dat")
val root = BookmarkFolder(null, null, -1)
private val siteComparator: Comparator<BookmarkSite> = Comparator { s1, s2 -> s1.url.hashCode().compareTo(s2.url.hashCode()) }
private val siteIndex = ArrayList<BookmarkSite>()
init {
load()
}
companion object {
private var instance: BookmarkManager? = null
@JvmStatic
fun getInstance(context: Context): BookmarkManager {
if (instance == null) {
instance = BookmarkManager(context.applicationContext)
}
return instance!!
}
}
fun load(): Boolean {
root.clear()
if (!file.exists() || file.isDirectory) return true
try {
JsonReader.of(file.source().buffer()).use {
root.readForRoot(it)
createIndex()
return true
}
} catch (e: IOException) {
ErrorReport.printAndWriteLog(e)
}
return false
}
fun save(): Boolean {
file.parentFile?.apply {
if (!exists()) mkdirs()
}
try {
JsonWriter.of(file.sink().buffer()).use {
root.writeForRoot(it)
return true
}
} catch (e: IOException) {
ErrorReport.printAndWriteLog(e)
}
return false
}
fun addFirst(folder: BookmarkFolder, item: BookmarkItem) {
folder.list.add(0, item)
if (item is BookmarkSite) {
addToIndex(item)
}
}
fun add(folder: BookmarkFolder, item: BookmarkItem) {
folder.add(item)
if (item is BookmarkSite) {
addToIndex(item)
}
}
fun moveToFirst(folder: BookmarkFolder, item: BookmarkItem) {
folder.list.remove(item)
folder.list.add(0, item)
}
fun addAll(folder: BookmarkFolder, addList: Collection<BookmarkItem>) {
folder.list.addAll(addList)
addList.filterIsInstance<BookmarkSite>()
.forEach(this::addToIndex)
}
fun remove(folder: BookmarkFolder, item: BookmarkItem) {
remove(folder, folder.list.indexOf(item))
}
fun remove(folder: BookmarkFolder, index: Int) {
val item = folder.list.removeAt(index)
if (item is BookmarkSite) {
removeFromIndex(item)
}
}
fun removeAll(folder: BookmarkFolder, items: List<BookmarkItem>) {
folder.list.removeAll(items)
items.filterIsInstance<BookmarkSite>()
.forEach(this::removeFromIndex)
}
fun removeAll(url: String) {
val it = siteIndex.iterator()
while (it.hasNext()) {
val site = it.next()
if (site.url == url) {
it.remove()
deepRemove(root, site)
}
}
}
private fun deepRemove(folder: BookmarkFolder, item: BookmarkItem): Boolean {
val it = folder.list.iterator()
while (it.hasNext()) {
val child = it.next()
if (child is BookmarkFolder) {
if (deepRemove(child, item))
return true
} else if (child is BookmarkSite) {
if (child == item) {
it.remove()
return true
}
}
}
return false
}
fun moveTo(from: BookmarkFolder, to: BookmarkFolder, siteIndex: Int) {
val item = from.list.removeAt(siteIndex)
to.list.add(item)
if (item is BookmarkFolder) {
item.parent = to
}
}
fun moveAll(from: BookmarkFolder, to: BookmarkFolder, items: List<BookmarkItem>) {
from.list.removeAll(items)
to.list.addAll(items)
items.filterIsInstance<BookmarkFolder>().forEach { it.parent = to }
}
fun search(query: String): List<BookmarkSite> {
val list = mutableListOf<BookmarkSite>()
val pattern = Pattern.compile("[^a-zA-Z]\\Q$query\\E")
search(list, root, pattern)
return list
}
private fun search(list: MutableList<BookmarkSite>, root: BookmarkFolder, pattern: Pattern) {
root.list.forEach {
if (it is BookmarkSite) {
if (pattern.matcher(it.url).find() || pattern.matcher(it.title ?: "").find()) {
list.add(it)
}
}
if (it is BookmarkFolder) {
search(list, it, pattern)
}
}
}
fun isBookmarked(url: String?): Boolean {
if (url == null) return false
var low = 0
var high = siteIndex.size - 1
val hash = url.hashCode()
while (low <= high) {
val mid = (low + high).ushr(1)
val itemHash = siteIndex[mid].url.hashCode()
when {
itemHash < hash -> low = mid + 1
itemHash > hash -> high = mid - 1
else -> {
if (url == siteIndex[mid].url) {
return true
}
for (i in mid - 1 downTo 0) {
val nowHash = siteIndex[i].hashCode()
if (hash != nowHash) {
break
}
if (siteIndex[i].url == url) {
return true
}
}
for (i in mid + 1 until siteIndex.size) {
val nowHash = siteIndex[i].hashCode()
if (hash != nowHash) {
break
}
if (siteIndex[i].url == url) {
return true
}
}
}
}
}
return false
}
operator fun get(id: Long): BookmarkItem? {
return if (id < 0) null else get(id, root)
}
private fun get(id: Long, root: BookmarkFolder): BookmarkItem? {
for (item in root.list) {
if (item.id == id) {
return item
} else if (item is BookmarkFolder) {
val inner = get(id, item)
if (inner != null) {
return inner
}
}
}
return null
}
private fun createIndex() {
siteIndex.clear()
addToIndexFromFolder(root)
}
private fun addToIndexFromFolder(folder: BookmarkFolder) {
folder.list.forEach {
if (it is BookmarkFolder) {
addToIndexFromFolder(it)
}
if (it is BookmarkSite) {
addToIndex(it)
}
}
}
private fun addToIndex(site: BookmarkSite) {
val hash = site.url.hashCode()
val index = siteIndex.binarySearch(site, siteComparator)
if (index < 0) {
siteIndex.add(index.inv(), site)
} else {
if (siteIndex[index] != site) {
for (i in index - 1 downTo 0) {
val itemHash = siteIndex[i].url.hashCode()
if (hash != itemHash) {
break
}
if (siteIndex[i] == site) {
return
}
}
for (i in index + 1 until siteIndex.size) {
val itemHash = siteIndex[i].url.hashCode()
if (hash != itemHash) {
break
}
if (siteIndex[i] == site) {
return
}
}
siteIndex.add(index, site)
}
}
}
private fun removeFromIndex(site: BookmarkSite) {
val hash = site.url.hashCode()
val index = siteIndex.binarySearch(site, siteComparator)
if (index >= 0) {
if (siteIndex[index] == site) {
siteIndex.removeAt(index)
return
}
for (i in index - 1 downTo 0) {
val itemHash = siteIndex[i].url.hashCode()
if (hash != itemHash) {
break
}
if (siteIndex[i] == site) {
siteIndex.removeAt(index)
return
}
}
for (i in index + 1 until siteIndex.size) {
val itemHash = siteIndex[i].url.hashCode()
if (hash != itemHash) {
break
}
if (siteIndex[i] == site) {
siteIndex.removeAt(index)
return
}
}
}
}
}
| module/bookmark/src/main/java/jp/hazuki/yuzubrowser/bookmark/repository/BookmarkManager.kt | 854177542 |
/*
* Copyright 2020 Ren Binden
*
* 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
*
* http://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.
*/
package com.rpkit.languages.bukkit.language
import com.rpkit.core.service.ServiceProvider
interface RPKLanguageProvider: ServiceProvider {
val languages: List<RPKLanguage>
fun getLanguage(name: String): RPKLanguage?
} | bukkit/rpk-language-lib-bukkit/src/main/kotlin/com/rpkit/languages/bukkit/language/RPKLanguageProvider.kt | 2112325567 |
package net.sourceforge.lifeograph
interface FragmentHost {
fun updateDrawerMenu( id: Int )
}
| app/src/main/java/net/sourceforge/lifeograph/FragmentHost.kt | 1237043731 |
package trypp.support.math
import com.google.common.truth.Truth.assertThat
import org.testng.annotations.Test
class BitUtilsTest {
@Test fun testRequireSingleBit() {
for (i in 0..31) {
assertThat(BitUtils.hasSingleBit(1 shl i)).isTrue()
}
assertThat(BitUtils.hasSingleBit(3)).isFalse()
assertThat(BitUtils.hasSingleBit(11)).isFalse()
assertThat(BitUtils.hasSingleBit(99381)).isFalse()
}
@Test fun testGetBitIndex() {
for (i in 0..31) {
assertThat(BitUtils.getBitIndex(1 shl i)).isEqualTo(i)
}
}
} | src/test/code/trypp/support/math/BitUtilsTest.kt | 1174103312 |
package chat.rocket.android.server.infrastructure
import android.content.SharedPreferences
import chat.rocket.android.server.domain.CurrentServerRepository
class SharedPrefsConnectingServerRepository(private val preferences: SharedPreferences) : CurrentServerRepository {
override fun save(url: String) {
preferences.edit().putString(CONNECTING_SERVER_KEY, url).apply()
}
override fun get(): String? {
return preferences.getString(CONNECTING_SERVER_KEY, null)
}
companion object {
private const val CONNECTING_SERVER_KEY = "connecting_server"
}
override fun clear() {
preferences.edit().remove(CONNECTING_SERVER_KEY).apply()
}
} | app/src/main/java/chat/rocket/android/server/infrastructure/SharedPrefsConnectingServerRepository.kt | 1993236715 |
package com.joekickass.mondaymadness.model
import org.junit.Assert
import org.junit.Rule
import org.junit.Test
import org.junit.rules.ExpectedException
import java.util.*
class IntervalQueueTest {
@Rule
@JvmField
val exception = ExpectedException.none()!!
@Test
fun createNewWorkout() {
Assert.assertNotNull(IntervalQueue(10, 10, 1))
}
@Test
fun newWorkoutWithNegativeWorktimeNotAllowed() {
exception.expect(IllegalArgumentException::class.java)
IntervalQueue(-10, 10, 1)
}
@Test
fun newWorkoutWithZeroWorktimeNotAllowed() {
exception.expect(IllegalArgumentException::class.java)
IntervalQueue(0, 10, 1)
}
@Test
fun newWorkoutWithNegativeResttimeNotAllowed() {
exception.expect(IllegalArgumentException::class.java)
IntervalQueue(10, -10, 1)
}
@Test
fun newWorkoutWithZeroResttimeOnlyAllowedIfSingleRepetition() {
Assert.assertNotNull(IntervalQueue(10, 0, 1))
}
@Test
fun newWorkoutWithZeroResttimeOnlyAllowedIfSingleRepetition2() {
exception.expect(IllegalArgumentException::class.java)
IntervalQueue(10, 0, 2)
}
@Test
fun newWorkoutWithNegativeRepetitionsNotAllowed() {
exception.expect(IllegalArgumentException::class.java)
IntervalQueue(10, 10, -10)
}
@Test
fun newWorkoutWithZeroRepetitionsNotAllowed() {
exception.expect(IllegalArgumentException::class.java)
IntervalQueue(10, 10, 0)
}
@Test
fun WorkoutWith10RepetitionsShouldHave20Intervals() {
Assert.assertEquals(20, IntervalQueue(10, 10, 10).count)
}
@Test
fun WorkoutWith1RepetitionShouldHave1WorkInterval() {
Assert.assertTrue(IntervalQueue(10, 10, 1).work)
}
@Test
fun WorkoutWith1RepetitionShouldHave1RestIntervalAfterWorkInterval() {
val workout = IntervalQueue(10, 10, 1)
workout.nextInterval()
Assert.assertTrue(workout.rest)
}
@Test
fun WorkoutWith1RepetitionButNoRestTimeShouldHave1WorkIntervalOnly() {
Assert.assertEquals(1, IntervalQueue(10, 0, 1).count)
}
@Test
fun ItIsPossibleToCheckIfThereAreMoreIntervals() {
val workout = IntervalQueue(10, 10, 3)
Assert.assertTrue(workout.nextInterval().nextInterval().hasNextInterval())
}
@Test
fun NoMoreIntervalsAfterLastDuh() {
val workout = IntervalQueue(10, 10, 3)
Assert.assertFalse(workout.nextInterval().nextInterval().nextInterval().nextInterval().nextInterval().hasNextInterval())
}
@Test
fun TryingToGetMoreIntervalsThanExistIsNotAllowed() {
exception.expect(NoSuchElementException::class.java)
val workout = IntervalQueue(10, 10, 3)
workout.nextInterval().nextInterval().nextInterval().nextInterval().nextInterval().nextInterval()
}
@Test
fun AllWorkIntervalsShouldHaveCorrectTime() {
val workout = IntervalQueue(15, 20, 3)
val work1 = workout.time
val work2 = workout.nextInterval().nextInterval().time
val work3 = workout.nextInterval().nextInterval().time
val arr = listOf(work1, work2, work3)
Assert.assertTrue(arr.all { it == 15L })
}
@Test
fun AllRestIntervalsShouldHaveCorrectTime() {
val workout = IntervalQueue(10, 20, 3)
val rest1 = workout.nextInterval().time
val rest2 = workout.nextInterval().nextInterval().time
val rest3 = workout.nextInterval().nextInterval().time
val arr = listOf(rest1, rest2, rest3)
Assert.assertTrue(arr.all { it == 20L })
}
}
| app/src/test/kotlin/com/joekickass/mondaymadness/model/IntervalQueueTest.kt | 3190782584 |
package org.nield.kotlinstatistics
import org.apache.commons.math3.ml.clustering.*
fun Collection<Pair<Double,Double>>.kMeansCluster(k: Int, maxIterations: Int) = kMeansCluster(k, maxIterations, {it.first}, {it.second})
fun Sequence<Pair<Double,Double>>.kMeansCluster(k: Int, maxIterations: Int) = toList().kMeansCluster(k, maxIterations, {it.first}, {it.second})
inline fun <T> Collection<T>.kMeansCluster(k: Int, maxIterations: Int, crossinline xSelector: (T) -> Double, crossinline ySelector: (T) -> Double) =
asSequence().map { ClusterInput(it, doubleArrayOf(xSelector(it), ySelector(it))) }
.toList()
.let {
KMeansPlusPlusClusterer<ClusterInput<T>>(k,maxIterations)
.cluster(it)
.map {
Centroid((it.center).point.let { DoublePoint(it[0],it[1])}, it.points.map { it.item })
}
}
inline fun <T> Sequence<T>.kMeansCluster(k: Int, maxIterations: Int, crossinline xSelector: (T) -> Double, crossinline ySelector: (T) -> Double) =
toList().kMeansCluster(k,maxIterations,xSelector,ySelector)
inline fun <T> Collection<T>.fuzzyKMeansCluster(k: Int, fuzziness: Double, crossinline xSelector: (T) -> Double, crossinline ySelector: (T) -> Double) =
asSequence().map { ClusterInput(it, doubleArrayOf(xSelector(it), ySelector(it))) }
.toList()
.let {
FuzzyKMeansClusterer<ClusterInput<T>>(k,fuzziness)
.cluster(it)
.map {
Centroid((it.center).point.let { DoublePoint(it[0],it[1])}, it.points.map { it.item })
}
}
inline fun <T> Sequence<T>.fuzzyKMeansCluster(k: Int, fuzziness: Double, crossinline xSelector: (T) -> Double, crossinline ySelector: (T) -> Double) =
toList().fuzzyKMeansCluster(k,fuzziness,xSelector,ySelector)
fun Collection<Pair<Double,Double>>.multiKMeansCluster(k: Int, maxIterations: Int, trialCount: Int) = multiKMeansCluster(k, maxIterations, trialCount, {it.first}, {it.second})
fun Sequence<Pair<Double,Double>>.multiKMeansCluster(k: Int, maxIterations: Int, trialCount: Int) = toList().multiKMeansCluster(k, maxIterations, trialCount, {it.first}, {it.second})
inline fun <T> Sequence<T>.multiKMeansCluster(k: Int, maxIterations: Int, trialCount: Int, crossinline xSelector: (T) -> Double, crossinline ySelector: (T) -> Double) =
toList().multiKMeansCluster(k, maxIterations, trialCount, xSelector, ySelector)
inline fun <T> Collection<T>.multiKMeansCluster(k: Int, maxIterations: Int, trialCount: Int, crossinline xSelector: (T) -> Double, crossinline ySelector: (T) -> Double) =
asSequence().map { ClusterInput(it, doubleArrayOf(xSelector(it), ySelector(it))) }
.toList()
.let { list ->
KMeansPlusPlusClusterer<ClusterInput<T>>(k, maxIterations)
.let {
MultiKMeansPlusPlusClusterer<ClusterInput<T>>(it, trialCount)
.cluster(list)
.map {
Centroid(DoublePoint(-1.0,-1.0), it.points.map { it.item })
}
}
}
inline fun <T> Collection<T>.dbScanCluster(maximumRadius: Double, minPoints: Int, crossinline xSelector: (T) -> Double, crossinline ySelector: (T) -> Double) =
asSequence().map { ClusterInput(it, doubleArrayOf(xSelector(it), ySelector(it))) }
.toList()
.let {
DBSCANClusterer<ClusterInput<T>>(maximumRadius,minPoints)
.cluster(it)
.map {
Centroid(DoublePoint(-1.0,-1.0), it.points.map { it.item })
}
}
inline fun <T> Sequence<T>.dbScanCluster(maximumRadius: Double, minPoints: Int, crossinline xSelector: (T) -> Double, crossinline ySelector: (T) -> Double) =
toList().dbScanCluster(maximumRadius,minPoints,xSelector,ySelector)
class ClusterInput<out T>(val item: T, val location: DoubleArray): Clusterable {
override fun getPoint() = location
}
data class DoublePoint(val x: Double, val y: Double)
data class Centroid<out T>(val center: DoublePoint, val points: List<T>) | src/main/kotlin/org/nield/kotlinstatistics/Clustering.kt | 1880526250 |
/*
* Copyright 2020 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
*
* http://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.
*/
package gradlebuild.buildutils.tasks
import org.gradle.api.tasks.TaskAction
import org.gradle.work.DisableCachingByDefault
@DisableCachingByDefault(because = "Not worth caching")
abstract class GenerateSubprojectsInfo : SubprojectsInfo() {
@TaskAction
fun generateSubprojectsInfo() {
subprojectsJson.asFile.writeText(generateSubprojectsJson())
}
companion object {
internal
const val TASK_NAME = "generateSubprojectsInfo"
}
}
| build-logic/build-update-utils/src/main/kotlin/gradlebuild/buildutils/tasks/GenerateSubprojectsInfo.kt | 1780814173 |
/*
* FXGL - JavaFX Game Library. The MIT License (MIT).
* Copyright (c) AlmasB ([email protected]).
* See LICENSE for details.
*/
package com.almasb.fxgl.ai.senseai
import com.almasb.fxgl.ai.senseai.SenseAIState.*
import com.almasb.fxgl.entity.component.Component
import javafx.beans.property.SimpleObjectProperty
import javafx.geometry.Point2D
import kotlin.math.max
/**
* Adds the ability to "hear" "noises" of interest in the game environment.
*
* @author Almas Baimagambetov ([email protected])
*/
class HearingSenseComponent(
/**
* Noise heard outside this radius will be ignored.
*/
var hearingRadius: Double
): Component() {
/**
* Drives the change in [state].
*/
private var alertness = 0.0
/**
* How quickly does the entity lose interest in being alert / aggressive.
*/
var alertnessDecay = 0.1
/**
* Noise heard with volume less than or equal to this value will be ignored.
*/
var noiseVolumeTolerance: Double = 0.0
/**
* When in [SenseAIState.CALM], only a portion of the noise volume will be heard.
* By default the value is 0.5 (=50%).
*/
var calmFactor: Double = 0.5
/**
* Alertness equal to or above this value will trigger state change to [SenseAIState.ALERT].
*/
var alertStateThreshold: Double = 0.5
/**
* Alertness equal to or above this value will trigger state change to [SenseAIState.AGGRESSIVE].
*/
var aggressiveStateThreshold: Double = 0.75
/**
* The position of the last heard noise.
*/
var lastHeardPoint = Point2D.ZERO
private val stateProp = SimpleObjectProperty(CALM)
var state: SenseAIState
get() = stateProp.value
set(value) { stateProp.value = value }
fun stateProperty() = stateProp
override fun onUpdate(tpf: Double) {
alertness = max(0.0, alertness - alertnessDecay * tpf)
if (alertness >= aggressiveStateThreshold) {
state = AGGRESSIVE
} else if (alertness >= alertStateThreshold) {
state = ALERT
} else {
state = CALM
}
}
/**
* Trigger this sense to hear a noise at [point] with given [volume].
* The [volume] diminishes based on distance between [point] and the entity.
* Based on [state], [hearingRadius] and [noiseVolumeTolerance] this noise may be ignored.
*/
fun hearNoise(point: Point2D, volume: Double) {
if (state == CANNOT_BE_DISTURBED)
return
if (volume <= noiseVolumeTolerance)
return
val distance = entity.position.distance(point)
if (distance > hearingRadius)
return
lastHeardPoint = point
val stateVolumeRatio = if (state == CALM) calmFactor else 1.0
val adjustedVolume = volume * (1.0 - (distance / hearingRadius)) * stateVolumeRatio
alertness += adjustedVolume
}
fun alertnessDecay(decayAmount: Double) = this.apply {
this.alertnessDecay = decayAmount
}
fun noiseVolumeTolerance(noiseVolumeTolerance: Double) = this.apply {
this.noiseVolumeTolerance = noiseVolumeTolerance
}
fun calmFactor(calmFactor: Double) = this.apply {
this.calmFactor = calmFactor
}
fun alertStateThreshold(alertThreshold: Double) = this.apply {
this.alertStateThreshold = alertThreshold
}
fun aggressiveStateThreshold(aggressiveStateThreshold: Double) = this.apply {
this.aggressiveStateThreshold = aggressiveStateThreshold
}
fun lastHeardPoint(lastHeardPoint: Point2D) = this.apply {
this.lastHeardPoint = lastHeardPoint
}
} | fxgl-entity/src/main/kotlin/com/almasb/fxgl/ai/senseai/HearingSenseComponent.kt | 2522742954 |
package io.github.manamiproject.manami.app.events
import io.github.manamiproject.manami.app.lists.ListChangedEvent
import io.github.manamiproject.manami.app.lists.ListChangedEvent.EventType.ADDED
import io.github.manamiproject.manami.app.lists.ListChangedEvent.EventType.REMOVED
import java.util.function.Predicate
internal class EventfulList<T>(
private val listType: EventListType,
private val eventBus: EventBus = SimpleEventBus,
private val list: MutableList<T> = mutableListOf(),
) : MutableList<T> by list {
constructor(listType: EventListType, vararg values: T) : this(
listType = listType,
list = values.toMutableList()
)
override fun add(element: T): Boolean {
if (list.contains(element)) {
return false
}
val hasBeenModified = list.add(element)
if (hasBeenModified) {
eventBus.post(
ListChangedEvent(
list = listType,
type = ADDED,
obj = setOf(element)
)
)
}
return hasBeenModified
}
override fun add(index: Int, element: T) {
require(index <= list.size - 1) { "Cannot add on unpopulated index." }
if (list.contains(element)) {
list.remove(element)
list.add(index, element)
} else {
list.add(index, element)
eventBus.post(
ListChangedEvent(
list = listType,
type = ADDED,
obj = setOf(element)
)
)
}
}
override fun addAll(index: Int, elements: Collection<T>): Boolean {
val isModifiable = elements.any { !list.contains(it) }
list.removeAll(elements)
list.addAll(index, elements)
if (isModifiable) {
eventBus.post(
ListChangedEvent(
list = listType,
type = ADDED,
obj = elements.toSet()
)
)
}
return isModifiable
}
override fun addAll(elements: Collection<T>): Boolean {
val elementsToAdd = elements.filterNot { list.contains(it) }
val isModifiable = elementsToAdd.isNotEmpty()
if (isModifiable) {
list.addAll(elementsToAdd)
eventBus.post(
ListChangedEvent(
list = listType,
type = ADDED,
obj = elements.toSet()
)
)
}
return isModifiable
}
override fun remove(element: T): Boolean {
if (!list.contains(element)) {
return false
}
val hasBeenModified = list.remove(element)
if (hasBeenModified) {
eventBus.post(
ListChangedEvent(
list = listType,
type = REMOVED,
obj = setOf(element)
)
)
}
return hasBeenModified
}
override fun removeAll(elements: Collection<T>): Boolean {
val elementsToRemove = elements.filter { list.contains(it) }
val isModifiable = elementsToRemove.isNotEmpty()
if (isModifiable) {
list.removeAll(elementsToRemove)
eventBus.post(
ListChangedEvent(
list = listType,
type = REMOVED,
obj = elementsToRemove.toSet()
)
)
}
return isModifiable
}
override fun removeAt(index: Int): T {
require(index < list.size - 1) { "Cannot remove unpopulated index." }
val returnValue = list.removeAt(index)
eventBus.post(
ListChangedEvent(
list = listType,
type = REMOVED,
obj = setOf(returnValue)
)
)
return returnValue
}
override fun removeIf(filter: Predicate<in T>): Boolean {
val elementsBeingRemoved = list.filter { filter.test(it)}
val isModifiable = elementsBeingRemoved.isNotEmpty()
if (isModifiable) {
list.removeIf(filter)
eventBus.post(
ListChangedEvent(
list = listType,
type = REMOVED,
obj = elementsBeingRemoved.toSet()
)
)
}
return isModifiable
}
override fun retainAll(elements: Collection<T>): Boolean {
val elementsToBeRemoved = list - elements
val isModifiable = elementsToBeRemoved.isNotEmpty()
if (isModifiable) {
list.removeAll(elementsToBeRemoved)
eventBus.post(
ListChangedEvent(
list = listType,
type = REMOVED,
obj = elementsToBeRemoved.toSet()
)
)
}
return isModifiable
}
override fun set(index: Int, element: T): T {
require(index <= list.size - 1) { "Cannot replace entry on unpopulated index." }
val replacedValue = list.set(index, element)
if (replacedValue != element) {
eventBus.post(
ListChangedEvent(
list = listType,
type = REMOVED,
obj = setOf(replacedValue)
)
)
eventBus.post(
ListChangedEvent(
list = listType,
type = ADDED,
obj = setOf(element)
)
)
}
return replacedValue
}
override fun clear() {
if (list.isEmpty()) {
return
}
eventBus.post(
ListChangedEvent(
list = listType,
type = REMOVED,
obj = list.toSet()
)
)
list.clear()
}
override fun toString(): String = list.toString()
override fun equals(other: Any?): Boolean {
if (other == null || other !is EventfulList<*>) return false
if (other === this) return true
return other.toList() == list.toList()
}
override fun hashCode(): Int = list.toList().hashCode()
} | manami-app/src/main/kotlin/io/github/manamiproject/manami/app/events/EventfulList.kt | 2784770749 |
/*
* Copyright 2022 Ren Binden
*
* 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
*
* http://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.
*/
package com.rpkit.characters.bukkit.command.result
import com.rpkit.core.command.result.CommandFailure
class NoCharacterOtherFailure : CommandFailure() | bukkit/rpk-character-lib-bukkit/src/main/kotlin/com/rpkit/characters/bukkit/command/result/NoCharacterOtherFailure.kt | 2696420513 |
package si.pecan.controller
import org.springframework.messaging.simp.SimpMessagingTemplate
import org.springframework.web.bind.annotation.*
import si.pecan.dto.GetUserInfoRequest
import si.pecan.dto.toDto
import si.pecan.model.User
import si.pecan.services.UserService
@RestController
@RequestMapping("/api/user")
class UserController(private val userService: UserService, private val simpMessagingTemplate: SimpMessagingTemplate) {
@RequestMapping(method = arrayOf(RequestMethod.POST))
fun getUser(@RequestBody request: GetUserInfoRequest) = userService.getOrCreate(request.username).toDto().apply {
simpMessagingTemplate.convertAndSend("/topic/users", this)
}
@RequestMapping(method = arrayOf(RequestMethod.GET))
fun getOtherUsers() = userService.getAllOrdered().map(User::toDto)
}
| src/main/kotlin/si/pecan/controller/UserController.kt | 272342096 |
/*
* Copyright (C) 2019. Uber Technologies
*
* 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
*
* http://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.
*/
package autodispose2.lint
import com.android.tools.lint.checks.infrastructure.LintDetectorTest
import com.android.tools.lint.checks.infrastructure.TestFile
import com.android.tools.lint.checks.infrastructure.TestFiles.LibraryReferenceTestFile
import com.android.tools.lint.detector.api.Detector
import com.android.tools.lint.detector.api.Issue
import org.junit.Test
import org.junit.runner.RunWith
import org.junit.runners.JUnit4
import java.io.File
@RunWith(JUnit4::class)
internal class AutoDisposeDetectorTest : LintDetectorTest() {
companion object {
// Stub activity
private val ACTIVITY = java(
"""
package androidx.appcompat.app;
import androidx.lifecycle.LifecycleOwner;
public class AppCompatActivity implements LifecycleOwner {
}
"""
).indented()
// Stub LifecycleOwner
private val LIFECYCLE_OWNER = java(
"""
package androidx.lifecycle;
public interface LifecycleOwner {}
"""
).indented()
// Stub Fragment
private val FRAGMENT = java(
"""
package androidx.fragment.app;
import androidx.lifecycle.LifecycleOwner;
public class Fragment implements LifecycleOwner {}
"""
).indented()
// Stub Scope Provider
private val SCOPE_PROVIDER = kotlin(
"""
package autodispose2
interface ScopeProvider
"""
).indented()
// Stub LifecycleScopeProvider
private val LIFECYCLE_SCOPE_PROVIDER = kotlin(
"""
package autodispose2.lifecycle
import autodispose2.ScopeProvider
interface LifecycleScopeProvider: ScopeProvider
"""
).indented()
// Custom Scope
private val CUSTOM_SCOPE = kotlin(
"""
package autodispose2.sample
class ClassWithCustomScope
"""
).indented()
private val AUTODISPOSE_CONTEXT = kotlin(
"""
package autodispose2
interface AutoDisposeContext
"""
).indented()
private val WITH_SCOPE_PROVIDER = kotlin(
"autodispose2/KotlinExtensions.kt",
"""
@file:JvmName("KotlinExtensions")
package autodispose2
fun withScope(scope: ScopeProvider, body: AutoDisposeContext.() -> Unit) {
}
"""
).indented().within("src/")
private val WITH_SCOPE_COMPLETABLE = kotlin(
"autodispose2/KotlinExtensions.kt",
"""
@file:JvmName("KotlinExtensions")
package autodispose2
import io.reactivex.rxjava3.core.Completable
fun withScope(scope: Completable, body: AutoDisposeContext.() -> Unit) {
}
"""
).indented().within("src/")
private val RX_KOTLIN = kotlin(
"io/reactivex/rxjava3/kotlin/subscribers.kt",
"""
@file:JvmName("subscribers")
package io.reactivex.rxjava3.kotlin
import io.reactivex.rxjava3.core.*
import io.reactivex.rxjava3.disposables.Disposable
fun <G : Any> Observable<G>.subscribeBy(
onNext: (G) -> Unit
): Disposable = subscribe()
"""
).indented().within("src/")
private fun propertiesFile(lenient: Boolean = true, kotlinExtensionFunctions: String? = null): TestFile.PropertyTestFile {
val properties = projectProperties()
properties.property(LENIENT, lenient.toString())
kotlinExtensionFunctions?.also {
properties.property(KOTLIN_EXTENSION_FUNCTIONS, it)
}
properties.to(AutoDisposeDetector.PROPERTY_FILE)
return properties
}
private fun lenientPropertiesFile(lenient: Boolean = true): TestFile.PropertyTestFile {
return propertiesFile(lenient)
}
}
@Test fun observableErrorsOutOnOmittingAutoDispose() {
lint()
.files(
*jars(),
LIFECYCLE_OWNER,
FRAGMENT,
java(
"""
package foo;
import io.reactivex.rxjava3.core.Observable;
import androidx.fragment.app.Fragment;
class ExampleClass extends Fragment {
void names() {
Observable<Integer> obs = Observable.just(1, 2, 3, 4);
obs.subscribe();
}
}
"""
).indented()
)
.run()
.expect(
"""src/foo/ExampleClass.java:8: Error: ${AutoDisposeDetector.LINT_DESCRIPTION} [AutoDispose]
| obs.subscribe();
| ~~~~~~~~~~~~~~~
|1 errors, 0 warnings""".trimMargin()
)
}
@Test fun observableDisposesSubscriptionJava() {
lint()
.files(
*jars(),
java(
"""
package foo;
import io.reactivex.rxjava3.core.Observable;
import autodispose2.AutoDispose;
import autodispose2.ScopeProvider;
class ExampleClass {
private ScopeProvider scopeProvider;
void names() {
Observable<Integer> obs = Observable.just(1, 2, 3, 4);
obs.as(AutoDispose.autoDisposable(scopeProvider)).subscribe();
}
}
"""
).indented()
)
.allowCompilationErrors() // Lint 30 doesn't understand subscribeProxies for some reason
.run()
.expectClean()
}
@Test fun observableSubscribeWithNotHandled() {
lint()
.files(
*jars(),
LIFECYCLE_OWNER,
FRAGMENT,
java(
"""
package foo;
import io.reactivex.rxjava3.core.Observable;
import io.reactivex.rxjava3.observers.DisposableObserver;
import androidx.fragment.app.Fragment;
class ExampleClass extends Fragment {
void names() {
Observable<Integer> obs = Observable.just(1, 2, 3, 4);
obs.subscribeWith(new DisposableObserver<Integer>() {
@Override
public void onNext(Integer integer) {
}
@Override
public void onError(Throwable e) {}
@Override
public void onComplete() {}
});
}
}
"""
).indented()
)
.run()
.expect(
"""src/foo/ExampleClass.java:9: Error: ${AutoDisposeDetector.LINT_DESCRIPTION} [AutoDispose]
| obs.subscribeWith(new DisposableObserver<Integer>() {
| ^
|1 errors, 0 warnings""".trimMargin()
)
}
@Test fun observableSubscribeWithDisposed() {
lint()
.files(
*jars(),
SCOPE_PROVIDER,
LIFECYCLE_OWNER,
FRAGMENT,
java(
"""
package foo;
import io.reactivex.rxjava3.core.Observable;
import io.reactivex.rxjava3.observers.DisposableObserver;
import androidx.fragment.app.Fragment;
import autodispose2.AutoDispose;
import autodispose2.ScopeProvider;
class ExampleClass extends Fragment {
ScopeProvider scopeProvider;
void names() {
Observable<Integer> obs = Observable.just(1, 2, 3, 4);
obs.as(AutoDispose.autoDisposable(scopeProvider)).subscribeWith(
new DisposableObserver<Integer>() {
@Override
public void onNext(Integer integer) {
}
@Override
public void onError(Throwable e) {}
@Override
public void onComplete() {}
});
}
}
"""
).indented()
)
.allowCompilationErrors() // Lint 30 doesn't understand subscribeWith for some reason
.run()
.expectClean()
}
@Test fun observableDisposesSubscriptionKotlin() {
lint()
.files(
*jars(),
kotlin(
"""
package foo
import io.reactivex.rxjava3.core.Observable
import autodispose2.autoDispose
import autodispose2.ScopeProvider
class ExampleClass {
lateinit var scopeProvider: ScopeProvider
fun names() {
val obs = Observable.just(1, 2, 3, 4)
obs.autoDispose(scopeProvider).subscribe()
}
}
"""
).indented()
)
.allowCompilationErrors() // Until AGP 7.1.0 https://groups.google.com/g/lint-dev/c/BigCO8sMhKU
.run()
.expectClean()
}
@Test fun singleErrorsOutOnOmittingAutoDispose() {
lint()
.files(
*jars(),
LIFECYCLE_OWNER,
ACTIVITY,
java(
"""
package foo;
import io.reactivex.rxjava3.core.Single;
import androidx.appcompat.app.AppCompatActivity;
class ExampleClass extends AppCompatActivity {
void names() {
Single<Integer> single = Single.just(1);
single.subscribe();
}
}
"""
).indented()
)
.run()
.expect(
"""src/foo/ExampleClass.java:8: Error: ${AutoDisposeDetector.LINT_DESCRIPTION} [AutoDispose]
| single.subscribe();
| ~~~~~~~~~~~~~~~~~~
|1 errors, 0 warnings""".trimMargin()
)
}
@Test fun singleDisposesSubscriptionJava() {
lint()
.files(
*jars(),
java(
"""
package foo;
import io.reactivex.rxjava3.core.Single;
import autodispose2.AutoDispose;
import autodispose2.ScopeProvider;
class ExampleClass {
private ScopeProvider scopeProvider;
void names() {
Single<Integer> single = Single.just(1);
single.as(AutoDispose.autoDisposable(scopeProvider)).subscribe();
}
}
"""
).indented()
)
.allowCompilationErrors() // Lint 30 doesn't understand subscribeProxies for some reason
.run()
.expectClean()
}
@Test fun singleDisposesSubscriptionKotlin() {
lint()
.files(
*jars(),
kotlin(
"""
package foo
import io.reactivex.rxjava3.core.Single
import autodispose2.ScopeProvider
import autodispose2.autoDispose
class ExampleClass {
lateinit var scopeProvider: ScopeProvider
fun names() {
val single = Single.just(1)
single.autoDispose(scopeProvider).subscribe()
}
}
"""
).indented()
)
.allowCompilationErrors() // Until AGP 7.1.0 https://groups.google.com/g/lint-dev/c/BigCO8sMhKU
.run()
.expectClean()
}
@Test fun flowableErrorsOutOnOmittingAutoDispose() {
lint()
.files(
*jars(),
LIFECYCLE_OWNER,
java(
"""
package foo;
import io.reactivex.rxjava3.core.Flowable;
import androidx.lifecycle.LifecycleOwner;
class ExampleClass implements LifecycleOwner {
void names() {
Flowable<Integer> flowable = Flowable.just(1);
flowable.subscribe();
}
}
"""
).indented()
)
.run()
.expect(
"""src/foo/ExampleClass.java:8: Error: ${AutoDisposeDetector.LINT_DESCRIPTION} [AutoDispose]
| flowable.subscribe();
| ~~~~~~~~~~~~~~~~~~~~
|1 errors, 0 warnings""".trimMargin()
)
}
@Test fun flowableDisposesSubscriptionJava() {
lint()
.files(
*jars(),
java(
"""
package foo;
import io.reactivex.rxjava3.core.Flowable;
import autodispose2.AutoDispose;
import autodispose2.ScopeProvider;
class ExampleClass {
private ScopeProvider scopeProvider;
void names() {
Flowable<Integer> flowable = Flowable.just(1, 2, 3, 4);
flowable.as(AutoDispose.autoDisposable(scopeProvider)).subscribe();
}
}
"""
).indented()
)
.allowCompilationErrors() // Lint 30 doesn't understand subscribeProxies for some reason
.run()
.expectClean()
}
@Test fun flowableDisposesSubscriptionKotlin() {
lint()
.files(
*jars(),
LIFECYCLE_SCOPE_PROVIDER,
kotlin(
"""
package foo
import io.reactivex.rxjava3.core.Observable
import autodispose2.autoDispose
import autodispose2.lifecycle.LifecycleScopeProvider
class ExampleClass: LifecycleScopeProvider {
fun names() {
val flowable = Flowable.just(1, 2, 3, 4)
flowable.autoDispose(this).subscribe()
}
}
"""
).indented()
)
.allowCompilationErrors() // Until AGP 7.1.0 https://groups.google.com/g/lint-dev/c/BigCO8sMhKU
.run()
.expectClean()
}
@Test fun completableErrorsOutOnOmittingAutoDispose() {
lint()
.files(
*jars(),
SCOPE_PROVIDER,
kotlin(
"""
package foo
import io.reactivex.rxjava3.core.Completable
import autodispose2.ScopeProvider
class ExampleClass: ScopeProvider {
fun names() {
val completable = Completable.complete()
completable.subscribe()
}
}
"""
).indented()
)
.run()
.expect(
"""src/foo/ExampleClass.kt:8: Error: ${AutoDisposeDetector.LINT_DESCRIPTION} [AutoDispose]
| completable.subscribe()
| ~~~~~~~~~~~~~~~~~~~~~~~
|1 errors, 0 warnings""".trimMargin()
)
}
@Test fun completableSubscriptionNonScopedClass() {
lint()
.files(
*jars(),
java(
"""
package foo;
import io.reactivex.rxjava3.core.Completable;
import autodispose2.ScopeProvider;
class ExampleClass {
private ScopeProvider scopeProvider;
void names() {
Completable completable = Completable.complete();
completable.subscribe();
}
}
"""
).indented()
)
.run()
.expectClean()
}
@Test fun completableDisposesSubscriptionKotlin() {
lint()
.files(
*jars(),
kotlin(
"""
package foo
import io.reactivex.rxjava3.core.Observable
import autodispose2.ScopeProvider
import autodispose2.autoDispose
class ExampleClass {
lateinit var scopeProvider: ScopeProvider
fun names() {
val completable = Completable.complete()
completable.autoDispose(scopeProvider).subscribe()
}
}
"""
).indented()
)
.allowCompilationErrors() // Until AGP 7.1.0 https://groups.google.com/g/lint-dev/c/BigCO8sMhKU
.run()
.expectClean()
}
@Test fun maybeErrorsOutOnOmittingAutoDispose() {
lint()
.files(
*jars(),
LIFECYCLE_OWNER,
ACTIVITY,
kotlin(
"""
package foo
import io.reactivex.rxjava3.core.Maybe
import androidx.appcompat.app.AppCompatActivity
class ExampleClass: AppCompatActivity {
fun names() {
val maybe = Maybe.just(1)
maybe.subscribe()
}
}
"""
).indented()
)
.run()
.expect(
"""src/foo/ExampleClass.kt:8: Error: ${AutoDisposeDetector.LINT_DESCRIPTION} [AutoDispose]
| maybe.subscribe()
| ~~~~~~~~~~~~~~~~~
|1 errors, 0 warnings""".trimMargin()
)
}
@Test fun maybeDisposesSubscriptionJava() {
lint()
.files(
*jars(),
java(
"""
package foo;
import io.reactivex.rxjava3.core.Maybe;
import autodispose2.AutoDispose;
import autodispose2.ScopeProvider;
class ExampleClass {
private ScopeProvider scopeProvider;
void names() {
Maybe<Integer> maybe = Maybe.just(1);
maybe.as(AutoDispose.autoDisposable(scopeProvider)).subscribe();
}
}
"""
).indented()
)
.allowCompilationErrors() // Lint 30 doesn't understand subscribeProxies for some reason
.run()
.expectClean()
}
@Test fun maybeDisposesSubscriptionKotlin() {
lint()
.files(
*jars(),
kotlin(
"""
package foo
import io.reactivex.rxjava3.core.Maybe
import autodispose2.autoDispose
import autodispose2.ScopeProvider
class ExampleClass {
lateinit var scopeProvider: ScopeProvider
fun names() {
val maybe = Maybe.just(2)
maybe.autoDispose(scopeProvider).subscribe()
}
}
"""
).indented()
)
.allowCompilationErrors() // Until AGP 7.1.0 https://groups.google.com/g/lint-dev/c/BigCO8sMhKU
.run()
.expectClean()
}
@Test fun customScopeWithoutAutoDispose() {
val properties = projectProperties()
properties.property(CUSTOM_SCOPE_KEY, "autodispose2.sample.ClassWithCustomScope")
properties.to(AutoDisposeDetector.PROPERTY_FILE)
lint().files(
*jars(),
CUSTOM_SCOPE,
properties,
kotlin(
"""
package autodispose2.sample
import autodispose2.sample.ClassWithCustomScope
import io.reactivex.rxjava3.core.Observable
class MyCustomClass: ClassWithCustomScope {
fun doSomething() {
val observable = Observable.just(1, 2, 3)
observable.subscribe()
}
}
"""
).indented()
)
.run()
.expect(
"""
src/autodispose2/sample/MyCustomClass.kt:8: Error: ${AutoDisposeDetector.LINT_DESCRIPTION} [AutoDispose]
| observable.subscribe()
| ~~~~~~~~~~~~~~~~~~~~~~
|1 errors, 0 warnings""".trimMargin()
)
}
@Test fun customScopeWithAutoDispose() {
val properties = projectProperties()
properties.property(CUSTOM_SCOPE_KEY, "autodispose2.sample.ClassWithCustomScope")
properties.to(AutoDisposeDetector.PROPERTY_FILE)
lint().files(
*jars(),
CUSTOM_SCOPE,
properties,
kotlin(
"""
package autodispose2.sample
import autodispose2.sample.ClassWithCustomScope
import io.reactivex.rxjava3.core.Observable
import autodispose2.autoDispose
import autodispose2.ScopeProvider
class MyCustomClass: ClassWithCustomScope {
lateinit var scopeProvider: ScopeProvider
fun doSomething() {
val observable = Observable.just(1, 2, 3)
observable.autoDispose(scopeProvider).subscribe()
}
}
"""
).indented()
)
.allowCompilationErrors() // Until AGP 7.1.0 https://groups.google.com/g/lint-dev/c/BigCO8sMhKU
.run()
.expectClean()
}
@Test fun emptyCustomScopeWithoutAutoDispose() {
val properties = projectProperties()
properties.to(AutoDisposeDetector.PROPERTY_FILE)
lint().files(
*jars(),
CUSTOM_SCOPE,
properties,
kotlin(
"""
package autodispose2.sample
import autodispose2.sample.ClassWithCustomScope
import io.reactivex.rxjava3.core.Observable
import autodispose2.ScopeProvider
class MyCustomClass: ClassWithCustomScope {
lateinit var scopeProvider: ScopeProvider
fun doSomething() {
val observable = Observable.just(1, 2, 3)
observable.subscribe() // No error since custom scope not defined in properties file.
}
}
"""
).indented()
)
.run()
.expectClean()
}
@Test fun overrideCustomScopeWithoutAutoDispose() {
val properties = projectProperties()
properties.property(CUSTOM_SCOPE_KEY, "autodispose2.sample.ClassWithCustomScope")
properties.property(OVERRIDE_SCOPES, "true")
properties.to(AutoDisposeDetector.PROPERTY_FILE)
lint().files(
*jars(),
LIFECYCLE_OWNER,
ACTIVITY,
properties,
kotlin(
"""
package autodispose2.sample
import autodispose2.sample.ClassWithCustomScope
import androidx.appcompat.app.AppCompatActivity
import io.reactivex.rxjava3.core.Observable
import autodispose2.ScopeProvider
class MyCustomClass: AppCompatActivity {
lateinit var scopeProvider: ScopeProvider
fun doSomething() {
val observable = Observable.just(1, 2, 3)
observable.subscribe() // No error since the scopes are being overriden and only custom ones are considered.
}
}
"""
).indented()
)
.allowCompilationErrors() // TODO or replace with a real sample stub?
.run()
.expectClean()
}
@Test fun overrideCustomScopeWithAutoDispose() {
val properties = projectProperties()
properties.property(CUSTOM_SCOPE_KEY, "autodispose2.sample.ClassWithCustomScope")
properties.property(OVERRIDE_SCOPES, "true")
properties.to(AutoDisposeDetector.PROPERTY_FILE)
lint().files(
*jars(),
CUSTOM_SCOPE,
properties,
kotlin(
"""
package autodispose2.sample
import autodispose2.sample.ClassWithCustomScope
import io.reactivex.rxjava3.core.Observable
import autodispose2.ScopeProvider
import autodispose2.autoDispose
class MyCustomClass: ClassWithCustomScope {
lateinit var scopeProvider: ScopeProvider
fun doSomething() {
val observable = Observable.just(1, 2, 3)
observable.autoDispose(scopeProvider).subscribe()
}
}
"""
).indented()
)
.allowCompilationErrors() // Until AGP 7.1.0 https://groups.google.com/g/lint-dev/c/BigCO8sMhKU
.run()
.expectClean()
}
@Test fun capturedDisposable() {
val propertiesFile = lenientPropertiesFile()
lint().files(
*jars(),
propertiesFile,
LIFECYCLE_OWNER,
ACTIVITY,
kotlin(
"""
package foo
import androidx.appcompat.app.AppCompatActivity
import io.reactivex.rxjava3.core.Observable
class MyActivity: AppCompatActivity {
fun doSomething() {
val disposable = Observable.just(1, 2, 3).subscribe()
}
}
"""
).indented()
)
.run()
.expectClean()
}
@Test fun nestedDisposable() {
val propertiesFile = lenientPropertiesFile()
lint().files(
*jars(),
propertiesFile,
LIFECYCLE_OWNER,
ACTIVITY,
kotlin(
"""
package foo
import androidx.appcompat.app.AppCompatActivity
import io.reactivex.rxjava3.core.Observable
import io.reactivex.rxjava3.disposables.CompositeDisposable
class MyActivity: AppCompatActivity {
private val disposables = CompositeDisposable()
fun doSomething() {
disposables.add(
Observable.just(1, 2, 3).subscribe()
)
}
}
"""
).indented()
)
.run()
.expectClean()
}
@Test fun subscribeWithLambda() {
lint().files(
*jars(),
LIFECYCLE_OWNER,
ACTIVITY,
kotlin(
"""
package foo
import androidx.appcompat.app.AppCompatActivity
import io.reactivex.rxjava3.core.Observable
import io.reactivex.rxjava3.disposables.CompositeDisposable
import io.reactivex.rxjava3.disposables.Disposable
class MyActivity: AppCompatActivity {
private val disposables = CompositeDisposable()
fun doSomething() {
Observable.just(1,2,3).subscribe {}
}
}
"""
).indented()
)
.run()
.expect(
"""src/foo/MyActivity.kt:10: Error: ${AutoDisposeDetector.LINT_DESCRIPTION} [AutoDispose]
| Observable.just(1,2,3).subscribe {}
| ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|1 errors, 0 warnings""".trimMargin()
)
}
@Test fun checkLenientLintInIfExpression() {
val propertiesFile = lenientPropertiesFile()
lint().files(
*jars(),
propertiesFile,
LIFECYCLE_OWNER,
ACTIVITY,
kotlin(
"""
package foo
import androidx.appcompat.app.AppCompatActivity
import io.reactivex.rxjava3.core.Observable
import io.reactivex.rxjava3.disposables.CompositeDisposable
class MyActivity: AppCompatActivity {
private val disposables = CompositeDisposable()
fun doSomething(flag: Boolean) {
if (flag) {
Observable.just(1).subscribe()
} else {
Observable.just(2).subscribe()
}
}
}
"""
).indented()
)
.run()
.expect(
"""
|src/foo/MyActivity.kt:10: Error: ${AutoDisposeDetector.LINT_DESCRIPTION} [AutoDispose]
| Observable.just(1).subscribe()
| ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|src/foo/MyActivity.kt:12: Error: ${AutoDisposeDetector.LINT_DESCRIPTION} [AutoDispose]
| Observable.just(2).subscribe()
| ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|2 errors, 0 warnings""".trimMargin()
)
}
@Test fun checkLenientLintInIfExpressionCaptured() {
val propertiesFile = lenientPropertiesFile()
lint().files(
*jars(),
propertiesFile,
LIFECYCLE_OWNER,
ACTIVITY,
kotlin(
"""
package foo
import androidx.appcompat.app.AppCompatActivity
import io.reactivex.rxjava3.core.Observable
import io.reactivex.rxjava3.disposables.CompositeDisposable
class MyActivity: AppCompatActivity {
private val disposables = CompositeDisposable()
fun doSomething(flag: Boolean) {
val disposable = if (flag) {
Observable.just(1).subscribe()
} else {
Observable.just(2).subscribe()
}
}
}
"""
).indented()
)
.run()
.expectClean()
}
@Test fun checkLenientLintInWhenExpression() {
val propertiesFile = lenientPropertiesFile()
lint().files(
*jars(),
propertiesFile,
LIFECYCLE_OWNER,
ACTIVITY,
kotlin(
"""
package foo
import androidx.appcompat.app.AppCompatActivity
import io.reactivex.rxjava3.core.Observable
import io.reactivex.rxjava3.disposables.CompositeDisposable
class MyActivity: AppCompatActivity {
private val disposables = CompositeDisposable()
fun doSomething(flag: Boolean) {
when (flag) {
true -> Observable.just(1).subscribe()
false -> Observable.just(2).subscribe()
}
}
}
"""
).indented()
)
.run()
.expect(
"""
|src/foo/MyActivity.kt:10: Error: ${AutoDisposeDetector.LINT_DESCRIPTION} [AutoDispose]
| true -> Observable.just(1).subscribe()
| ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|src/foo/MyActivity.kt:11: Error: ${AutoDisposeDetector.LINT_DESCRIPTION} [AutoDispose]
| false -> Observable.just(2).subscribe()
| ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|2 errors, 0 warnings""".trimMargin()
)
}
@Test fun checkLenientLintInWhenExpressionCaptured() {
val propertiesFile = lenientPropertiesFile()
lint().files(
*jars(),
propertiesFile,
LIFECYCLE_OWNER,
ACTIVITY,
kotlin(
"""
package foo
import androidx.appcompat.app.AppCompatActivity
import io.reactivex.rxjava3.core.Observable
import io.reactivex.rxjava3.disposables.CompositeDisposable
class MyActivity: AppCompatActivity {
private val disposables = CompositeDisposable()
fun doSomething(flag: Boolean) {
val disposable = when (flag) {
true -> Observable.just(1).subscribe()
false -> Observable.just(2).subscribe()
}
}
}
"""
).indented()
)
.run()
.expectClean()
}
@Test fun checkLenientLintInLambdaWithUnitReturnExpression() {
val propertiesFile = lenientPropertiesFile()
lint().files(
*jars(),
propertiesFile,
LIFECYCLE_OWNER,
ACTIVITY,
kotlin(
"""
package foo
import androidx.appcompat.app.AppCompatActivity
import io.reactivex.rxjava3.core.Observable
import io.reactivex.rxjava3.disposables.CompositeDisposable
class MyActivity: AppCompatActivity {
private val disposables = CompositeDisposable()
fun doSomething() {
val receiveReturnUnitFn: (() -> Unit) -> Unit = {}
receiveReturnUnitFn {
Observable.just(1).subscribe()
}
}
}
"""
).indented()
)
.run()
.expect(
"""
|src/foo/MyActivity.kt:11: Error: ${AutoDisposeDetector.LINT_DESCRIPTION} [AutoDispose]
| Observable.just(1).subscribe()
| ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|1 errors, 0 warnings""".trimMargin()
)
}
@Test fun checkLenientLintInLambdaWithNonUnitReturnExpression() {
val propertiesFile = lenientPropertiesFile()
lint().files(
*jars(),
propertiesFile,
LIFECYCLE_OWNER,
ACTIVITY,
kotlin(
"""
package foo
import androidx.appcompat.app.AppCompatActivity
import io.reactivex.rxjava3.core.Observable
import io.reactivex.rxjava3.disposables.CompositeDisposable
class MyActivity: AppCompatActivity {
private val disposables = CompositeDisposable()
fun doSomething() {
val receiveReturnAnyFn: (() -> Any) -> Unit = {}
receiveReturnAnyFn {
Observable.just(1).subscribe()
"result"
}
}
}
"""
).indented()
)
.run()
.expect(
"""
|src/foo/MyActivity.kt:11: Error: ${AutoDisposeDetector.LINT_DESCRIPTION} [AutoDispose]
| Observable.just(1).subscribe()
| ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|1 errors, 0 warnings""".trimMargin()
)
}
@Test fun checkLenientLintInLambdaExpressionCaptured() {
val propertiesFile = lenientPropertiesFile()
lint().files(
*jars(),
propertiesFile,
LIFECYCLE_OWNER,
ACTIVITY,
kotlin(
"""
package foo
import androidx.appcompat.app.AppCompatActivity
import io.reactivex.rxjava3.core.Observable
import io.reactivex.rxjava3.disposables.CompositeDisposable
class MyActivity: AppCompatActivity {
private val disposables = CompositeDisposable()
fun doSomething() {
val receiveReturnAnyFn: (() -> Any) -> Unit = {}
receiveReturnAnyFn {
Observable.just(1).subscribe()
}
}
}
"""
).indented()
)
.run()
.expectClean()
}
@Test fun javaCapturedDisposable() {
val propertiesFile = lenientPropertiesFile()
lint().files(
*jars(),
propertiesFile,
LIFECYCLE_OWNER,
ACTIVITY,
java(
"""
package foo;
import androidx.appcompat.app.AppCompatActivity;
import io.reactivex.rxjava3.core.Observable;
import io.reactivex.rxjava3.disposables.Disposable;
class MyActivity extends AppCompatActivity {
fun doSomething() {
Disposable disposable = Observable.just(1, 2, 3).subscribe();
}
}
"""
).indented()
)
.run()
.expectClean()
}
@Test fun javaCapturedDisposableWithoutLenientProperty() {
val propertiesFile = lenientPropertiesFile(false)
lint().files(
*jars(),
propertiesFile,
LIFECYCLE_OWNER,
ACTIVITY,
java(
"""
package foo;
import androidx.appcompat.app.AppCompatActivity;
import io.reactivex.rxjava3.core.Observable;
import io.reactivex.rxjava3.disposables.Disposable;
class MyActivity extends AppCompatActivity {
fun doSomething() {
Disposable disposable = Observable.just(1, 2, 3).subscribe();
}
}
"""
).indented()
)
.run()
.expect(
"""src/foo/MyActivity.java:8: Error: ${AutoDisposeDetector.LINT_DESCRIPTION} [AutoDispose]
| Disposable disposable = Observable.just(1, 2, 3).subscribe();
| ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|1 errors, 0 warnings""".trimMargin()
)
}
@Test fun subscribeWithCapturedNonDisposableFromMethodReference() {
lint()
.files(
*jars(),
LIFECYCLE_OWNER,
FRAGMENT,
java(
"""
package foo;
import io.reactivex.rxjava3.core.Observable;
import io.reactivex.rxjava3.observers.DisposableObserver;
import io.reactivex.rxjava3.disposables.Disposable;
import io.reactivex.rxjava3.core.Observer;
import androidx.fragment.app.Fragment;
import io.reactivex.rxjava3.functions.Function;
class ExampleClass extends Fragment {
void names() {
Observable<Integer> obs = Observable.just(1, 2, 3, 4);
try {
Observer<Integer> observer = methodReferencable(obs::subscribeWith);
} catch (Exception e){
}
}
Observer<Integer> methodReferencable(Function<Observer<Integer>, Observer<Integer>> func) throws Exception {
return func.apply(new Observer<Integer>() {
@Override public void onSubscribe(Disposable d) {
}
@Override public void onNext(Integer integer) {
}
@Override public void onError(Throwable e) {
}
@Override public void onComplete() {
}
});
}
}
"""
).indented()
)
.run()
.expect(
"""src/foo/ExampleClass.java:13: Error: ${AutoDisposeDetector.LINT_DESCRIPTION} [AutoDispose]
| Observer<Integer> observer = methodReferencable(obs::subscribeWith);
| ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|1 errors, 0 warnings""".trimMargin()
)
}
@Test fun subscribeWithCapturedDisposableFromMethodReference() {
val propertiesFile = lenientPropertiesFile()
lint()
.files(
*jars(),
propertiesFile,
LIFECYCLE_OWNER,
FRAGMENT,
java(
"""
package foo;
import io.reactivex.rxjava3.core.Observable;
import io.reactivex.rxjava3.observers.DisposableObserver;
import io.reactivex.rxjava3.disposables.Disposable;
import io.reactivex.rxjava3.core.Observer;
import androidx.fragment.app.Fragment;
import io.reactivex.rxjava3.functions.Function;
class ExampleClass extends Fragment {
void names() {
Observable<Integer> obs = Observable.just(1, 2, 3, 4);
try {
Disposable disposable = methodReferencable(obs::subscribeWith);
} catch (Exception e){
}
}
DisposableObserver<Integer> methodReferencable(Function<DisposableObserver<Integer>, DisposableObserver<Integer>> func) throws Exception {
return func.apply(new DisposableObserver<Integer>() {
@Override
public void onNext(Integer integer) {
}
@Override
public void onError(Throwable e) {
}
@Override
public void onComplete() {
}
});
}
}
"""
).indented()
)
.run()
.expectClean()
}
@Test fun kotlinSubscribeWithCapturedNonDisposableFromMethodReference() {
val propertiesFile = lenientPropertiesFile()
lint()
.files(
*jars(),
propertiesFile,
LIFECYCLE_OWNER,
FRAGMENT,
kotlin(
"""
package foo
import io.reactivex.rxjava3.core.Observable
import io.reactivex.rxjava3.observers.DisposableObserver
import io.reactivex.rxjava3.disposables.Disposable
import io.reactivex.rxjava3.core.Observer
import androidx.fragment.app.Fragment
import io.reactivex.rxjava3.functions.Function
class ExampleClass: Fragment {
fun names() {
val observable: Observable<Int> = Observable.just(1)
val observer: Observer<Int> = methodReferencable(Function { observable.subscribeWith(it) })
}
@Throws(Exception::class)
internal fun methodReferencable(func: Function<Observer<Int>, Observer<Int>>): Observer<Int> {
return func.apply(object : Observer<Int> {
override fun onSubscribe(d: Disposable) {
}
override fun onNext(integer: Int) {
}
override fun onError(e: Throwable) {
}
override fun onComplete() {
}
})
}
}
"""
).indented()
)
.run()
.expect(
"""src/foo/ExampleClass.kt:12: Error: ${AutoDisposeDetector.LINT_DESCRIPTION} [AutoDispose]
| val observer: Observer<Int> = methodReferencable(Function { observable.subscribeWith(it) })
| ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|1 errors, 0 warnings""".trimMargin()
)
}
@Test fun kotlinSubscribeWithCapturedDisposableFromMethodReference() {
val propertiesFile = lenientPropertiesFile()
lint()
.files(
*jars(),
propertiesFile,
LIFECYCLE_OWNER,
FRAGMENT,
kotlin(
"""
package foo
import androidx.fragment.app.Fragment
import io.reactivex.rxjava3.core.Observable
import io.reactivex.rxjava3.core.Observer
import io.reactivex.rxjava3.disposables.Disposable
import io.reactivex.rxjava3.functions.Function
import io.reactivex.rxjava3.observers.DisposableObserver
class ExampleClass: Fragment {
fun names() {
val observable: Observable<Int> = Observable.just(1)
val disposable: Disposable = methodReferencable(Function { observable.subscribeWith(it) })
}
@Throws(Exception::class)
internal fun methodReferencable(func: Function<DisposableObserver<Int>, DisposableObserver<Int>>): DisposableObserver<Int> {
return func.apply(object : DisposableObserver<Int>() {
override fun onNext(integer: Int) {
}
override fun onError(e: Throwable) {
}
override fun onComplete() {
}
})
}
}
"""
).indented()
)
.run()
.expectClean()
}
@Test fun kotlinExtensionFunctionNotConfigured() {
lint()
.files(
*jars(),
LIFECYCLE_OWNER,
RX_KOTLIN,
FRAGMENT,
kotlin(
"""
package foo
import io.reactivex.rxjava3.core.Observable
import io.reactivex.rxjava3.observers.DisposableObserver
import io.reactivex.rxjava3.kotlin.subscribeBy
import androidx.fragment.app.Fragment
class ExampleClass : Fragment() {
fun names() {
val obs = Observable.just(1, 2, 3, 4)
obs.subscribeBy { }
}
}
"""
).indented()
)
.run()
.expectClean()
}
@Test fun kotlinExtensionFunctionNotHandled() {
lint()
.files(
*jars(),
propertiesFile(kotlinExtensionFunctions = "io.reactivex.rxjava3.kotlin.subscribers#subscribeBy"),
LIFECYCLE_OWNER,
RX_KOTLIN,
FRAGMENT,
kotlin(
"""
package foo
import io.reactivex.rxjava3.core.Observable
import io.reactivex.rxjava3.observers.DisposableObserver
import io.reactivex.rxjava3.kotlin.subscribeBy
import androidx.fragment.app.Fragment
class ExampleClass : Fragment() {
fun names() {
val obs = Observable.just(1, 2, 3, 4)
obs.subscribeBy { }
}
}
"""
).indented()
)
.run()
.expect(
"""src/foo/ExampleClass.kt:10: Error: ${AutoDisposeDetector.LINT_DESCRIPTION} [AutoDispose]
| obs.subscribeBy { }
| ~~~~~~~~~~~~~~~~~~~
|1 errors, 0 warnings""".trimMargin()
)
}
@Test fun subscribeWithCapturedNonDisposableType() {
lint()
.files(
*jars(),
LIFECYCLE_OWNER,
FRAGMENT,
java(
"""
package foo;
import io.reactivex.rxjava3.core.Observable;
import io.reactivex.rxjava3.observers.DisposableObserver;
import io.reactivex.rxjava3.disposables.Disposable;
import io.reactivex.rxjava3.core.Observer;
import androidx.fragment.app.Fragment;
class ExampleClass extends Fragment {
void names() {
Observable<Integer> obs = Observable.just(1, 2, 3, 4);
Observer<Integer> disposable = obs.subscribeWith(new Observer<Integer>() {
@Override
public void onSubscribe(Disposable d) {
}
@Override
public void onNext(Integer integer) {
}
@Override
public void onError(Throwable e) {}
@Override
public void onComplete() {}
});
}
}
"""
).indented()
)
.run()
.expect(
"""src/foo/ExampleClass.java:11: Error: ${AutoDisposeDetector.LINT_DESCRIPTION} [AutoDispose]
| Observer<Integer> disposable = obs.subscribeWith(new Observer<Integer>() {
| ^
|1 errors, 0 warnings""".trimMargin()
)
}
@Test fun subscribeWithCapturedDisposable() {
val propertiesFile = lenientPropertiesFile()
lint()
.files(
*jars(),
propertiesFile,
LIFECYCLE_OWNER,
FRAGMENT,
java(
"""
package foo;
import io.reactivex.rxjava3.core.Observable;
import io.reactivex.rxjava3.observers.DisposableObserver;
import io.reactivex.rxjava3.disposables.Disposable;
import androidx.fragment.app.Fragment;
class ExampleClass extends Fragment {
void names() {
Observable<Integer> obs = Observable.just(1, 2, 3, 4);
Disposable disposable = obs.subscribeWith(new DisposableObserver<Integer>() {
@Override
public void onNext(Integer integer) {
}
@Override
public void onError(Throwable e) {}
@Override
public void onComplete() {}
});
}
}
"""
).indented()
)
.run()
.expectClean()
}
@Test fun withScope_withScopeProvider_missingAutoDispose_shouldError() {
lint()
.files(
*jars(),
SCOPE_PROVIDER,
AUTODISPOSE_CONTEXT,
WITH_SCOPE_PROVIDER,
kotlin(
"""
package foo
import io.reactivex.rxjava3.core.Observable
import autodispose2.ScopeProvider
import autodispose2.autoDispose
import autodispose2.withScope
class ExampleClass {
lateinit var scopeProvider: ScopeProvider
fun names() {
val observable = Observable.just(1)
withScope(scopeProvider) {
observable.subscribe()
}
}
}
"""
).indented()
)
.allowCompilationErrors() // Until AGP 7.1.0 https://groups.google.com/g/lint-dev/c/BigCO8sMhKU
.run()
.expectErrorCount(1)
}
@Test fun withScope_withCompletable_missingAutoDispose_shouldError() {
lint()
.files(
*jars(),
AUTODISPOSE_CONTEXT,
WITH_SCOPE_COMPLETABLE,
kotlin(
"""
package foo
import io.reactivex.rxjava3.core.Completable
import io.reactivex.rxjava3.core.Observable
import autodispose2.withScope
class ExampleClass {
fun names() {
val observable = Observable.just(1)
withScope(Completable.complete()) {
observable.subscribe()
}
}
}
"""
).indented()
)
.allowCompilationErrors() // Until AGP 7.1.0 https://groups.google.com/g/lint-dev/c/BigCO8sMhKU
.run()
.expectErrorCount(1)
}
@Test fun withScope_withScopeProvider_expectClean() {
lint()
.files(
*jars(),
SCOPE_PROVIDER,
AUTODISPOSE_CONTEXT,
WITH_SCOPE_PROVIDER,
kotlin(
"""
package foo
import io.reactivex.rxjava3.core.Observable
import autodispose2.ScopeProvider
import autodispose2.autoDispose
import autodispose2.withScope
class ExampleClass {
lateinit var scopeProvider: ScopeProvider
fun names() {
val observable = Observable.just(1)
withScope(scopeProvider) {
observable.autoDispose().subscribe()
}
}
}
"""
).indented()
)
.allowCompilationErrors() // Until AGP 7.1.0 https://groups.google.com/g/lint-dev/c/BigCO8sMhKU
.run()
.expectClean()
}
@Test fun withScope_withCompletable_expectClean() {
lint()
.files(
*jars(),
AUTODISPOSE_CONTEXT,
WITH_SCOPE_COMPLETABLE,
kotlin(
"""
package foo
import io.reactivex.rxjava3.core.Completable
import autodispose2.autoDispose
import autodispose2.withScope
class ExampleClass {
fun names() {
val observable = Observable.just(1)
withScope(Completable.complete()) {
observable.autoDispose().subscribe()
}
}
}
"""
).indented()
)
.allowCompilationErrors() // Until AGP 7.1.0 https://groups.google.com/g/lint-dev/c/BigCO8sMhKU
.run()
.expectClean()
}
private fun jars(): Array<TestFile> {
val classLoader = AutoDisposeDetector::class.java.classLoader
return arrayOf(
LibraryReferenceTestFile(
File(classLoader.getResource("rxjava-3.1.0.jar")!!.toURI()),
),
LibraryReferenceTestFile(
File(classLoader.getResource("autodispose-2.0.0.jar")!!.toURI())
)
)
}
override fun getDetector(): Detector {
return AutoDisposeDetector()
}
override fun getIssues(): List<Issue> {
return listOf(AutoDisposeDetector.ISSUE)
}
}
| static-analysis/autodispose-lint/src/test/kotlin/autodispose2/lint/AutoDisposeDetectorTest.kt | 2546425755 |
package com.zj.example.kotlin.basicsknowledge
/**
* 伴生对象
* Created by zhengjiong
* date: 2017/9/16 17:13
*/
fun main(vararg args: String) {
//minOf是包级函数
val a = minOf(1, 2)
var l = Latitude.ofDouble(1.0)
var l2 = Latitude.ofLatitude(l)
println(l)//1.0
println(l2)//1.0
println(Latitude.TAG)//Latitude
}
/**
* 构造函数设置成private后, 外部就不能在通过Latitude()的方式实例化对象
* companion object 就是伴生对象, 可以对象中的方法都相当于是java中的
* 静态(static)方法和静态(static)对象, 如果想在java中调用伴生对象中的方法需要加注
* 解@JvmStatic(用于方法), @JvmField(用于对象)
*/
class Latitude private constructor(val value: Double) {
/**
* 每个类都可以有一个伴生对象
* 伴生对象的成员全局只有一份,类似java的静态成员
*/
companion object {
@JvmStatic
fun ofDouble(d: Double): Latitude = Latitude(d)
fun ofLatitude(latitude: Latitude) = Latitude(latitude.value)
@JvmField
val TAG: String = "Latitude"
}
override fun toString(): String {
return value.toString()
}
} | src/main/kotlin/com/zj/example/kotlin/basicsknowledge/29.CompanionObjectExample伴生对象.kt | 743092534 |
package io.requery.android.example.app.model
import android.os.Parcelable
import io.requery.*
import java.util.*
@Entity
interface Person : Parcelable, Persistable {
@get:Key
@get:Generated
val id: Int
var name: String
var email: String
var birthday: Date
var age: Int
@get:ForeignKey
@get:OneToOne
var address: Address?
@get:OneToMany(mappedBy = "owner")
val phoneNumbers: MutableSet<Phone>
@get:Column(unique = true)
var uuid: UUID
}
| requery-android/example-kotlin/src/main/kotlin/io/requery/android/example/app/model/Person.kt | 2401254462 |
package org.owntracks.android.ui.welcome
import android.content.Context
import android.os.Bundle
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import androidx.fragment.app.activityViewModels
import androidx.fragment.app.viewModels
import com.google.android.gms.common.ConnectionResult
import com.google.android.gms.common.GoogleApiAvailability
import com.google.android.material.snackbar.Snackbar
import dagger.hilt.android.AndroidEntryPoint
import org.owntracks.android.R
import org.owntracks.android.databinding.UiWelcomePlayBinding
import javax.inject.Inject
@AndroidEntryPoint
class PlayFragment @Inject constructor() : WelcomeFragment() {
private val viewModel: WelcomeViewModel by activityViewModels()
private val playFragmentViewModel: PlayFragmentViewModel by viewModels()
private lateinit var binding: UiWelcomePlayBinding
private val googleAPI = GoogleApiAvailability.getInstance()
override fun shouldBeDisplayed(context: Context): Boolean =
googleAPI.isGooglePlayServicesAvailable(context) != ConnectionResult.SUCCESS
override fun onCreateView(
inflater: LayoutInflater,
container: ViewGroup?,
savedInstanceState: Bundle?,
): View? {
binding = UiWelcomePlayBinding.inflate(inflater, container, false)
binding.vm = playFragmentViewModel
binding.lifecycleOwner = this.viewLifecycleOwner
binding.recover.setOnClickListener {
requestFix()
}
return binding.root
}
fun onPlayServicesResolutionResult() {
checkGooglePlayservicesIsAvailable()
}
fun requestFix() {
val result = googleAPI.isGooglePlayServicesAvailable(requireContext())
if (!googleAPI.showErrorDialogFragment(
requireActivity(),
result,
PLAY_SERVICES_RESOLUTION_REQUEST
)
) {
Snackbar.make(
binding.root,
getString(R.string.play_services_not_available),
Snackbar.LENGTH_SHORT
).show()
}
checkGooglePlayservicesIsAvailable()
}
private fun checkGooglePlayservicesIsAvailable() {
val nextEnabled =
when (val result = googleAPI.isGooglePlayServicesAvailable(requireContext())) {
ConnectionResult.SUCCESS -> {
playFragmentViewModel.setPlayServicesAvailable(getString(R.string.play_services_now_available))
true
}
ConnectionResult.SERVICE_VERSION_UPDATE_REQUIRED, ConnectionResult.SERVICE_UPDATING -> {
playFragmentViewModel.setPlayServicesNotAvailable(
true,
getString(R.string.play_services_update_required)
)
false
}
else -> {
playFragmentViewModel.setPlayServicesNotAvailable(
googleAPI.isUserResolvableError(
result
),
getString(R.string.play_services_not_available)
)
false
}
}
if (nextEnabled) {
viewModel.setWelcomeCanProceed()
} else {
viewModel.setWelcomeCannotProceed()
}
}
override fun onResume() {
super.onResume()
checkGooglePlayservicesIsAvailable()
}
companion object {
const val PLAY_SERVICES_RESOLUTION_REQUEST = 1
}
}
| project/app/src/gms/java/org/owntracks/android/ui/welcome/PlayFragment.kt | 2408347461 |
/*
* Copyright 2020 Michael Rozumyanskiy
*
* 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
*
* http://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.
*/
package io.michaelrocks.lightsaber.processor.model
import io.michaelrocks.grip.mirrors.MethodMirror
import io.michaelrocks.grip.mirrors.Type
data class FactoryProvisionPoint(
val containerType: Type.Object,
val method: MethodMirror,
val injectionPoint: FactoryInjectionPoint
)
| processor/src/main/java/io/michaelrocks/lightsaber/processor/model/FactoryProvisionPoint.kt | 883351974 |
/*
* Copyright (C) 2017 John Leacox
* Copyright (C) 2017 Brian van de Boogaard
*
* 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
*
* http://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.
*/
package dev.misfitlabs.kotlinguice4.benchmarks
import com.google.inject.AbstractModule
import com.google.inject.Guice
import com.google.inject.Key
import com.google.inject.TypeLiteral
import java.util.concurrent.TimeUnit
import org.openjdk.jmh.annotations.Benchmark
import org.openjdk.jmh.annotations.BenchmarkMode
import org.openjdk.jmh.annotations.CompilerControl
import org.openjdk.jmh.annotations.Fork
import org.openjdk.jmh.annotations.Measurement
import org.openjdk.jmh.annotations.Mode
import org.openjdk.jmh.annotations.OutputTimeUnit
import org.openjdk.jmh.annotations.Scope
import org.openjdk.jmh.annotations.State
import org.openjdk.jmh.annotations.Warmup
/**
* Benchmarks showing the performance of Guice bindings from Kotlin without using the kotlin-guice
* library extensions.
*
* @author John Leacox
*/
@Fork(1)
@Warmup(iterations = 10)
@Measurement(iterations = 10)
@State(Scope.Benchmark)
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.MILLISECONDS)
@CompilerControl(CompilerControl.Mode.DONT_INLINE)
open class KotlinStandardInjectorBenchmark {
@Benchmark fun getSimpleInstance() {
val injector = Guice.createInjector(object : AbstractModule() {
override fun configure() {
bind(Simple::class.java).to(SimpleImpl::class.java)
}
})
val instance = injector.getInstance(Simple::class.java)
instance.value()
}
@Benchmark fun getComplexIterableInstance() {
val injector = Guice.createInjector(object : AbstractModule() {
override fun configure() {
bind(object : TypeLiteral<Complex<Iterable<String>>>() {})
.to(object : TypeLiteral<ComplexImpl<Iterable<String>>>() {})
}
})
val instance = injector
.getInstance(Key.get(object : TypeLiteral<Complex<Iterable<String>>>() {}))
instance.value()
}
@Benchmark fun getComplexStringInstance() {
val injector = Guice.createInjector(object : AbstractModule() {
override fun configure() {
bind(object : TypeLiteral<Complex<String>>() {}).to(StringComplexImpl::class.java)
}
})
val instance = injector.getInstance(Key.get(object : TypeLiteral<Complex<String>>() {}))
instance.value()
}
}
| kotlin-guice/src/jmh/kotlin/dev/misfitlabs/kotlinguice4/benchmarks/KotlinStandardInjectorBenchmark.kt | 1671836450 |
package at.cpickl.gadsu.client.view.detail
import at.cpickl.gadsu.client.Client
import at.cpickl.gadsu.client.xprops.model.XPropEnum
import at.cpickl.gadsu.development.debugColor
import at.cpickl.gadsu.tcm.model.XProps
import at.cpickl.gadsu.view.LiveSearchField
import at.cpickl.gadsu.view.ViewNames
import at.cpickl.gadsu.view.components.ExpandCollapseListener
import at.cpickl.gadsu.view.components.ExpandCollapsePanel
import at.cpickl.gadsu.view.components.panels.GridPanel
import at.cpickl.gadsu.view.components.panels.fillAll
import at.cpickl.gadsu.view.language.Labels
import at.cpickl.gadsu.view.swing.scrolled
import at.cpickl.gadsu.view.tree.TreeSearcher
import at.cpickl.gadsu.view.tree.buildTree
import com.github.christophpickl.kpotpourri.common.logging.LOG
import java.awt.BorderLayout
import java.awt.Color
import java.awt.GridBagConstraints
import javax.swing.BoxLayout
import javax.swing.JButton
import javax.swing.JLabel
import javax.swing.JPanel
class ClientTabTcm2(
initialClient: Client
) : DefaultClientTab(
tabTitle = Labels.Tabs.ClientTcm,
type = ClientTabType.TCM,
scrolled = false
) {
private val container = JPanel().apply {
layout = BorderLayout()
}
private val xpropEnums = listOf(
listOf(XProps.Hungry, XProps.BodyConception),
listOf(XProps.ChiStatus, XProps.Digestion, XProps.Temperature),
listOf(XProps.Impression, XProps.Liquid, XProps.Menstruation, XProps.Sleep)
)
private val viewPanel = TcmViewPanel(xpropEnums)
private val editPanel = TcmEditPanel(xpropEnums)
init {
container.debugColor = Color.RED
c.fillAll()
add(container)
viewPanel.initClient(initialClient)
editPanel.initClient(initialClient)
changeContentTo(editPanel)
editPanel.btnFinishEdit.addActionListener {
changeContentTo(viewPanel)
}
viewPanel.btnStartEdit.addActionListener {
changeContentTo(editPanel)
}
}
override fun isModified(client: Client): Boolean {
// TODO implement me
return false
}
override fun updateFields(client: Client) {
// TODO implement me
}
private fun changeContentTo(panel: JPanel) {
container.removeAll()
container.add(panel, BorderLayout.CENTER)
container.revalidate()
container.repaint()
}
}
private class TcmViewPanel(xpropEnums: List<List<XPropEnum>>) : GridPanel() {
// TODO buttons same width
val btnStartEdit = JButton("Bearbeiten")
init {
add(btnStartEdit)
c.gridy++
c.fillAll()
add(JPanel().apply {
layout = BoxLayout(this, BoxLayout.Y_AXIS)
xpropEnums.forEach {
add(JLabel(it[0].label))
// go through all, and check if client has selected => render label (with header); and note
}
})
}
fun initClient(client: Client) {
println("initClient(client=$client)")
}
}
typealias XPropEnums = List<List<XPropEnum>>
private class TcmEditPanel(xPropEnums: XPropEnums) : GridPanel(), ExpandCollapseListener {
private val log = LOG {}
private val searchField = LiveSearchField(ViewNames.Client.InputTcmSearchField)
val btnFinishEdit = JButton("Fertig")
private val trees = xPropEnums.map { buildTree(it) }
init {
TreeSearcher(searchField, trees) // will work async
debugColor = Color.GREEN
// TODO tree.initSelected
c.weightx = 0.0
add(btnFinishEdit)
c.gridx++
c.fill = GridBagConstraints.HORIZONTAL
c.weightx = 1.0
add(searchField.asComponent())
c.gridx++
c.weightx = 0.0
add(ExpandCollapsePanel(this))
c.gridx = 0
c.gridy++
c.gridwidth = 3
c.fillAll()
add(GridPanel().apply {
c.anchor = GridBagConstraints.NORTH
c.weightx = 0.3
c.weighty = 1.0
c.fill = GridBagConstraints.BOTH
trees.forEach { tree ->
add(tree.scrolled())
c.gridx++
}
})
}
override fun onExpand() {
log.trace { "onExpand()" }
trees.forEach { tree ->
tree.expandAll()
}
}
override fun onCollapse() {
log.trace { "onCollapse()" }
trees.forEach { tree ->
tree.collapseAll()
}
}
fun initClient(client: Client) {
log.trace { "initClient(client)" }
trees.forEach { tree ->
tree.initSelected(client.cprops.map { it.clientValue }.flatten().toSet())
}
}
}
| src/main/kotlin/at/cpickl/gadsu/client/view/detail/tab_tcm2.kt | 612153855 |
/*
* Copyright (C) 2016 - Niklas Baudy, Ruben Gees, Mario Đanić and contributors
*
* 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
*
* http://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.
*/
@file:JvmName("EmojiTextViews")
package com.vanniktech.emoji
import android.util.AttributeSet
import android.widget.TextView
import androidx.annotation.Px
import androidx.annotation.StyleableRes
@Px fun TextView.init(
attrs: AttributeSet?,
@StyleableRes styleable: IntArray,
@StyleableRes emojiSizeAttr: Int,
): Float {
if (!isInEditMode) {
EmojiManager.verifyInstalled()
}
val fontMetrics = paint.fontMetrics
val defaultEmojiSize = fontMetrics.descent - fontMetrics.ascent
val emojiSize: Float = if (attrs == null) {
defaultEmojiSize
} else {
val a = context.obtainStyledAttributes(attrs, styleable)
try {
a.getDimension(emojiSizeAttr, defaultEmojiSize)
} finally {
a.recycle()
}
}
text = text // Reassign.
return emojiSize
}
| emoji/src/androidMain/kotlin/com/vanniktech/emoji/EmojiTextViews.kt | 182779603 |
package ee.system
open class SocketService : SocketServiceBase {
companion object {
val EMPTY = SocketServiceBase.EMPTY
}
constructor(elName: String = "", category: String = "", dependsOn: MutableList<Service> = arrayListOf(),
dependsOnMe: MutableList<Service> = arrayListOf(), host: String = "", port: Int = 0) : super(elName, category,
dependsOn, dependsOnMe, host, port) {
}
}
| ee-system/src/main/kotlin/ee/system/SocketService.kt | 1733313565 |
/*
* Copyright 2016 Karl Tauber
*
* 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
*
* http://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.
*/
package com.devcharly.kotlin.ant
import org.apache.tools.ant.util.PackageNameMapper
/******************************************************************************
DO NOT EDIT - this file was generated
******************************************************************************/
interface IPackageNameMapperNested {
fun packagemapper(
handledirsep: Boolean? = null,
casesensitive: Boolean? = null,
from: String? = null,
to: String? = null)
{
_addPackageNameMapper(PackageNameMapper().apply {
_init(handledirsep, casesensitive, from, to)
})
}
fun _addPackageNameMapper(value: PackageNameMapper)
}
fun IGlobPatternMapperNested.packagemapper(
handledirsep: Boolean? = null,
casesensitive: Boolean? = null,
from: String? = null,
to: String? = null)
{
_addGlobPatternMapper(PackageNameMapper().apply {
_init(handledirsep, casesensitive, from, to)
})
}
fun IFileNameMapperNested.packagemapper(
handledirsep: Boolean? = null,
casesensitive: Boolean? = null,
from: String? = null,
to: String? = null)
{
_addFileNameMapper(PackageNameMapper().apply {
_init(handledirsep, casesensitive, from, to)
})
}
fun PackageNameMapper._init(
handledirsep: Boolean?,
casesensitive: Boolean?,
from: String?,
to: String?)
{
if (handledirsep != null)
setHandleDirSep(handledirsep)
if (casesensitive != null)
setCaseSensitive(casesensitive)
if (from != null)
setFrom(from)
if (to != null)
setTo(to)
}
| src/main/kotlin/com/devcharly/kotlin/ant/util/packagenamemapper.kt | 552704972 |
package melquelolea.vefexchange.data
import android.content.Context
import com.google.gson.JsonObject
import melquelolea.vefexchange.R
import okhttp3.OkHttpClient
import okhttp3.logging.HttpLoggingInterceptor
import retrofit2.Retrofit
import retrofit2.adapter.rxjava.RxJavaCallAdapterFactory
import retrofit2.converter.gson.GsonConverterFactory
import retrofit2.http.GET
import rx.Observable
/**
* Created by Patrick Rengifo on 11/29/16.
* Definition of the Api to get the data from the exchange
*/
internal object CoinBaseApi {
internal interface ApiInterface {
@GET("prices/spot_rate")
fun bitcoinUSD(): Observable<JsonObject>
}
private var adapter: ApiInterface? = null
fun getClient(context: Context): ApiInterface {
if (adapter == null) {
// Log
val logging = HttpLoggingInterceptor()
// set your desired log level
logging.level = HttpLoggingInterceptor.Level.BASIC
// OkHttpClient
val httpClient = OkHttpClient.Builder()
httpClient.addInterceptor { chain ->
val original = chain.request()
// Customize the request
val request = original.newBuilder()
.header("X-Device", "Android")
.build()
// Customize or return the response
chain.proceed(request)
}
// add logging as last interceptor
httpClient.addInterceptor(logging)
val client = httpClient.build()
val restAdapter = Retrofit.Builder()
.addCallAdapterFactory(RxJavaCallAdapterFactory.create())
.addConverterFactory(GsonConverterFactory.create())
.baseUrl(context.getString(R.string.coinbase_endpoint))
.client(client)
.build()
adapter = restAdapter.create(ApiInterface::class.java)
}
return adapter!!
}
}
| mobile/src/main/java/melquelolea/vefexchange/data/CoinBaseApi.kt | 2010459238 |
package io.kotest.mpp
import kotlin.reflect.KClass
/**
* Returns the longest possible name available for this class.
* That is, in order, the FQN, the simple name, or <none>.
*/
fun KClass<*>.bestName(): String = fqn() ?: simpleName ?: "<none>"
/**
* Returns the fully qualified name for this class, or null
*/
expect fun KClass<*>.fqn(): String?
/**
* Returns the annotations on this class or empty list if not supported
*/
expect fun KClass<*>.annotations(): List<Annotation>
/**
* Finds the first annotation of type T on this class, or returns null if annotations
* are not supported on this platform or the annotation is missing.
*/
inline fun <reified T> KClass<*>.annotation(): T? = annotations().filterIsInstance<T>().firstOrNull()
/**
* Returns true if this KClass is a data class, false if it is not, or null if the functionality
* is not supported on the platform.
*/
expect val <T : Any> KClass<T>.isDataClass: Boolean?
/**
* Returns the names of the parameters if supported. Eg, for `fun foo(a: String, b: Boolean)` on the JVM
* it would return [a, b] and on unsupported platforms an empty list.
*/
expect val Function<*>.paramNames: List<String>
| kotest-mpp/src/commonMain/kotlin/io/kotest/mpp/reflectutils.kt | 4211905391 |
/**
* Copyright 2021 Carl-Philipp Harmant
*
*
* 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
*
*
* http://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.
*/
package fr.cph.chicago.core.model
import fr.cph.chicago.core.model.enumeration.BusDirection
/**
* Bus directions entity
*
* @author Carl-Philipp Harmant
* @version 1
*/
class BusDirections(val id: String) {
// Need a list because we access with indexes
val busDirections: MutableList<BusDirection> = mutableListOf()
fun addBusDirection(busDirection: BusDirection) {
if (!busDirections.contains(busDirection)) {
busDirections.add(busDirection)
}
}
}
| android-app/src/main/kotlin/fr/cph/chicago/core/model/BusDirections.kt | 3708665978 |
/**
* Swaggy Jenkins
* Jenkins API clients generated from Swagger / Open API specification
*
* The version of the OpenAPI document: 1.5.1-pre.0
* Contact: [email protected]
*
* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
* https://openapi-generator.tech
* Do not edit the class manually.
*/
package org.openapitools.database.models
import org.ktorm.dsl.*
import org.ktorm.schema.*
import org.ktorm.database.Database
import .*
/**
*
* @param classes
* @param propertyClass
*/
object ClassesByClasss : BaseTable<ClassesByClass>("ClassesByClass") {
val propertyClass = text("_class") /* null */
/**
* Create an entity of type ClassesByClass from the model
*/
override fun doCreateEntity(row: QueryRowSet, withReferences: Boolean) = ClassesByClass(
classes = emptyList() /* kotlin.Array<kotlin.String>? */,
propertyClass = row[propertyClass] /* kotlin.String? */
)
/**
* Assign all the columns from the entity of type ClassesByClass to the DML expression.
*
* Usage:
*
* ```kotlin
* let entity = ClassesByClass()
* database.update(ClassesByClasss, {
* assignFrom(entity)
* })
* ```
* @return the builder with the columns for the update or insert.
*/
fun AssignmentsBuilder.assignFrom(entity: ClassesByClass) {
this.apply {
set(ClassesByClasss.propertyClass, entity.propertyClass)
}
}
}
object ClassesByClassClasses : BaseTable<Pair<kotlin.Long, kotlin.String>>("ClassesByClassClasses") {
val classesByClass = long("classesByClass")
val classes = text("classes")
override fun doCreateEntity(row: QueryRowSet, withReferences: Boolean): Pair<kotlin.Long, kotlin.String> =
Pair(row[classesByClass] ?: 0, row[classes] ?: "")
fun AssignmentsBuilder.assignFrom(entity: Pair<kotlin.Long, kotlin.String>) {
this.apply {
set(ClassesByClassClasses.classesByClass, entity.first)
set(ClassesByClassClasses.classes, entity.second)
}
}
}
| clients/ktorm-schema/generated/src/main/kotlin/org/openapitools/database/models/ClassesByClass.kt | 1499912967 |
package com.makingiants.todayhistory.screens.today
import android.os.Bundle
import android.support.v4.widget.SwipeRefreshLayout
import android.support.v7.widget.DefaultItemAnimator
import android.support.v7.widget.LinearLayoutManager
import android.support.v7.widget.Toolbar
import android.view.View
import com.makingiants.today.api.repository.history.pojo.Event
import com.makingiants.todayhistory.R
import com.makingiants.todayhistory.TodayApp
import com.makingiants.todayhistory.utils.SpacesItemDecoration
import com.makingiants.todayhistory.utils.base.BaseActivityView
import com.makingiants.todayhistory.utils.refresh_layout.ScrollEnabler
import com.squareup.picasso.Picasso
import kotlinx.android.synthetic.main.today_activity.*
import javax.inject.Inject
class TodayActivity : BaseActivityView(), TodayView, SwipeRefreshLayout.OnRefreshListener, ScrollEnabler {
@Inject lateinit var presenter: TodayPresenter
val todayAdapter: TodayAdapter by lazy { TodayAdapter(Picasso.with(applicationContext)) }
//<editor-fold desc="Activity">
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.today_activity)
setSupportActionBar(toolbar as Toolbar)
(application as TodayApp).applicationComponent.inject(this)
presenter.attach(this)
}
override fun onDestroy() {
super.onDestroy()
presenter.unAttach()
swipeRefreshLayout.setScrollEnabler(null)
swipeRefreshLayout.setOnRefreshListener(null)
}
//</editor-fold>
//<editor-fold desc="TodayView">
override fun initViews() {
recyclerView.apply {
adapter = todayAdapter
layoutManager = LinearLayoutManager(applicationContext)
itemAnimator = DefaultItemAnimator()
addItemDecoration(SpacesItemDecoration(16))
}
swipeRefreshLayout.apply {
setOnRefreshListener(this@TodayActivity)
setScrollEnabler(this@TodayActivity)
setColorSchemeColors(R.color.colorAccent, R.color.colorPrimary)
}
}
override fun showEvents(events: List<Event>) {
recyclerView.visibility = View.VISIBLE
todayAdapter.setEvents(events)
}
override fun hideEvents() = recyclerView.setVisibility(View.GONE)
override fun showEmptyViewProgress() = progressView.setVisibility(View.VISIBLE)
override fun dismissEmptyViewProgress() = progressView.setVisibility(View.GONE)
override fun showReloadProgress() = swipeRefreshLayout.setRefreshing(true)
override fun dismissReloadProgress() = swipeRefreshLayout.setRefreshing(false)
override fun showErrorView(title: String, message: String) {
errorTitleView.text = title
errorMessageTextView.text = message
errorView.visibility = View.VISIBLE
}
override fun hideErrorView() = errorView.setVisibility(View.GONE)
override fun showErrorToast(message: String) = showToast(message)
override fun showEmptyView() = emptyView.setVisibility(View.VISIBLE)
override fun hideEmptyView() = emptyView.setVisibility(View.GONE)
override fun showErrorDialog(throwable: Throwable) = super.showError(throwable)
//</editor-fold>
//<editor-fold desc="SwipeRefreshLayout.OnRefreshListener">
override fun onRefresh() = presenter.onRefresh()
//</editor-fold>
//<editor-fold desc="ScrollEnabler">
override fun canScrollUp(): Boolean =
recyclerView.visibility === View.VISIBLE && recyclerView.canScrollVertically(-1)
//</editor-fold>
}
| app/src/main/kotlin/com/makingiants/todayhistory/screens/today/TodayActivity.kt | 1388762217 |
package mil.nga.giat.mage.map
import android.util.Log
import com.google.android.gms.maps.model.UrlTileProvider
import mil.nga.giat.mage.map.cache.URLCacheOverlay
import java.net.MalformedURLException
import java.net.URL
class XYZTileProvider(
width: Int,
height: Int,
private val myOverlay: URLCacheOverlay
) : UrlTileProvider(width, height) {
override fun getTileUrl(x: Int, y: Int, z: Int): URL? {
val path = myOverlay.url.toString()
.replace("{s}", "")
.replace("{x}", x.toString())
.replace("{y}", y.toString())
.replace("{z}", z.toString())
return try {
URL(path)
} catch (e: MalformedURLException) {
Log.w(LOG_NAME, "Problem with URL $path", e)
null
}
}
companion object {
private val LOG_NAME = XYZTileProvider::class.java.name
}
} | mage/src/main/java/mil/nga/giat/mage/map/XYZTileProvider.kt | 2721548463 |
package mil.nga.giat.mage.form.view
import android.content.res.Configuration
import android.graphics.Color
import android.os.Bundle
import androidx.compose.runtime.*
import androidx.compose.ui.platform.LocalContext
import androidx.compose.ui.platform.LocalLifecycleOwner
import androidx.compose.ui.viewinterop.AndroidView
import androidx.core.content.res.ResourcesCompat
import androidx.lifecycle.Lifecycle
import androidx.lifecycle.LifecycleEventObserver
import androidx.preference.PreferenceManager
import com.bumptech.glide.Glide
import com.google.android.gms.maps.CameraUpdateFactory
import com.google.android.gms.maps.MapView
import com.google.android.gms.maps.model.*
import com.google.maps.android.ktx.*
import kotlinx.coroutines.launch
import mil.nga.geopackage.map.geom.GoogleMapShapeConverter
import mil.nga.giat.mage.R
import mil.nga.giat.mage.form.FormState
import mil.nga.giat.mage.form.field.FieldValue
import mil.nga.giat.mage.glide.target.MarkerTarget
import mil.nga.giat.mage.map.annotation.MapAnnotation
import mil.nga.giat.mage.map.annotation.ShapeStyle
import mil.nga.giat.mage.observation.ObservationLocation
import mil.nga.sf.GeometryType
import mil.nga.sf.util.GeometryUtils
data class MapState(val center: LatLng?, val zoom: Float?)
@Composable
fun MapViewContent(
map: MapView,
mapState: MapState,
formState: FormState?,
location: ObservationLocation
) {
val context = LocalContext.current
var mapInitialized by remember(map) { mutableStateOf(false) }
val primaryFieldState = formState?.fields?.find { it.definition.name == formState.definition.primaryMapField }
val primary = (primaryFieldState?.answer as? FieldValue.Text)?.text
val secondaryFieldState = formState?.fields?.find { it.definition.name == formState.definition.secondaryMapField }
val secondary = (secondaryFieldState?.answer as? FieldValue.Text)?.text
LaunchedEffect(map, mapInitialized) {
if (!mapInitialized) {
val googleMap = map.awaitMap()
googleMap.uiSettings.isMapToolbarEnabled = false
if (mapState.center != null && mapState.zoom != null) {
googleMap.moveCamera(CameraUpdateFactory.newLatLngZoom(mapState.center, mapState.zoom))
}
val preferences = PreferenceManager.getDefaultSharedPreferences(context)
googleMap.mapType = preferences.getInt(context.getString(R.string.baseLayerKey), context.resources.getInteger(R.integer.baseLayerDefaultValue))
val dayNightMode: Int = context.resources.configuration.uiMode and Configuration.UI_MODE_NIGHT_MASK
if (dayNightMode == Configuration.UI_MODE_NIGHT_NO) {
googleMap.setMapStyle(null)
} else {
googleMap.setMapStyle(MapStyleOptions.loadRawResourceStyle(context, R.raw.map_theme_night))
}
mapInitialized = true
}
}
val scope = rememberCoroutineScope()
AndroidView({ map }) { mapView ->
scope.launch {
val googleMap = mapView.awaitMap()
googleMap.clear()
if (location.geometry.geometryType == GeometryType.POINT) {
val centroid = GeometryUtils.getCentroid(location.geometry)
val point = LatLng(centroid.y, centroid.x)
val marker = googleMap.addMarker {
position(point)
visible(false)
}
marker?.tag = formState?.id
if (formState != null) {
Glide.with(context)
.asBitmap()
.load(MapAnnotation.fromObservationProperties(formState.id ?: 0, location.geometry, location.time, location.accuracy, formState.eventId, formState.definition.id, primary, secondary, context))
.error(R.drawable.default_marker)
.into(MarkerTarget(context, marker, 32, 32))
}
if (!location.provider.equals(ObservationLocation.MANUAL_PROVIDER, true) && location.accuracy != null) {
googleMap.addCircle {
fillColor(ResourcesCompat.getColor(context.resources, R.color.accuracy_circle_fill, null))
strokeColor(ResourcesCompat.getColor(context.resources, R.color.accuracy_circle_stroke, null))
strokeWidth(2f)
center(point)
radius(location.accuracy.toDouble())
}
}
} else {
val shape = GoogleMapShapeConverter().toShape(location.geometry).shape
val style = ShapeStyle.fromForm(formState, context)
if (shape is PolylineOptions) {
googleMap.addPolyline {
addAll(shape.points)
width(style.strokeWidth)
color(style.strokeColor)
}
} else if (shape is PolygonOptions) {
googleMap.addPolygon {
addAll(shape.points)
for (hole in shape.holes) {
addHole(hole)
}
strokeWidth(style.strokeWidth)
strokeColor(style.strokeColor)
fillColor(style.fillColor)
}
}
}
googleMap.animateCamera(location.getCameraUpdate(mapView, true, 1.0f / 6))
}
}
}
@Composable
fun MapViewContent(
map: MapView,
location: ObservationLocation
) {
val context = LocalContext.current
var mapInitialized by remember(map) { mutableStateOf(false) }
LaunchedEffect(map, mapInitialized) {
if (!mapInitialized) {
val googleMap = map.awaitMap()
googleMap.uiSettings.isMapToolbarEnabled = false
val preferences = PreferenceManager.getDefaultSharedPreferences(context)
googleMap.mapType = preferences.getInt(context.getString(R.string.baseLayerKey), context.resources.getInteger(R.integer.baseLayerDefaultValue))
val dayNightMode: Int = context.resources.configuration.uiMode and Configuration.UI_MODE_NIGHT_MASK
if (dayNightMode == Configuration.UI_MODE_NIGHT_NO) {
googleMap.setMapStyle(null)
} else {
googleMap.setMapStyle(MapStyleOptions.loadRawResourceStyle(context, R.raw.map_theme_night))
}
mapInitialized = true
}
}
val scope = rememberCoroutineScope()
AndroidView({ map }) { mapView ->
scope.launch {
val googleMap = mapView.awaitMap()
googleMap.clear()
if (location.geometry.geometryType == GeometryType.POINT) {
val centroid = GeometryUtils.getCentroid(location.geometry)
val point = LatLng(centroid.y, centroid.x)
googleMap.addMarker {
position(point)
val color: Int = Color.parseColor("#1E88E5")
val hsv = FloatArray(3)
Color.colorToHSV(color, hsv)
icon(BitmapDescriptorFactory.defaultMarker(hsv[0]))
}
} else {
val shape = GoogleMapShapeConverter().toShape(location.geometry).shape
if (shape is PolylineOptions) {
googleMap.addPolyline {
addAll(shape.points)
}
} else if (shape is PolygonOptions) {
googleMap.addPolygon {
addAll(shape.points)
for (hole in shape.holes) {
addHole(hole)
}
}
}
}
googleMap.moveCamera(location.getCameraUpdate(mapView))
}
}
}
@Composable
fun rememberMapViewWithLifecycle(): MapView {
val context = LocalContext.current
val mapView = remember {
MapView(context).apply {
id = R.id.map
}
}
// Makes MapView follow the lifecycle of this composable
val lifecycleObserver = rememberMapLifecycleObserver(mapView)
val lifecycle = LocalLifecycleOwner.current.lifecycle
DisposableEffect(lifecycle) {
lifecycle.addObserver(lifecycleObserver)
onDispose {
lifecycle.removeObserver(lifecycleObserver)
}
}
return mapView
}
@Composable
private fun rememberMapLifecycleObserver(mapView: MapView): LifecycleEventObserver =
remember(mapView) {
LifecycleEventObserver { _, event ->
when (event) {
Lifecycle.Event.ON_CREATE -> mapView.onCreate(Bundle())
Lifecycle.Event.ON_START -> mapView.onStart()
Lifecycle.Event.ON_RESUME -> mapView.onResume()
Lifecycle.Event.ON_PAUSE -> mapView.onPause()
Lifecycle.Event.ON_STOP -> mapView.onStop()
Lifecycle.Event.ON_DESTROY -> mapView.onDestroy()
else -> throw IllegalStateException()
}
}
} | mage/src/main/java/mil/nga/giat/mage/form/view/MapViewContent.kt | 3451458826 |
package com.makingiants.todayhistory.utils
import android.os.Parcel
import android.os.Parcelable
import java.util.*
open class DateManager : Parcelable {
internal var mCalendar: Calendar
constructor() {
mCalendar = Calendar.getInstance()
}
open fun getTodayDay(): Int = mCalendar.get(Calendar.DAY_OF_MONTH)
open fun getTodayMonth(): Int = mCalendar.get(Calendar.MONTH)
//<editor-fold desc="Parcelable">
override fun describeContents(): Int {
return 0
}
override fun writeToParcel(dest: Parcel, flags: Int) {
dest.writeSerializable(this.mCalendar)
}
protected constructor(`in`: Parcel) {
this.mCalendar = `in`.readSerializable() as Calendar
}
companion object {
val CREATOR: Parcelable.Creator<DateManager> = object : Parcelable.Creator<DateManager> {
override fun createFromParcel(source: Parcel): DateManager {
return com.makingiants.todayhistory.utils.DateManager(source)
}
override fun newArray(size: Int): Array<out DateManager?> = arrayOfNulls(size)
}
}
//</editor-fold>
}
| app/src/main/kotlin/com/makingiants/todayhistory/utils/DateManager.kt | 252114194 |
/**
* Sone - SoneMentionDetector.kt - Copyright © 2019–2020 David ‘Bombe’ Roden
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package net.pterodactylus.sone.text
import com.google.common.eventbus.*
import net.pterodactylus.sone.core.event.*
import net.pterodactylus.sone.data.*
import net.pterodactylus.sone.database.*
import net.pterodactylus.sone.utils.*
import javax.inject.*
/**
* Listens to [NewPostFoundEvent]s and [NewPostReplyFoundEvent], parses the
* texts and emits a [MentionOfLocalSoneFoundEvent] if a [SoneTextParser]
* finds a [SonePart] that points to a local [Sone].
*/
class SoneMentionDetector @Inject constructor(private val eventBus: EventBus, private val soneTextParser: SoneTextParser, private val postReplyProvider: PostReplyProvider) {
@Subscribe
fun onNewPost(newPostFoundEvent: NewPostFoundEvent) {
newPostFoundEvent.post.let { post ->
post.sone.isLocal.onFalse {
if (post.text.hasLinksToLocalSones()) {
mentionedPosts += post
eventBus.post(MentionOfLocalSoneFoundEvent(post))
}
}
}
}
@Subscribe
fun onNewPostReply(event: NewPostReplyFoundEvent) {
event.postReply.let { postReply ->
postReply.sone.isLocal.onFalse {
if (postReply.text.hasLinksToLocalSones()) {
postReply.post
.also { mentionedPosts += it }
.let(::MentionOfLocalSoneFoundEvent)
?.also(eventBus::post)
}
}
}
}
@Subscribe
fun onPostRemoved(event: PostRemovedEvent) {
unmentionPost(event.post)
}
@Subscribe
fun onPostMarkedKnown(event: MarkPostKnownEvent) {
unmentionPost(event.post)
}
@Subscribe
fun onReplyRemoved(event: PostReplyRemovedEvent) {
event.postReply.post.let {
if ((!it.text.hasLinksToLocalSones() || it.isKnown) && (it.replies.filterNot { it == event.postReply }.none { it.text.hasLinksToLocalSones() && !it.isKnown })) {
unmentionPost(it)
}
}
}
private fun unmentionPost(post: Post) {
if (post in mentionedPosts) {
eventBus.post(MentionOfLocalSoneRemovedEvent(post))
mentionedPosts -= post
}
}
private val mentionedPosts = mutableSetOf<Post>()
private fun String.hasLinksToLocalSones() = soneTextParser.parse(this, null)
.filterIsInstance<SonePart>()
.any { it.sone.isLocal }
private val Post.replies get() = postReplyProvider.getReplies(id)
}
| src/main/kotlin/net/pterodactylus/sone/text/SoneMentionDetector.kt | 1720845834 |
package cz.vhromada.catalog.web.common
import cz.vhromada.catalog.entity.Song
import cz.vhromada.catalog.web.fo.SongFO
import org.assertj.core.api.SoftAssertions.assertSoftly
/**
* A class represents utility class for songs.
*
* @author Vladimir Hromada
*/
object SongUtils {
/**
* Returns FO for song.
*
* @return FO for song
*/
fun getSongFO(): SongFO {
return SongFO(id = CatalogUtils.ID,
name = CatalogUtils.NAME,
length = TimeUtils.getTimeFO(),
note = CatalogUtils.NOTE,
position = CatalogUtils.POSITION)
}
/**
* Returns song.
*
* @return song
*/
fun getSong(): Song {
return Song(id = CatalogUtils.ID,
name = CatalogUtils.NAME,
length = CatalogUtils.LENGTH,
note = CatalogUtils.NOTE,
position = CatalogUtils.POSITION)
}
/**
* Asserts song deep equals.
*
* @param expected expected FO for song
* @param actual actual song
*/
fun assertSongDeepEquals(expected: SongFO?, actual: Song?) {
assertSoftly {
it.assertThat(expected).isNotNull
it.assertThat(actual).isNotNull
}
assertSoftly {
it.assertThat(actual!!.id).isEqualTo(expected!!.id)
it.assertThat(actual.name).isEqualTo(expected.name)
TimeUtils.assertTimeDeepEquals(expected.length, actual.length)
it.assertThat(actual.note).isEqualTo(expected.note)
it.assertThat(actual.position).isEqualTo(expected.position)
}
}
}
| src/test/kotlin/cz/vhromada/catalog/web/common/SongUtils.kt | 145421027 |
package net.halawata.artich.model.config
import net.halawata.artich.entity.QiitaTag
import net.halawata.artich.model.Log
import org.json.JSONArray
import org.json.JSONException
class QiitaTagList {
fun parse(content: String, selectedList: ArrayList<String>): ArrayList<QiitaTag>? {
try {
val list = ArrayList<QiitaTag>()
val items = JSONArray(content)
for (i in 0 until (items).length()) {
val row = items.getJSONObject(i)
val title = row.getString("id") ?: break
val selected = selectedList.contains(title)
list.add(QiitaTag(
id = i.toLong(),
title = title,
selected = selected
))
}
list.sortBy { item -> item.title }
return list
} catch (ex: JSONException) {
Log.e(ex.message)
return null
}
}
}
| app/src/main/java/net/halawata/artich/model/config/QiitaTagList.kt | 684660607 |
package io.ringle.mo
import android.view.View
import android.view.ViewGroup
public fun View.removeSelf(): Unit = (getParent() as? ViewGroup)?.removeView(this)
| runtime/src/main/kotlin/io/ringle/mo/Helpers.kt | 2174185469 |
/*
* The MIT License (MIT)
*
* Copyright (c) 2015-2022 Elior "Mallowigi" Boukhobza
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
package com.mallowigi.icons.patchers
import com.intellij.openapi.util.IconPathPatcher
import com.mallowigi.config.AtomFileIconsConfig
import org.jetbrains.annotations.NonNls
import java.net.URL
/** Base class for [IconPathPatcher]s. */
abstract class AbstractIconPatcher : IconPathPatcher() {
/** The string to append to the final path. */
protected abstract val pathToAppend: @NonNls String
/** The string to remove from the original path. */
protected abstract val pathToRemove: @NonNls String
/** Whether the patcher should be enabled or not. */
var enabled: Boolean = false
/** Singleton instance. */
var instance: AtomFileIconsConfig? = AtomFileIconsConfig.instance
get() {
if (field == null) field = AtomFileIconsConfig.instance
return field
}
private set
/**
* Get the plugin context class loader if an icon needs to be patched
*
* @param path the icon path
* @param originalClassLoader the original class loader
* @return the plugin class loader if the icon needs to be patched, or the original class loader
*/
override fun getContextClassLoader(path: String, originalClassLoader: ClassLoader?): ClassLoader? {
val classLoader = javaClass.classLoader
if (!CL_CACHE.containsKey(path)) CL_CACHE[path] = originalClassLoader
val cachedClassLoader = CL_CACHE[path]
return if (enabled) classLoader else cachedClassLoader
}
/**
* Patch the icon path if there is an icon available
*
* @param path the path to patch
* @param classLoader the classloader of the icon
* @return the patched path to the plugin icon, or the original path if the icon patcher is disabled
*/
override fun patchPath(path: String, classLoader: ClassLoader?): String? {
if (instance == null) return null
val patchedPath = getPatchedPath(path)
return if (!enabled) null else patchedPath
}
/** Check whether a png version of a resource exists. */
private fun getPNG(path: String): URL? {
val replacement = SVG.replace(getReplacement(path), ".png") // NON-NLS
return javaClass.getResource("/$replacement")
}
/**
* Returns the patched path by taking the original path and appending the path to append, and converting to svg
*
* @param path
* @return
*/
@Suppress("kotlin:S1871", "HardCodedStringLiteral")
private fun getPatchedPath(path: String): String? = when {
!enabled -> null
CACHE.containsKey(path) -> CACHE[path]
// First try the svg version of the resource
getSVG(path) != null -> {
CACHE[path] = getReplacement(path)
CACHE[path]
}
// Then try the png version
getPNG(path) != null -> {
CACHE[path] = getReplacement(path)
CACHE[path]
}
else -> null
}
/**
* Replace the path by using the pathToAppend and pathToRemove
*
* @param path
* @return
*/
private fun getReplacement(path: String): String {
val finalPath: String = when {
path.contains(".gif") -> GIF.replace(path, ".svg")
else -> path.replace(".png", ".svg")
}
return (pathToAppend + finalPath.replace(pathToRemove, "")).replace("//", "/") // don't ask
}
/** Check whether a svg version of a resource exists. */
private fun getSVG(path: String): URL? {
val svgFile = PNG.replace(getReplacement(path), ".svg") // NON-NLS
return javaClass.getResource("/$svgFile")
}
companion object {
private val CACHE: MutableMap<String, String> = HashMap(100)
private val CL_CACHE: MutableMap<String, ClassLoader?> = HashMap(100)
private val PNG = ".png".toRegex(RegexOption.LITERAL)
private val SVG = ".svg".toRegex(RegexOption.LITERAL)
private val GIF = ".gif".toRegex(RegexOption.LITERAL)
/** Clear all caches. */
@JvmStatic
fun clearCache() {
CACHE.clear()
CL_CACHE.clear()
}
}
}
| common/src/main/java/com/mallowigi/icons/patchers/AbstractIconPatcher.kt | 3847162722 |
package io.particle.mesh.ui.controlpanel
import android.os.Bundle
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import androidx.core.view.isVisible
import androidx.fragment.app.FragmentActivity
import io.particle.mesh.setup.flow.FlowRunnerUiListener
import io.particle.mesh.ui.navigateOnClick
import io.particle.mesh.ui.R
import io.particle.mesh.ui.TitleBarOptions
import io.particle.mesh.ui.inflateFragment
import kotlinx.android.synthetic.main.fragment_controlpanel_mesh_network_options.*
class ControlPanelMeshOptionsFragment : BaseControlPanelFragment() {
override val titleBarOptions = TitleBarOptions(
R.string.p_common_mesh,
showBackButton = true
)
override fun onCreateView(
inflater: LayoutInflater,
container: ViewGroup?,
savedInstanceState: Bundle?
): View? {
return container?.inflateFragment(R.layout.fragment_controlpanel_mesh_network_options)
}
override fun onFragmentReady(activity: FragmentActivity, flowUiListener: FlowRunnerUiListener) {
super.onFragmentReady(activity, flowUiListener)
p_controlpanel_mesh_add_to_network_frame.setOnClickListener { addToMesh() }
}
private fun addToMesh() {
flowScopes.onMain { startFlowWithBarcode(flowRunner::startControlPanelMeshAddToMeshFlow) }
}
} | meshui/src/main/java/io/particle/mesh/ui/controlpanel/ControlPanelMeshOptionsFragment.kt | 1469573894 |
/*
* Copyright (C) 2018 The Android Open Source Project
*
* 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
*
* http://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.
*/
package com.android.example.text.styling.roundedbg.app
import android.os.Bundle
import androidx.appcompat.app.AppCompatActivity
/**
* Sample activity that uses [com.android.example.text.styling.roundedbg.RoundedBgTextView].
*/
class MainActivity : AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
}
}
| RoundedBackground-Kotlin/app/src/main/java/com/android/example/text/styling/roundedbg/app/MainActivity.kt | 3650394541 |
/*
* Copyright (C) 2017 Square, Inc.
*
* 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
*
* http://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.
*/
package okhttp3.internal.publicsuffix
import java.io.IOException
import java.io.InterruptedIOException
import java.net.IDN
import java.util.concurrent.CountDownLatch
import java.util.concurrent.atomic.AtomicBoolean
import okhttp3.internal.and
import okhttp3.internal.platform.Platform
import okio.GzipSource
import okio.buffer
import okio.source
/**
* A database of public suffixes provided by [publicsuffix.org][publicsuffix_org].
*
* [publicsuffix_org]: https://publicsuffix.org/
*/
class PublicSuffixDatabase {
/** True after we've attempted to read the list for the first time. */
private val listRead = AtomicBoolean(false)
/** Used for concurrent threads reading the list for the first time. */
private val readCompleteLatch = CountDownLatch(1)
// The lists are held as a large array of UTF-8 bytes. This is to avoid allocating lots of strings
// that will likely never be used. Each rule is separated by '\n'. Please see the
// PublicSuffixListGenerator class for how these lists are generated.
// Guarded by this.
private lateinit var publicSuffixListBytes: ByteArray
private lateinit var publicSuffixExceptionListBytes: ByteArray
/**
* Returns the effective top-level domain plus one (eTLD+1) by referencing the public suffix list.
* Returns null if the domain is a public suffix or a private address.
*
* Here are some examples:
*
* ```java
* assertEquals("google.com", getEffectiveTldPlusOne("google.com"));
* assertEquals("google.com", getEffectiveTldPlusOne("www.google.com"));
* assertNull(getEffectiveTldPlusOne("com"));
* assertNull(getEffectiveTldPlusOne("localhost"));
* assertNull(getEffectiveTldPlusOne("mymacbook"));
* ```
*
* @param domain A canonicalized domain. An International Domain Name (IDN) should be punycode
* encoded.
*/
fun getEffectiveTldPlusOne(domain: String): String? {
// We use UTF-8 in the list so we need to convert to Unicode.
val unicodeDomain = IDN.toUnicode(domain)
val domainLabels = splitDomain(unicodeDomain)
val rule = findMatchingRule(domainLabels)
if (domainLabels.size == rule.size && rule[0][0] != EXCEPTION_MARKER) {
return null // The domain is a public suffix.
}
val firstLabelOffset = if (rule[0][0] == EXCEPTION_MARKER) {
// Exception rules hold the effective TLD plus one.
domainLabels.size - rule.size
} else {
// Otherwise the rule is for a public suffix, so we must take one more label.
domainLabels.size - (rule.size + 1)
}
return splitDomain(domain).asSequence().drop(firstLabelOffset).joinToString(".")
}
private fun splitDomain(domain: String): List<String> {
val domainLabels = domain.split('.')
if (domainLabels.last() == "") {
// allow for domain name trailing dot
return domainLabels.dropLast(1)
}
return domainLabels
}
private fun findMatchingRule(domainLabels: List<String>): List<String> {
if (!listRead.get() && listRead.compareAndSet(false, true)) {
readTheListUninterruptibly()
} else {
try {
readCompleteLatch.await()
} catch (_: InterruptedException) {
Thread.currentThread().interrupt() // Retain interrupted status.
}
}
check(::publicSuffixListBytes.isInitialized) {
"Unable to load $PUBLIC_SUFFIX_RESOURCE resource from the classpath."
}
// Break apart the domain into UTF-8 labels, i.e. foo.bar.com turns into [foo, bar, com].
val domainLabelsUtf8Bytes = Array(domainLabels.size) { i -> domainLabels[i].toByteArray() }
// Start by looking for exact matches. We start at the leftmost label. For example, foo.bar.com
// will look like: [foo, bar, com], [bar, com], [com]. The longest matching rule wins.
var exactMatch: String? = null
for (i in domainLabelsUtf8Bytes.indices) {
val rule = publicSuffixListBytes.binarySearch(domainLabelsUtf8Bytes, i)
if (rule != null) {
exactMatch = rule
break
}
}
// In theory, wildcard rules are not restricted to having the wildcard in the leftmost position.
// In practice, wildcards are always in the leftmost position. For now, this implementation
// cheats and does not attempt every possible permutation. Instead, it only considers wildcards
// in the leftmost position. We assert this fact when we generate the public suffix file. If
// this assertion ever fails we'll need to refactor this implementation.
var wildcardMatch: String? = null
if (domainLabelsUtf8Bytes.size > 1) {
val labelsWithWildcard = domainLabelsUtf8Bytes.clone()
for (labelIndex in 0 until labelsWithWildcard.size - 1) {
labelsWithWildcard[labelIndex] = WILDCARD_LABEL
val rule = publicSuffixListBytes.binarySearch(labelsWithWildcard, labelIndex)
if (rule != null) {
wildcardMatch = rule
break
}
}
}
// Exception rules only apply to wildcard rules, so only try it if we matched a wildcard.
var exception: String? = null
if (wildcardMatch != null) {
for (labelIndex in 0 until domainLabelsUtf8Bytes.size - 1) {
val rule = publicSuffixExceptionListBytes.binarySearch(
domainLabelsUtf8Bytes, labelIndex)
if (rule != null) {
exception = rule
break
}
}
}
if (exception != null) {
// Signal we've identified an exception rule.
exception = "!$exception"
return exception.split('.')
} else if (exactMatch == null && wildcardMatch == null) {
return PREVAILING_RULE
}
val exactRuleLabels = exactMatch?.split('.') ?: listOf()
val wildcardRuleLabels = wildcardMatch?.split('.') ?: listOf()
return if (exactRuleLabels.size > wildcardRuleLabels.size) {
exactRuleLabels
} else {
wildcardRuleLabels
}
}
/**
* Reads the public suffix list treating the operation as uninterruptible. We always want to read
* the list otherwise we'll be left in a bad state. If the thread was interrupted prior to this
* operation, it will be re-interrupted after the list is read.
*/
private fun readTheListUninterruptibly() {
var interrupted = false
try {
while (true) {
try {
readTheList()
return
} catch (_: InterruptedIOException) {
Thread.interrupted() // Temporarily clear the interrupted state.
interrupted = true
} catch (e: IOException) {
Platform.get().log("Failed to read public suffix list", Platform.WARN, e)
return
}
}
} finally {
if (interrupted) {
Thread.currentThread().interrupt() // Retain interrupted status.
}
}
}
@Throws(IOException::class)
private fun readTheList() {
var publicSuffixListBytes: ByteArray?
var publicSuffixExceptionListBytes: ByteArray?
val resource =
PublicSuffixDatabase::class.java.getResourceAsStream(PUBLIC_SUFFIX_RESOURCE) ?: return
GzipSource(resource.source()).buffer().use { bufferedSource ->
val totalBytes = bufferedSource.readInt()
publicSuffixListBytes = bufferedSource.readByteArray(totalBytes.toLong())
val totalExceptionBytes = bufferedSource.readInt()
publicSuffixExceptionListBytes = bufferedSource.readByteArray(totalExceptionBytes.toLong())
}
synchronized(this) {
this.publicSuffixListBytes = publicSuffixListBytes!!
this.publicSuffixExceptionListBytes = publicSuffixExceptionListBytes!!
}
readCompleteLatch.countDown()
}
/** Visible for testing. */
fun setListBytes(
publicSuffixListBytes: ByteArray,
publicSuffixExceptionListBytes: ByteArray
) {
this.publicSuffixListBytes = publicSuffixListBytes
this.publicSuffixExceptionListBytes = publicSuffixExceptionListBytes
listRead.set(true)
readCompleteLatch.countDown()
}
companion object {
@JvmField
val PUBLIC_SUFFIX_RESOURCE = "${PublicSuffixDatabase::class.java.simpleName}.gz"
private val WILDCARD_LABEL = byteArrayOf('*'.code.toByte())
private val PREVAILING_RULE = listOf("*")
private const val EXCEPTION_MARKER = '!'
private val instance = PublicSuffixDatabase()
fun get(): PublicSuffixDatabase {
return instance
}
private fun ByteArray.binarySearch(
labels: Array<ByteArray>,
labelIndex: Int
): String? {
var low = 0
var high = size
var match: String? = null
while (low < high) {
var mid = (low + high) / 2
// Search for a '\n' that marks the start of a value. Don't go back past the start of the
// array.
while (mid > -1 && this[mid] != '\n'.code.toByte()) {
mid--
}
mid++
// Now look for the ending '\n'.
var end = 1
while (this[mid + end] != '\n'.code.toByte()) {
end++
}
val publicSuffixLength = mid + end - mid
// Compare the bytes. Note that the file stores UTF-8 encoded bytes, so we must compare the
// unsigned bytes.
var compareResult: Int
var currentLabelIndex = labelIndex
var currentLabelByteIndex = 0
var publicSuffixByteIndex = 0
var expectDot = false
while (true) {
val byte0: Int
if (expectDot) {
byte0 = '.'.code
expectDot = false
} else {
byte0 = labels[currentLabelIndex][currentLabelByteIndex] and 0xff
}
val byte1 = this[mid + publicSuffixByteIndex] and 0xff
compareResult = byte0 - byte1
if (compareResult != 0) break
publicSuffixByteIndex++
currentLabelByteIndex++
if (publicSuffixByteIndex == publicSuffixLength) break
if (labels[currentLabelIndex].size == currentLabelByteIndex) {
// We've exhausted our current label. Either there are more labels to compare, in which
// case we expect a dot as the next character. Otherwise, we've checked all our labels.
if (currentLabelIndex == labels.size - 1) {
break
} else {
currentLabelIndex++
currentLabelByteIndex = -1
expectDot = true
}
}
}
if (compareResult < 0) {
high = mid - 1
} else if (compareResult > 0) {
low = mid + end + 1
} else {
// We found a match, but are the lengths equal?
val publicSuffixBytesLeft = publicSuffixLength - publicSuffixByteIndex
var labelBytesLeft = labels[currentLabelIndex].size - currentLabelByteIndex
for (i in currentLabelIndex + 1 until labels.size) {
labelBytesLeft += labels[i].size
}
if (labelBytesLeft < publicSuffixBytesLeft) {
high = mid - 1
} else if (labelBytesLeft > publicSuffixBytesLeft) {
low = mid + end + 1
} else {
// Found a match.
match = String(this, mid, publicSuffixLength)
break
}
}
}
return match
}
}
}
| okhttp/src/jvmMain/kotlin/okhttp3/internal/publicsuffix/PublicSuffixDatabase.kt | 3464904259 |
Subsets and Splits