SQL: Remove update class.
parent
0a60088596
commit
ee4706737e
|
|
@ -1,469 +0,0 @@
|
|||
# ============================================================================== #
|
||||
# update_table_for_save.py - AcouSed #
|
||||
# Copyright (C) 2024 INRAE #
|
||||
# #
|
||||
# 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 <https://www.gnu.org/licenses/>. #
|
||||
|
||||
# by Brahim MOUDJED #
|
||||
# ============================================================================== #
|
||||
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
|
||||
import numpy as np
|
||||
from PyQt5.QtWidgets import QFileDialog, QApplication, QMessageBox
|
||||
import sqlite3
|
||||
import settings as stg
|
||||
from os import chdir, getcwd
|
||||
import time
|
||||
|
||||
|
||||
class UpdateTableForSave:
|
||||
|
||||
def __init__(self):
|
||||
|
||||
if stg.dirname_save_as:
|
||||
start = time.time()
|
||||
chdir(stg.dirname_save_as)
|
||||
print("get cwd for save :", getcwd())
|
||||
print("stg.filename_save_as ", stg.filename_save_as)
|
||||
self.update_table()
|
||||
print(f"end : {time.time() - start} sec")
|
||||
else:
|
||||
msgBox = QMessageBox()
|
||||
msgBox.setWindowTitle("Save Error")
|
||||
msgBox.setIcon(QMessageBox.Warning)
|
||||
msgBox.setText("Use 'Save as' before 'Save'")
|
||||
msgBox.setStandardButtons(QMessageBox.Ok)
|
||||
msgBox.exec()
|
||||
|
||||
def update_table(self):
|
||||
|
||||
# Create a new database and open a database connection to allow sqlite3 to work with it.
|
||||
cnx = sqlite3.connect(stg.filename_save_as)
|
||||
|
||||
# Create database cursor to execute SQL statements and fetch results from SQL queries.
|
||||
cur = cnx.cursor()
|
||||
|
||||
# --------------------------------------------------------------------------------------------------------------
|
||||
# +++++++++++++++++++++++++++
|
||||
# --- Table Acoustic File ---
|
||||
# +++++++++++++++++++++++++++
|
||||
|
||||
start_table_AcousticFile = time.time()
|
||||
|
||||
cur.execute('''DROP TABLE AcousticFile''')
|
||||
|
||||
cur.execute("""CREATE TABLE AcousticFile(ID INTEGER PRIMARY KEY AUTOINCREMENT,
|
||||
acoustic_data INTEGER,
|
||||
acoustic_file STRING,
|
||||
ABS_name STRING,
|
||||
path_BS_noise_data STRING,
|
||||
filename_BS_noise_data STRING,
|
||||
noise_method FLOAT,
|
||||
noise_value FLOAT,
|
||||
data_preprocessed STRING
|
||||
)"""
|
||||
)
|
||||
|
||||
for i in stg.acoustic_data:
|
||||
print("stg.acoustic_data ", stg.acoustic_data[i])
|
||||
print("stg.filename_BS_raw_data ", stg.filename_BS_raw_data[i])
|
||||
print('stg.ABS_name', stg.ABS_name)
|
||||
print("stg.path_BS_raw_data ", stg.path_BS_raw_data[i])
|
||||
|
||||
cur.execute(''' INSERT into AcousticFile(acoustic_data, acoustic_file, ABS_name, path_BS_noise_data,
|
||||
filename_BS_noise_data, noise_method, noise_value, data_preprocessed)
|
||||
VALUES(?, ?, ?, ?, ?, ?, ?, ?)''',
|
||||
(stg.acoustic_data[i], stg.filename_BS_raw_data[i].split('.')[0], stg.ABS_name[i],
|
||||
stg.path_BS_noise_data[i], stg.filename_BS_noise_data[i], stg.noise_method[i],
|
||||
stg.noise_value[i], stg.data_preprocessed[i])
|
||||
)
|
||||
|
||||
cnx.commit()
|
||||
print(f"Table AcousticFile : {time.time() - start_table_AcousticFile} sec")
|
||||
|
||||
# --------------------------------------------------------------------------------------------------------------
|
||||
# ++++++++++++++++++++++++++
|
||||
# --- Table Measurements ---
|
||||
# ++++++++++++++++++++++++++
|
||||
|
||||
start_table_Measure = time.time()
|
||||
|
||||
# Drop Table if exists
|
||||
cur.execute("DROP TABLE if exists Measure")
|
||||
|
||||
cur.execute(
|
||||
"""
|
||||
CREATE TABLE Measure(
|
||||
ID INTEGER PRIMARY KEY AUTOINCREMENT,
|
||||
acoustic_data INTEGER,
|
||||
Date STRING,
|
||||
Hour STRING,
|
||||
frequency FLOAT,
|
||||
sound_attenuation FLOAT,
|
||||
kt_read FLOAT,
|
||||
kt_corrected FLOAT,
|
||||
NbProfiles FLOAT,
|
||||
NbProfilesPerSeconds FLOAT,
|
||||
NbCells FLOAT,
|
||||
CellSize FLOAT,
|
||||
PulseLength FLOAT,
|
||||
NbPingsPerSeconds FLOAT,
|
||||
NbPingsAveragedPerProfile FLOAT,
|
||||
GainRx FLOAT,
|
||||
GainTx FLOAT
|
||||
)"""
|
||||
)
|
||||
|
||||
# Fill the table Measure
|
||||
for i in stg.acoustic_data:
|
||||
for j in range(stg.freq[i].shape[0]):
|
||||
cur.execute(
|
||||
'''
|
||||
INSERT into Measure(
|
||||
acoustic_data,
|
||||
Date, Hour,
|
||||
frequency,
|
||||
sound_attenuation,
|
||||
kt_read, kt_corrected,
|
||||
NbProfiles, NbProfilesPerSeconds,
|
||||
NbCells, CellSize,
|
||||
PulseLength,
|
||||
NbPingsPerSeconds,
|
||||
NbPingsAveragedPerProfile,
|
||||
GainRx, GainTx
|
||||
) VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)''',
|
||||
(
|
||||
stg.acoustic_data[i],
|
||||
stg.date[i].isoformat(),
|
||||
stg.hour[i].isoformat(),
|
||||
stg.freq[i][j],
|
||||
stg.water_attenuation[i][j],
|
||||
stg.kt_read[j],
|
||||
stg.kt_corrected[j],
|
||||
stg.nb_profiles[i][j],
|
||||
stg.nb_profiles_per_sec[i][j],
|
||||
stg.nb_cells[i][j],
|
||||
stg.cell_size[i][j],
|
||||
stg.pulse_length[i][j],
|
||||
stg.nb_pings_per_sec[i][j],
|
||||
stg.nb_pings_averaged_per_profile[i][j],
|
||||
stg.gain_rx[i][j], stg.gain_tx[i][j]
|
||||
)
|
||||
)
|
||||
|
||||
# Commit the transaction after executing INSERT.
|
||||
cnx.commit()
|
||||
|
||||
print(f"table Measure : {time.time() - start_table_Measure} sec")
|
||||
|
||||
# --------------------------------------------------------------------------------------------------------------
|
||||
# +++++++++++++++++++++++++++
|
||||
# --- Table Acoustic Data ---
|
||||
# +++++++++++++++++++++++++++
|
||||
|
||||
start_table_BSRawData = time.time()
|
||||
|
||||
cur.execute(''' DROP TABLE BSRawData ''')
|
||||
|
||||
cur.execute('''CREATE TABLE BSRawData(ID INTEGER PRIMARY KEY AUTOINCREMENT,
|
||||
acoustic_data INTEGER,
|
||||
time BLOB, depth BLOB, BS_raw_data BLOB,
|
||||
time_reshape BLOB, depth_reshape BLOB, BS_raw_data_reshape BLOB,
|
||||
time_cross_section BLOB, depth_cross_section BLOB, BS_cross_section BLOB, BS_stream_bed BLOB,
|
||||
depth_bottom, val_bottom, ind_bottom,
|
||||
time_noise BLOB, depth_noise BLOB, BS_noise_raw_data BLOB,
|
||||
SNR_raw_data BLOB, SNR_cross_section BLOB, SNR_stream_bed BLOB,
|
||||
BS_raw_data_pre_process_SNR BLOB, BS_raw_data_pre_process_average BLOB,
|
||||
BS_cross_section_pre_process_SNR BLOB, BS_cross_section_pre_process_average BLOB,
|
||||
BS_stream_bed_pre_process_SNR BLOB, BS_stream_bed_pre_process_average BLOB,
|
||||
BS_mean BLOB
|
||||
)''')
|
||||
|
||||
for i in stg.acoustic_data:
|
||||
|
||||
cur.execute(''' INSERT into BSRawData(acoustic_data, time, depth, BS_raw_data,
|
||||
time_reshape, depth_reshape, BS_raw_data_reshape,
|
||||
time_cross_section, depth_cross_section,
|
||||
BS_cross_section, BS_stream_bed,
|
||||
depth_bottom, val_bottom, ind_bottom,
|
||||
time_noise, depth_noise, BS_noise_raw_data,
|
||||
SNR_raw_data, SNR_cross_section, SNR_stream_bed,
|
||||
BS_raw_data_pre_process_SNR, BS_raw_data_pre_process_average,
|
||||
BS_cross_section_pre_process_SNR, BS_cross_section_pre_process_average,
|
||||
BS_stream_bed_pre_process_SNR, BS_stream_bed_pre_process_average,
|
||||
BS_mean)
|
||||
VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)''',
|
||||
(stg.acoustic_data[i], stg.time[i].tobytes(), stg.depth[i].tobytes(), stg.BS_raw_data[i].tobytes(),
|
||||
stg.time_reshape[i].tobytes(),
|
||||
stg.depth_reshape[i].tobytes(),
|
||||
stg.BS_raw_data_reshape[i].tobytes(),
|
||||
stg.time_cross_section[i].tobytes(),
|
||||
stg.depth_cross_section[i].tobytes(),
|
||||
stg.BS_cross_section[i].tobytes(),
|
||||
np.array(stg.BS_stream_bed[i]).tobytes(),
|
||||
np.array(stg.depth_bottom[i]).tobytes(),
|
||||
np.array(stg.val_bottom[i]).tobytes(),
|
||||
np.array(stg.ind_bottom[i]).tobytes(),
|
||||
np.array(stg.time_noise[i]).tobytes(),
|
||||
np.array(stg.depth_noise[i]).tobytes(),
|
||||
np.array(stg.BS_noise_raw_data[i]).tobytes(),
|
||||
np.array(stg.SNR_raw_data[i]).tobytes(),
|
||||
np.array(stg.SNR_cross_section[i]).tobytes(),
|
||||
np.array(stg.SNR_stream_bed[i]).tobytes(),
|
||||
np.array(stg.BS_raw_data_pre_process_SNR[i]).tobytes(),
|
||||
np.array(stg.BS_raw_data_pre_process_average[i]).tobytes(),
|
||||
np.array(stg.BS_cross_section_pre_process_SNR[i]).tobytes(),
|
||||
np.array(stg.BS_cross_section_pre_process_average[i]).tobytes(),
|
||||
np.array(stg.BS_stream_bed_pre_process_SNR[i]).tobytes(),
|
||||
np.array(stg.BS_stream_bed_pre_process_average[i]).tobytes(),
|
||||
np.array(stg.BS_mean[i]).tobytes()
|
||||
)
|
||||
)
|
||||
|
||||
cnx.commit()
|
||||
|
||||
print(f"table BSRawData : {time.time() - start_table_BSRawData} sec")
|
||||
|
||||
# --------------------------------------------------------------------------------------------------------------
|
||||
# ++++++++++++++++++++++
|
||||
# --- Table Settings ---
|
||||
# ++++++++++++++++++++++
|
||||
|
||||
start_table_Settings = time.time()
|
||||
|
||||
cur.execute(''' DROP TABLE Settings''')
|
||||
|
||||
cur.execute('''
|
||||
CREATE TABLE Settings(
|
||||
ID INTEGER PRIMARY KEY AUTOINCREMENT,
|
||||
acoustic_data INTEGER,
|
||||
temperature FLOAT,
|
||||
distance_to_free_surface FLOAT,
|
||||
tmin_index FLOAT, tmin_value FLOAT,
|
||||
tmax_index FLOAT, tmax_value FLOAT,
|
||||
rmin_index FLOAT, rmin_value FLOAT,
|
||||
rmax_index FLOAT, rmax_value FLOAT,
|
||||
freq_bottom_detection_index FLOAT,
|
||||
freq_bottom_detection_value STRING,
|
||||
SNR_filter_value FLOAT,
|
||||
Nb_cells_to_average_BS_signal FLOAT
|
||||
)
|
||||
'''
|
||||
)
|
||||
|
||||
for i in stg.acoustic_data:
|
||||
cur.execute('''
|
||||
INSERT into Settings(
|
||||
acoustic_data, temperature,
|
||||
distance_to_free_surface,
|
||||
tmin_index, tmin_value, tmax_index, tmax_value,
|
||||
rmin_index, rmin_value, rmax_index, rmax_value,
|
||||
freq_bottom_detection_index, freq_bottom_detection_value,
|
||||
SNR_filter_value, Nb_cells_to_average_BS_signal
|
||||
) VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
|
||||
''',
|
||||
(
|
||||
stg.acoustic_data[i], stg.temperature,
|
||||
stg.distance_from_ABS_to_free_surface[i],
|
||||
stg.tmin[i][0], stg.tmin[i][1],
|
||||
stg.tmax[i][0], stg.tmax[i][1],
|
||||
stg.rmin[i][0], stg.rmin[i][1],
|
||||
stg.rmax[i][0], stg.rmax[i][1],
|
||||
stg.freq_bottom_detection[i][0],
|
||||
stg.freq_bottom_detection[i][1],
|
||||
stg.SNR_filter_value[i],
|
||||
stg.Nb_cells_to_average_BS_signal[i]
|
||||
)
|
||||
)
|
||||
|
||||
cnx.commit()
|
||||
|
||||
print(f"table Settings : {time.time() - start_table_Settings} sec")
|
||||
|
||||
# --------------------------------------------------------------------------------------------------------------
|
||||
# ++++++++++++++++++++++++++++
|
||||
# --- Table Sediments File ---
|
||||
# ++++++++++++++++++++++++++++
|
||||
|
||||
start_table_SedimentsFile = time.time()
|
||||
|
||||
cur.execute("DROP TABLE if exists SedimentsFile")
|
||||
|
||||
cur.execute("""CREATE TABLE SedimentsFile(ID INTEGER PRIMARY KEY AUTOINCREMENT,
|
||||
path_fine STRING,
|
||||
filename_fine STRING,
|
||||
radius_grain_fine BLOB,
|
||||
path_sand STRING,
|
||||
filename_sand STRING,
|
||||
radius_grain_sand BLOB,
|
||||
time_column_label STRING,
|
||||
distance_from_bank_column_label STRING,
|
||||
depth_column_label STRING,
|
||||
Ctot_fine_column_label STRING,
|
||||
D50_fine_column_label STRING,
|
||||
Ctot_sand_column_label STRING,
|
||||
D50_sand_column_label STRING
|
||||
)"""
|
||||
)
|
||||
|
||||
cur.execute('''INSERT into SedimentsFile(path_fine, filename_fine, radius_grain_fine,
|
||||
path_sand, filename_sand, radius_grain_sand,
|
||||
time_column_label, distance_from_bank_column_label,
|
||||
depth_column_label, Ctot_fine_column_label,
|
||||
D50_fine_column_label, Ctot_sand_column_label,
|
||||
D50_sand_column_label)
|
||||
VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)''',
|
||||
(stg.path_fine, stg.filename_fine, stg.radius_grain_fine.tobytes(),
|
||||
stg.path_sand, stg.filename_sand, stg.radius_grain_sand.tobytes(),
|
||||
stg.columns_fine[0], stg.columns_fine[1], stg.columns_fine[2],
|
||||
stg.columns_fine[3], stg.columns_fine[4], stg.columns_sand[3], stg.columns_sand[4]))
|
||||
|
||||
cnx.commit()
|
||||
|
||||
print(f"table SedimentsFile : {time.time() - start_table_SedimentsFile} sec")
|
||||
|
||||
# --------------------------------------------------------------------------------------------------------------
|
||||
# ++++++++++++++++++++++++++++
|
||||
# --- Table Sediments Data ---
|
||||
# ++++++++++++++++++++++++++++
|
||||
|
||||
start_table_SedimentsData = time.time()
|
||||
|
||||
cur.execute("DROP TABLE if exists SedimentsData")
|
||||
|
||||
cur.execute("""CREATE TABLE SedimentsData(ID INTEGER PRIMARY KEY AUTOINCREMENT,
|
||||
sample_fine_name STRING,
|
||||
sample_fine_index INTEGER,
|
||||
distance_from_bank_fine FLOAT,
|
||||
depth_fine FLOAT,
|
||||
time_fine FLOAT,
|
||||
Ctot_fine FLOAT,
|
||||
Ctot_fine_per_cent FLOAT,
|
||||
D50_fine FLOAT,
|
||||
frac_vol_fine BLOB,
|
||||
frac_vol_fine_cumul BLOB,
|
||||
sample_sand_name STRING,
|
||||
sample_sand_index INTEGER,
|
||||
distance_from_bank_sand FLOAT,
|
||||
depth_sand FLOAT,
|
||||
time_sand FLOAT,
|
||||
Ctot_sand FLOAT,
|
||||
Ctot_sand_per_cent FLOAT,
|
||||
D50_sand FLOAT,
|
||||
frac_vol_sand BLOB,
|
||||
frac_vol_sand_cumul BLOB
|
||||
)"""
|
||||
)
|
||||
|
||||
for f in range(len(stg.sample_fine)):
|
||||
cur.execute('''INSERT into SedimentsData(sample_fine_name, sample_fine_index, distance_from_bank_fine,
|
||||
depth_fine, time_fine, Ctot_fine, Ctot_fine_per_cent, D50_fine, frac_vol_fine,
|
||||
frac_vol_fine_cumul,
|
||||
sample_sand_name, sample_sand_index, distance_from_bank_sand,
|
||||
depth_sand, time_sand, Ctot_sand, Ctot_sand_per_cent, D50_sand, frac_vol_sand,
|
||||
frac_vol_sand_cumul)
|
||||
VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)''',
|
||||
(stg.sample_fine[f][0], stg.sample_fine[f][1],
|
||||
stg.distance_from_bank_fine[f], stg.depth_fine[f], stg.time_fine[f], stg.Ctot_fine[f],
|
||||
stg.Ctot_fine_per_cent[f], stg.D50_fine[f],
|
||||
stg.frac_vol_fine[f].tobytes(), stg.frac_vol_fine_cumul[f].tobytes(),
|
||||
stg.sample_sand[f][0], stg.sample_sand[f][1],
|
||||
stg.distance_from_bank_sand[f], stg.depth_sand[f], stg.time_sand[f], stg.Ctot_sand[f],
|
||||
stg.Ctot_sand_per_cent[f], stg.D50_sand[f],
|
||||
stg.frac_vol_sand[f].tobytes(), stg.frac_vol_sand_cumul[f].tobytes()
|
||||
))
|
||||
|
||||
cnx.commit()
|
||||
|
||||
print(f"table SedimentsData : {time.time() - start_table_SedimentsData} sec")
|
||||
|
||||
# --------------------------------------------------------------------------------------------------------------
|
||||
# ++++++++++++++++++++++++++++++
|
||||
# --- Table Calibration ---
|
||||
# ++++++++++++++++++++++++++++++
|
||||
|
||||
start_table_Calibration = time.time()
|
||||
|
||||
cur.execute("DROP TABLE if exists Calibration")
|
||||
|
||||
cur.execute("""CREATE TABLE Calibration(ID INTEGER PRIMARY KEY AUTOINCREMENT,
|
||||
path_calibration_file STRING,
|
||||
filename_calibration_file STRING,
|
||||
range_lin_interp BLOB,
|
||||
M_profile_fine BLOB,
|
||||
ks BLOB,
|
||||
sv BLOB,
|
||||
X_exponent BLOB,
|
||||
alpha_s BLOB,
|
||||
zeta BLOB,
|
||||
FCB BLOB,
|
||||
depth_real BLOB,
|
||||
lin_reg BLOB
|
||||
)"""
|
||||
)
|
||||
|
||||
cur.execute('''INSERT into Calibration(path_calibration_file, filename_calibration_file,
|
||||
range_lin_interp, M_profile_fine,
|
||||
ks, sv, X_exponent, alpha_s, zeta,
|
||||
FCB, depth_real, lin_reg)
|
||||
VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)''',
|
||||
(stg.path_calibration_file, stg.filename_calibration_file,
|
||||
stg.range_lin_interp.tobytes(), stg.M_profile_fine.tobytes(),
|
||||
np.array(stg.ks).tobytes(), np.array(stg.sv).tobytes(), np.array(stg.X_exponent).tobytes(),
|
||||
np.array(stg.alpha_s).tobytes(), np.array(stg.zeta).tobytes(),
|
||||
stg.FCB.tobytes(), stg.depth_real.tobytes(), np.array(stg.lin_reg).tobytes())
|
||||
)
|
||||
|
||||
cnx.commit()
|
||||
|
||||
print(f"table Calibration : {time.time() - start_table_Calibration} sec")
|
||||
|
||||
# --------------------------------------------------------------------------------------------------------------
|
||||
# ++++++++++++++++++++++++++++++
|
||||
# --- Table Inversion ---
|
||||
# ++++++++++++++++++++++++++++++
|
||||
|
||||
start_table_Inversion = time.time()
|
||||
|
||||
cur.execute("DROP TABLE if exists Inversion")
|
||||
|
||||
cur.execute("""CREATE TABLE Inversion(ID INTEGER PRIMARY KEY AUTOINCREMENT,
|
||||
J_cross_section_freq1 BLOB,
|
||||
J_cross_section_freq2 BLOB,
|
||||
VBI_cross_section BLOB,
|
||||
SSC_fine BLOB,
|
||||
SSC_sand BLOB
|
||||
)""")
|
||||
|
||||
for i in range(len(stg.SSC_fine)):
|
||||
cur.execute('''INSERT into Inversion(J_cross_section_freq1, J_cross_section_freq2,
|
||||
VBI_cross_section, SSC_fine, SSC_sand)
|
||||
VALUES(?, ?, ?, ?, ?)''',
|
||||
(stg.J_cross_section[i][0].tobytes(), stg.J_cross_section[i][1].tobytes(),
|
||||
stg.VBI_cross_section[i].tobytes(), stg.SSC_fine[i].tobytes(), stg.SSC_sand[i].tobytes())
|
||||
)
|
||||
|
||||
cnx.commit()
|
||||
|
||||
print(f"table Inversion : {time.time() - start_table_Inversion} sec")
|
||||
|
||||
# --------------------------------------------------------------------------------------------------------------
|
||||
|
||||
# Close database cursor
|
||||
cur.close()
|
||||
|
||||
# Close database connection
|
||||
cnx.close()
|
||||
|
|
@ -39,7 +39,6 @@ from subprocess import Popen
|
|||
|
||||
from PyQt5 import QtCore, QtGui, QtWidgets
|
||||
from Model.create_table_for_save_as import CreateTableForSaveAs
|
||||
from Model.update_table_for_save import UpdateTableForSave
|
||||
from Model.read_table_for_open import ReadTableForOpen
|
||||
from Model.calibration_constant_kt import CalibrationConstantKt
|
||||
from View.about_window import AboutWindow
|
||||
|
|
|
|||
Loading…
Reference in New Issue