thomasnield / rxkotlinfx-tornadofx-demo

A demo application demonstrating TornadoFX and Rx usage

RxKotlinFX/TornadoFX Demo

This is a fully-featured demo showcasing TornadoFX used in conjunction with RxKotlinFX to build a complex CRUD desktop application. It only took me two nights to build.

This is an RxJava-driven application. A temporary backing database is stored in-memory using SQLite, and RxKotlin-JDBC is used to reactively query and write to it.

Just build and run with Gradle.

Stack

Here is a list and Venn diagram of the different libraries used, with overlaps indicating their role in interoperability.

• RxJava
• RxKotlin
• JavaFX
• Kotlin
• TornadoFX
• RxJavaFX
• RxKotlinFX
• RxKotlin-JDBC
• SQLite

rxkotlinfx-tornadofx-demo's Issues

How to run

Hi, I'm having hard times running this. Any help?

Thanks!

Further cleanup

Code still needs some cleanup. Idiomatic patterns and unnecessary boilerplate needs to be handled.

Use FontAwesome Icons for Buttons

Found out the font symbols don't work for all computers. I may switch to use FontAwesome icons instead for ensured consistency.

Use DirtyFX for mutation tracking

https://github.com/thomasnield/DirtyFX

Would love an updated version

Hello, huge thanks for the demo. Would love to see this with updated dependencies. A lot of stuff breaks with current libraries and I am to new to kotlin to know where everything went ... thanks!

Feature request: Demonstrate editing table values in place

how to use paging and filter data

I try to make an project that get data from databse but my data rather big >10k rows so i want to paging it but don't know how to convert to rxkotlin and improve loading. I try to get data with runAsync for tableview hope you can show me how to do that
Here is my code:

 private val danhMucController: DanhMucDVKTController by inject()
private val eventController = EventController()
private var lstDanhMucModel = FXCollections.observableArrayList<DanhMucDVKTModel>()
private var filteredList: FilteredList<DanhMucDVKTModel> by singleAssign()
private var comboboxData = FXCollections.observableArrayList(10, 100, 500)
private val selectedData = SimpleIntegerProperty(10)
private val searchData = SimpleStringProperty()

private var btnXemDanhMuc: Button by singleAssign()
private var btnCapNhatDanhMuc: Button by singleAssign()
private var btnChonFile: Button by singleAssign()

private var table: TableView<DanhMucDVKTModel> by singleAssign()

private var paging: Pagination by singleAssign()

override val root = borderpane {
    center {
        tableview(lstDanhMucModel){
            isEditable = true

            column("STT", DanhMucDVKTModel::STT)
            column("Mã DVKT", DanhMucDVKTModel::maDVKT).makeEditable()
            column("Mã ánh xạ", DanhMucDVKTModel::maAX).makeEditable()

            columnResizePolicy = SmartResize.POLICY

            enableCellEditing()
            regainFocusAfterEdit()

            tableFilter.executeFilter()

            table = this

            onEditCommit {
                //update data
                danhMucController.update(it).subscribe()
            }

            //broadcast selections
            selectionModel.selectedItems.onChangedObservable()
                    .map { it.filterNotNull().toSet() }
                    .subscribe(eventController.selectedDanhMucDVKT)

            eventController.refreshDanhMucDVKT.startWith(Unit)
                    .flatMapSingle {
                        danhMucController.loadAll.toList()
                    }.subscribeBy(
                            onNext = {
                                lstDanhMucModel.clear()
                                table.items.clear()
                                lstDanhMucModel.addAll(it)
                            },
                            onError = {
                                alert(Alert.AlertType.ERROR, "Lỗi lấy dữ liệu", it.message ?: "").show()
                            }
                    )

            filteredList = FilteredList(lstDanhMucModel)
            table.items = filteredList
        }

    }

    bottom {
        hbox {
            combobox(selectedData, comboboxData) {
                hboxConstraints {
                    alignment = Pos.CENTER_LEFT
                }
                selectionModel.selectFirst()
            }
            paging = pagination {
                hboxConstraints {
                    alignment = Pos.CENTER
                }
                pageCount = lstDanhMucModel.size / selectedData.value + 1
                currentPageIndex = 0
                currentPageIndexProperty().addListener { _, _, newValue ->
                    changeTableView(newValue.toInt(), selectedData.value)
                }
            }
        }
    }

    top {
        toolbar {
            addClass(fontSize16px, fontFamily)
            paddingAll = 5.0

            //reload data from database
            btnXemDanhMuc = button("", refreshGlyph) {
                useMaxWidth = true
                tooltip(toolTipReload)
                actionEvents().map { Unit }.subscribe(eventController.refreshDanhMucDVKT)
            }

            //get data from excel
            btnChonFile = button("", uploadGlyph) {
                useMaxWidth = true
                tooltip(toolTipUpload)
                actionEvents().map {
                    danhMucController.loadFromExcel().map { danhMucDVKT ->
                        DanhMucDVKTModel().apply {
                            item = danhMucDVKT
                        }
                    }.observable()
                }.subscribe {
                    if (it.size != 0) {
                        lstDanhMucModel.clear()
                        table.items.clear()
                        lstDanhMucModel.addAll(it)
                        table.selectionModel.clearSelection()
                        table.requestFocus()
                    }
                }
            }

            //save data into database
            btnCapNhatDanhMuc = button("", saveGlyph) {
                useMaxWidth = true
                tooltip(toolTipSaveAs)
                actionEvents().map { Unit }.subscribe(eventController.saveDanhMucDVKT)
            }

            //remove an row
            button("", removeGlyph) {
                useMaxWidth = true
                tooltip(toolTipDelete)

                val keyEvents = table.events(KeyEvent.KEY_PRESSED).filter { it.code == KeyCode.DELETE }
                val buttonEvents = actionEvents()

                Observable.merge(keyEvents, buttonEvents).flatMapSingle {
                    table.selectionModel.selectedItems.toObservable()
                            .map { it.STT.value.toInt() }
                            .toSet()
                }.subscribe(eventController.deleteDanhMucDVKT)
            }

            textfield(searchData)
        }
    }

    lstDanhMucModel.onChange {
        changeTableView(paging.currentPageIndex, selectedData.value)
    }

    selectedData.onChange {
        changeTableView(paging.currentPageIndex, it)
    }

    searchData.onChange { searchValue ->
        filteredList.setPredicate { data ->
            data.tenDVKT.value.toLowerCase().contains(searchValue!!)
        }
        changeTableView(paging.currentPageIndex, selectedData.value)
    }

    searchData.onChange {
        JavaFxObservable.changesOf(searchData).map {
            lstDanhMucModel.filter { data ->
                data.tenDVKT.value.toLowerCase().contains(it.newVal)
            }
        }.subscribe {
            filteredList = FilteredList(it.observable())
        }
    }

    //handler save data into database
    val saveData = eventController.saveDanhMucDVKT
            .map { lstDanhMucModel }
            .flatMapSingle { lstDMDVKT ->
                Alert(Alert.AlertType.CONFIRMATION, "Lựa chọn hình thức lưu dữ liệu",
                        ButtonType("Thêm", ButtonBar.ButtonData.YES),
                        ButtonType("Lưu và xóa", ButtonBar.ButtonData.NO),
                        ButtonType("Bỏ qua", ButtonBar.ButtonData.CANCEL_CLOSE))
                        .toMaybe().toObservable()
                        .flatMap {
                            when {
                                it.buttonData == ButtonBar.ButtonData.YES -> danhMucController.createList(lstDMDVKT).toObservable()
                                it.buttonData == ButtonBar.ButtonData.NO -> {
                                    danhMucController.delete().subscribe()
                                    danhMucController.createList(lstDMDVKT).toObservable()
                                }
                                else -> Observable.empty()
                            }
                        }.toSet()
            }.publish() //publish() to prevent multiple subscriptions triggering alert multiple times
    saveData.subscribe(eventController.savedDanhMucDVKT)
    //add data into database
    eventController.savedDanhMucDVKT
            .map { Unit }
            .subscribe(eventController.refreshDanhMucDVKT)
    saveData.connect()
}

//pagingation when change view
private fun changeTableView(index: Int, limit: Int) {
val fromIndex = index * limit
val toIndex = min(fromIndex + limit, lstDanhMucModel.size)

    val minIndex = min(toIndex, filteredList.size)
    val sortedData = SortedList<DanhMucDVKTModel>(
            FXCollections.observableArrayList(filteredList.subList(min(fromIndex, minIndex), minIndex)))
    sortedData.comparatorProperty().bind(table.comparatorProperty())

    table.items = sortedData

    paging.pageCount = filteredList.size / selectedData.value + 1
}

init {
    //action to delete rows from database
    eventController.deleteDanhMucDVKT.flatMapSingle {
        table.currentSelections.toList().flatMap { deleteItems ->
            when {
                deleteItems.size == 0 -> {
                    Alert(Alert.AlertType.ERROR, "Bạn chưa chọn DVKT cần xóa", ButtonType.OK)
                            .toMaybe().map { 0 }.toObservable().toSet()
                }
                else -> {
                    Alert(Alert.AlertType.WARNING, "Bạn có chắc là muốn xóa ${deleteItems.size} DVKT không?",
                            ButtonType("Có", ButtonBar.ButtonData.YES),
                            ButtonType("Không", ButtonBar.ButtonData.NO)).toMaybe()
                            .filter { it.buttonData == ButtonBar.ButtonData.YES }
                            .flatMapObservable { deleteItems.toObservable() }
                            .flatMapSingle {
                                danhMucController.deleteWhere(it.STT.value.toInt())
                            }.map { deleteItems.first().STT.value.toInt() }
                            .toSet()
                }
            }
        }
    }.subscribe { deletedIds ->
        if (deletedIds.hashCode().absoluteValue != 0) {
            //thực hiện việc xóa dòng dữ liệu trong tableview
            lstDanhMucModel.deleteWhere { it.STT.value.toInt() in deletedIds }
            Alert(Alert.AlertType.INFORMATION, "Xóa dịch vụ kĩ thuật thành công", ButtonType.OK).show()
        }
    }
}