| {{ col }} | 13 |
|---|
| {{ aircraft[col] }} | 17 |
2 |
3 | 
4 |
5 |
8 | A cross platform ATC terminal 9 |
10 | 11 |
12 | 
22 | 
24 | Download
25 |
3 |
38 |
39 |
40 |
101 |
102 |
--------------------------------------------------------------------------------
/src/components/AppBar.vue:
--------------------------------------------------------------------------------
1 |
2 |
3 |
47 |
48 |
49 |
94 |
95 |
259 |
--------------------------------------------------------------------------------
/src/components/DraggableBase.vue:
--------------------------------------------------------------------------------
1 |
2 |
4 | ACF List
5 |
6 |
7 |
8 |
9 |
35 |
36 |
37 |
10 |
11 |
33 |
34 |
3 |
11 |
12 |
13 |
39 |
40 |
--------------------------------------------------------------------------------
/src/components/MessageContainer.vue:
--------------------------------------------------------------------------------
1 |
2 |
4 | title-subwindow
5 |
6 |
7 | submit submit submit
8 |
9 |
10 |
3 |
19 |
20 |
21 |
96 |
97 |
--------------------------------------------------------------------------------
/src/components/MetarContainer.vue:
--------------------------------------------------------------------------------
1 |
2 |
4 | Messages
5 |
6 |
7 |
8 |
9 |
15 |
16 |
17 |
18 |
10 |
14 | 11 | [{{ message.time }}] {{ message.type }}: {{ message.message }} 12 |
13 |
3 |
18 |
19 |
20 |
81 |
82 |
--------------------------------------------------------------------------------
/src/components/RadarScreen.vue:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
14 |
15 |
--------------------------------------------------------------------------------
/src/lib/coordparser.ts:
--------------------------------------------------------------------------------
1 | import { Coordinate_B, Coordinate_A, PolarCoordinate } from "./datatype";
2 | import {EARTH_RADIUS_LONG} from "./global";
3 |
4 |
5 | /**
6 | * 将B类坐标转换成A类坐标
7 | * @param coord B类坐标
8 | */
9 | export function parse2CoordA(coord: Coordinate_B): Coordinate_A {
10 | console.log(coord);
11 | throw "function not implemented";
12 | }
13 | export function DegToRad(deg:number){
14 | return Math.PI*(deg/180);
15 | }
16 | /**
17 | * 将A类坐标转换成B类坐标
18 | * @param coord A类坐标
19 | * @returns B类直角绘制坐标
20 | */
21 | export function parse2CoordB_(coord: Coordinate_A): Coordinate_B {
22 | let latres;
23 | let lonres;
24 | try {
25 | const pureLatNumber = coord.latitude.substring(1, coord.latitude.length).split(".");
26 | const pureLonNumber = coord.longitude.substring(1, coord.longitude.length).split(".");
27 | if (pureLatNumber.length == 4) {
28 | const deg = parseInt(pureLatNumber[0]); const min = parseInt(pureLatNumber[1]);
29 | const sec = parseInt(pureLatNumber[2]); const subsec = parseInt(pureLatNumber[3]);
30 | latres = deg + min / 60 + (sec + subsec / 1000) / 3600;
31 | if (coord.latitude.startsWith("N")) latres = -latres;
32 | }
33 | if (pureLonNumber.length == 4) {
34 | const deg = parseInt(pureLonNumber[0]); const min = parseInt(pureLonNumber[1]);
35 | const sec = parseInt(pureLonNumber[2]); const subsec = parseInt(pureLonNumber[3]);
36 | lonres = deg + min / 60 + (sec + subsec / 1000) / 3600;
37 | }
38 | if(latres == undefined || lonres == undefined) return {latitude:0,longitude:0}
39 | return {
40 | latitude: Math.log(Math.tan((Math.PI*0.25)+(0.5*DegToRad(latres))))*EARTH_RADIUS_LONG,
41 | longitude: DegToRad(lonres)*EARTH_RADIUS_LONG
42 | }
43 | } catch (error) {
44 | console.log(coord.latitude, coord.longitude);
45 | throw error;
46 | }
47 | }
48 | export function parse2CoordB(coord: Coordinate_A){
49 | let latres = parseFloat(coord.latitude.substring(1, coord.latitude.length));
50 | const lonres = parseFloat(coord.longitude.substring(1,coord.longitude.length));
51 | if(coord.latitude.startsWith("N")) latres = -latres;
52 | return {
53 | latitude: latres,
54 | longitude: lonres
55 | }
56 | }
57 | /**
58 | * 将B类坐标转换为极坐标
59 | * @param coord B类坐标
60 | * @returns 极坐标
61 | */
62 | export function parse2PolarCoord(coord: Coordinate_B): PolarCoordinate {
63 | return {
64 | radius: Math.atan(coord.latitude / coord.longitude),
65 | length: Math.sqrt(coord.latitude ^ 2 + coord.longitude ^ 2)
66 | }
67 | }
68 |
69 | export const parserMap = {
70 | 'obscure': parse2CoordB_,
71 | 'precise': parse2CoordB
72 | }
73 |
74 | /**
75 | * 实现坐标与坐标的转换
76 | * 内置坐标类型： `Coordinate_A` `Coordinate_B` `PolarCoordinate`
77 | */
78 | export default {
79 | parse2CoordA, parse2CoordB_, parse2PolarCoord, parse2CoordB
80 | }
81 |
--------------------------------------------------------------------------------
/src/lib/datatype.d.ts:
--------------------------------------------------------------------------------
1 | /**
2 | * 由一对字符串组成的坐标，形如 `N40.36.18.000` `E112.52.13.000`
3 | */
4 | export type Coordinate_A = {
5 | latitude: string,
6 | longitude: string
7 | }
8 | /**
9 | * 由一对浮点数组成的坐标，形如 `40.3613692` `112.7219753`
10 | */
11 | export type Coordinate_B = {
12 | latitude: number,
13 | longitude: number
14 | }
15 | /**
16 | * 极坐标
17 | * @param radius 极角
18 | * @param length 极径
19 | */
20 | export type PolarCoordinate = {
21 | radius: number,
22 | length: number
23 | }
24 |
25 | /**
26 | * prf配置文件的配置项
27 | */
28 | export type PrfItem = {
29 | type: string,
30 | flag: string,
31 | data: string
32 | }
33 | /**
34 | * asr文件中定义的配置
35 | */
36 | export type AsrSetting = {
37 | flag: string,
38 | data: string
39 | }
40 | /**
41 | * asr文件中定义的绘制项
42 | * @param type indicate the type of item. Possible value contains
43 | * `ARTCC low boundary` `Fixes` `Free Text`
44 | * `Geo` `Regions` `Runways` `Sids` `Stars`
45 | * `VORs`
46 | * @param name indicate the name of item. If the item is freetext, the format of name should be
47 | * `group`\\`name`
48 | * @param flag indicate the item to draw. Possible value contains
49 | * `name` `symbol` `freetext`, for runways, it will be more complex.
50 | */
51 | export type AsrDrawItem = {
52 | type: string,
53 | name: string,
54 | flag: string,
55 | draw: boolean
56 | }
57 | /**
58 | * asr文件中定义的默认显示区域，由左上角坐标及右下角坐标组成
59 | */
60 | export type AsrWindowArea = {
61 | coord1: Coordinate_B,
62 | coord2: Coordinate_B
63 | }
64 |
65 | /**
66 | * sct文件中定义的颜色组，读取时转化为16进制颜色代码
67 | */
68 | export type SctDefinition = {
69 | flag: string,
70 | color: string
71 | }
72 | /**
73 | * sct文件的版权和信息内容，仅读取版权
74 | */
75 | export type SctInfo = {
76 | copyright: string
77 | }
78 | /**
79 | * sct文件中定义的VOR及NDB
80 | */
81 | export type SctVorNdb = {
82 | name: string,
83 | frequency: string,
84 | coord: Coordinate_B,
85 | }
86 | export type SctAirport = {
87 | icao: string,
88 | frequency: string,
89 | coord: Coordinate_B,
90 | class: string,
91 |
92 | }
93 | export type SctRunway = {
94 | endPointA: string,
95 | endPointB: string,
96 | HeadingA: number,
97 | HeadingB: number,
98 | coordA: Coordinate_B,
99 | coordB: Coordinate_B,
100 | airportCode: string,
101 | airportName: string,
102 |
103 | }
104 | export type SctFix = {
105 | name: string,
106 | coord: Coordinate_B,
107 |
108 | }
109 | export type SctARTCC = {
110 | group: string,
111 | coords: {
112 | coordA: Coordinate_B,
113 | coordB: Coordinate_B,
114 | }[]
115 | }
116 | export type SctSIDSTAR = {
117 | group: string,
118 | coords: {
119 | coordA: Coordinate_B,
120 | coordB: Coordinate_B,
121 | }[]
122 | }
123 | export type SctLoHiAirway = {
124 | group: string,
125 | coords: {
126 | coordA: Coordinate_B,
127 | coordB: Coordinate_B,
128 | }[]
129 |
130 | }
131 | export type SctGEO = {
132 | group: string,
133 | items: {
134 | coordA: Coordinate_B,
135 | coordB: Coordinate_B,
136 | colorFlag: string,
137 | }[],
138 | }
139 | export type SctREGIONS = {
140 | regionName: string,
141 | items: {
142 | colorFlag: string,
143 | coords: Coordinate_B[],
144 | }[]
145 | }
146 |
147 | export type EseAirspaceDisplay = {
148 | sectorControlling: string,
149 | sectorCovered: string[]
150 | }
151 | export type EseAirspaceSubsection = {
152 | sector: {
153 | name: string | null,
154 | loAltLimit: number | null,
155 | upAltLimit: number | null
156 | } | null,
157 | owner: string[] | null,
158 | altowner: string[] | null,
159 | border: string[] | null
160 | }
161 | export type EseAirspace = {
162 | sectorline: string,
163 | displayCondition: EseAirspaceDisplay[],
164 | coords: Coordinate_B[],
165 | subsection: EseAirspaceSubsection,
166 | active: {
167 | airport: string,
168 | runway: string
169 | } | null
170 | }
171 | export type EseFreetext = {
172 | coord: Coordinate_B,
173 | group: string,
174 | text: string,
175 |
176 | }
177 | export type EsePosition = {
178 | name: string,
179 | callsign: string,
180 | frequency: string,
181 | identifier: string,
182 | middleLetter: string,
183 | prefix: string,
184 | suffix: string,
185 | notUsed1: string,
186 | notUsed2: string,
187 | startOfRange: string,
188 | endOfRange: string
189 | }
190 | export type EseSidsStars = {
191 | type: string,
192 | airport: string,
193 | runway: string,
194 | name: string,
195 | route: string[],
196 |
197 | }
198 |
199 |
200 | /**
201 | * @param type Symbology definition type, possible value contains
202 | * `Airports` `Low airways` `High airways` `Fixes` and etc.
203 | * @param flag SYmbology definition flag, possible value contains
204 | * `symbol` `name` `line`.
205 | */
206 | export type SymbologyDefine = {
207 | type: string,
208 | flag: string,
209 | data: {
210 | color: string,
211 | fontSymbolSize: number,
212 | lineWeight: number,
213 | lineStyle: number,
214 | alignment: number
215 | }
216 | }
217 | export type SymbologyDrawScript = {
218 | ident: number,
219 | sciprts: string[]
220 | }
221 |
222 | export type VoiceChannelDefine = {
223 | type: string,
224 | name: string,
225 | frequency: string,
226 | server: string,
227 | callsign: string
228 | }
229 |
230 | export type ProfileDefine = {
231 | info: {
232 | ident: string,
233 | range: number,
234 | facility: number
235 | },
236 | atis2: string | null,
237 | atis3: string | null,
238 | atis4: string | null
239 | }
240 |
--------------------------------------------------------------------------------
/src/lib/elementId.ts:
--------------------------------------------------------------------------------
1 | export const elementId = {
2 | RadarWindow: {
3 | Appbar: {
4 | Buttons: {
5 | connect: "button-connect",
6 | voiceSetting: "button-output",
7 | atisSetting: "button-atis",
8 | displaySetting: "button-display",
9 | runwaySetting: "button-runway",
10 | sectorSelect: "button-select-sector",
11 | setting: "button-setting",
12 | close: "button-close-app",
13 | maximizeOrRestore: "button-restore-app",
14 | minimize: "button-minimize-app",
15 | theme: "button-theme-toggle"
16 | },
17 | Tags: {
18 | currentCI: "appbar-connection-info",
19 | currentFrequency: "appbar-frequency",
20 | currentATIS: "appbar-atis-info",
21 | currentSector: "appbar-current-sector",
22 | currentTime: "appbar-utc-time",
23 | currentCoord: "appbar-coordinate"
24 | },
25 | Container: {
26 | metar: "app-bar"
27 | }
28 | },
29 | Canvas: {
30 | screen: "radar"
31 | },
32 | Footer: {
33 | channelChooser: "footer-channel-chooser",
34 | messageContainer: "footer-channel-message-container",
35 | toolbar: {
36 | messagebox: "tool-bar-messagebox"
37 | }
38 | },
39 | SubWin: {
40 | metar: "metarList"
41 | }
42 | }
43 | }
44 |
45 | export default elementId;
--------------------------------------------------------------------------------
/src/lib/global.ts:
--------------------------------------------------------------------------------
1 | import path from 'path';
2 | export const VMETAR_URL = "https://api.aviationapi.com/v1/weather/metar?apt=";
3 | export const METAR_URL = "https://metar.vatsim.net/";
4 | export const DefaultSectorSettingFilePath = path.join(__dirname, "config", "defaultsector.txt");
5 | export const obsAcfDataApi = "https://api.aviationapi.com/v1/vatsim/pilots?apt=";
6 | export const EARTH_RADIUS_LONG = 63.78137;
7 | export const EARTH_RADIUS_S = 63.567523142;
8 |
--------------------------------------------------------------------------------
/src/lib/ipcChannel.ts:
--------------------------------------------------------------------------------
1 | /**
2 | * 定义了程序所使用的所有ipcChannel
3 | */
4 | export const ipcChannel = {
5 | app: {
6 | window: {
7 | close: "app.window.close",
8 | maximizeOrRestore: "app.window.maximize",
9 | minimize: "app.window.minimize"
10 | },
11 | update: {
12 | prfFile: "app.update.prfFile",
13 | theme: "app.toggle.theme",
14 | themeSystem: "app.toggle.theme.system",
15 | canvasIndex: "app.update.canvas.index",
16 | canvasPos: "app.update.canvas.pos",
17 | obsAcfData: "app.update.obsAcfData",
18 | },
19 | msg: {
20 | error: "app.errmsg",
21 | warning: "app.wrnmsg",
22 | info: "app.info"
23 | },
24 | func: {
25 | connectToNetwork: "app.func.connecttonetwork",
26 | fetchWeather: "app.func.fetchweather",
27 | initRadar: "app.func.initradar",
28 | switchRadarView: "app.func.switchradarview"
29 | }
30 | }
31 | }
32 |
33 | export default ipcChannel;
--------------------------------------------------------------------------------
/src/lib/popupMsger.ts:
--------------------------------------------------------------------------------
1 | import { ipcRenderer } from "electron";
2 | import ipcChannel from "./ipcChannel";
3 |
4 | export type BoxMessage = {
5 | title: string;
6 | message: string;
7 | callback?: (response?: number, checkboxChecked?: boolean) => void;
8 | }
9 |
10 | export function ErrorBox(options: BoxMessage): void {
11 | ipcRenderer.invoke(ipcChannel.app.msg.error, {title: options.title, message: options.message});
12 | ipcRenderer.on(ipcChannel.app.msg.error, (e,args) => {
13 | if(options.callback) options.callback(args.response, args.checkboxChecked);
14 | });
15 | }
16 |
17 | export function WarningBox(options: BoxMessage): void {
18 | ipcRenderer.invoke(ipcChannel.app.msg.warning, {title: options.title, message: options.message});
19 | ipcRenderer.on(ipcChannel.app.msg.warning, (e,args) => {
20 | if(options.callback) options.callback(args.response, args.checkboxChecked);
21 | });
22 | }
23 |
24 | export function InfoBox(options: BoxMessage): void {
25 | ipcRenderer.invoke(ipcChannel.app.msg.info, {title: options.title, message: options.message});
26 | ipcRenderer.on(ipcChannel.app.msg.info, (e,args) => {
27 | if(options.callback) options.callback(args.response, args.checkboxChecked);
28 | });
29 | }
--------------------------------------------------------------------------------
/src/lib/sectortype.ts:
--------------------------------------------------------------------------------
1 | import { parse2CoordB } from "./coordparser";
2 | import { AsrDrawItem, AsrSetting, AsrWindowArea, EseAirspace, EseFreetext, EsePosition, EseSidsStars, PrfItem, SctAirport, SctARTCC, SctDefinition, SctFix, SctGEO, SctInfo, SctLoHiAirway, SctREGIONS, SctRunway, SctSIDSTAR, SctVorNdb } from "./datatype";
3 |
4 | class AsrData {
5 | settings: AsrSetting[] = [];
6 | items: AsrDrawItem[] = [];
7 | windowArea: AsrWindowArea | null = {
8 | coord1: parse2CoordB({
9 | latitude: "N0.0.0.0",
10 | longitude: "E0.0.0.0"
11 | }),
12 | coord2: parse2CoordB({
13 | latitude: "N0.0.0.0",
14 | longitude: "E0.0.0.0"
15 | })
16 | };
17 | }
18 |
19 | class PrfData {
20 | settings: PrfItem[] = [];
21 | }
22 |
23 | class SctData {
24 | definitions: SctDefinition[] = [];
25 | info: SctInfo = { copyright: "" };
26 | vors: SctVorNdb[] = [];
27 | ndbs: SctVorNdb[] = [];
28 | airports: SctAirport[] = [];
29 | runways: SctRunway[] = [];
30 | fixes: SctFix[] = [];
31 | ARTCCs: SctARTCC[] = [];
32 | sids: SctSIDSTAR[] = [];
33 | stars: SctSIDSTAR[] = [];
34 | loAirways: SctLoHiAirway[] = [];
35 | hiAirways: SctLoHiAirway[] = [];
36 | GEOs: SctGEO[] = [];
37 | REGIONs: SctREGIONS[] = [];
38 | }
39 |
40 | class EseData {
41 | airspacces: EseAirspace[] = [];
42 | freetexts: EseFreetext[] = [];
43 | positions: EsePosition[] = [];
44 | sidsstars: EseSidsStars[] = [];
45 | }
46 |
47 |
48 |
49 | export {
50 | AsrData, PrfData, EseData, SctData
51 | }
--------------------------------------------------------------------------------
/src/lib/settingtype.ts:
--------------------------------------------------------------------------------
1 | import { SymbologyDefine, SymbologyDrawScript, VoiceChannelDefine, ProfileDefine } from "./datatype";
2 |
3 | export class SymbologyData {
4 | colors: SymbologyDefine[] = [];
5 | scripts: SymbologyDrawScript[] = [];
6 | m_ClipArea = 0;
7 | }
8 |
9 | export class VoiceData {
10 | channels: VoiceChannelDefine[] = [];
11 | }
12 |
13 | export class ProfileData {
14 | profile: ProfileDefine[] = [];
15 | }
16 |
17 | export default {
18 | SymbologyData,VoiceData,ProfileData
19 | }
--------------------------------------------------------------------------------
/src/lib/spaceformatter.ts:
--------------------------------------------------------------------------------
1 | /**
2 | * 清除字符串中多余的空格
3 | * @param source 原字符串
4 | * @returns 处理后的字符串
5 | */
6 | export function CleanSpaces(source: string) : string
7 | {
8 | source = source.trim();
9 | while( source.lastIndexOf(" ") !== -1 )
10 | {
11 | source = source.replace(" "," ");
12 | }
13 | return source;
14 | }
15 |
16 | export default {
17 | CleanSpaces
18 | }
--------------------------------------------------------------------------------
/src/main.ts:
--------------------------------------------------------------------------------
1 | import { createApp } from 'vue'
2 | import App from './App.vue'
3 | import Antd from 'ant-design-vue'
4 | import 'ant-design-vue/dist/antd.css'
5 |
6 | createApp(App).use(Antd).mount('#app')
7 |
--------------------------------------------------------------------------------
/src/preloads/preload.ts:
--------------------------------------------------------------------------------
1 | import ipcChannel from '../lib/ipcChannel'
2 | import { ipcRenderer, contextBridge } from 'electron'
3 | import Drawer from '../utils/drawer'
4 | import elementId from '../lib/elementId'
5 | import path from 'path'
6 | import fs from 'fs'
7 | import { DefaultSectorSettingFilePath } from '../lib/global'
8 | contextBridge.exposeInMainWorld('appbar', {
9 | quitApp: () => ipcRenderer.invoke(ipcChannel.app.window.close),
10 | maximizeApp: () => ipcRenderer.invoke(ipcChannel.app.window.maximizeOrRestore),
11 | minimizeApp: () => ipcRenderer.invoke(ipcChannel.app.window.minimize),
12 | updateTime: () => {
13 | return getTime()
14 | },
15 | openSector: () => ipcRenderer.invoke(ipcChannel.app.update.prfFile)
16 | })
17 | const drawerGroup: Drawer[] = [];
18 | let activeDrawerIndex = 0;
19 | contextBridge.exposeInMainWorld('radar', {
20 | init: function (rootEl: string) {
21 | const drawer = new Drawer(rootEl)
22 | drawerGroup.push(drawer)
23 | const screen = document.getElementById(elementId.RadarWindow.Canvas.screen)
24 | if (!screen) return
25 | screen.addEventListener('wheel', (e) => {
26 | drawerGroup[activeDrawerIndex].UpdateCanvasIndex(e);
27 | })
28 | screen.oncontextmenu = function (ev: MouseEvent) {
29 | const distX = ev.clientX - screen.offsetLeft;
30 | const distY = ev.clientY - screen.offsetTop;
31 | screen.onmousemove = function (e) {
32 | const tX = e.clientX - distX;
33 | const tY = e.clientY - distY;
34 | screen.style.left = `${tX}px`
35 | screen.style.top = `${tY}px`
36 | drawerGroup[activeDrawerIndex].UpdateCanvasPosE(e)
37 | }
38 | }
39 | screen.onmouseup = function () {
40 | drawerGroup[activeDrawerIndex].ClearCanvas();
41 | screen.style.left = '0px'
42 | screen.style.top = '45px'
43 | screen.onmousemove = null
44 | }
45 | ipcRenderer.on(ipcChannel.app.update.prfFile, (e, args) => {
46 | const sectorindicator = document.getElementById(elementId.RadarWindow.Appbar.Tags.currentCoord)
47 | if (sectorindicator) sectorindicator.innerText = path.basename(args.path)
48 | if (!fs.existsSync(DefaultSectorSettingFilePath)) {
49 | fs.openSync(DefaultSectorSettingFilePath, 1)
50 | }
51 | fs.writeFileSync(DefaultSectorSettingFilePath, args.path, 'utf-8')
52 | drawerGroup[activeDrawerIndex].UpdateCache(args.path);
53 | drawerGroup[activeDrawerIndex].ClearCanvas();
54 | })
55 | ipcRenderer.on(ipcChannel.app.func.switchRadarView, (e, args) => {
56 | //如果所选视图大于已有
57 | while (args + 1 > drawerGroup.length) {
58 | drawerGroup.push(new Drawer('radar'))
59 | }
60 | drawerGroup.forEach((o) => {
61 | o.Hide()
62 | })
63 | activeDrawerIndex = args
64 | drawerGroup[args].Show()
65 | })
66 | }
67 | })
68 | let isSearchingWx = false
69 | ipcRenderer.on(ipcChannel.app.func.fetchWeather, (e, arg) => {
70 | isSearchingWx = false
71 | const metars: string[] = arg.split('\n')
72 | metars.forEach(metar => {
73 | const icao = metar.substring(0, 4)
74 | let exist = false
75 | for (let index = 0; index < weatherData.length; index++) {
76 | const weather = weatherData[index];
77 | if (weather.icao == icao && weather.metar !== metar) {
78 | weather.metar = metar
79 | weather.updateTime = getTime()
80 | exist = true
81 | }
82 | }
83 | if (!exist) weatherData.push({ icao: icao, updateTime: getTime(), metar: metar })
84 | })
85 | })
86 | const weatherData: { icao: string, metar: string, updateTime: string }[] = []
87 | contextBridge.exposeInMainWorld('weather', {
88 | requestWx: (icaos: string) => {
89 | isSearchingWx = true
90 | ipcRenderer.invoke(ipcChannel.app.func.fetchWeather, icaos)
91 | },
92 | weatherData: () => {
93 | return weatherData
94 | },
95 | searchStatus: () => {
96 | return isSearchingWx
97 | }
98 | })
99 | const aircraftData: {
100 | title: string,
101 | cols: string[],
102 | contextMenu: any[],
103 | key: string,
104 | aircrafts: any[],
105 | }[] = [
106 | {
107 | title: 'Departure',
108 | cols: [
109 | "C/S", "TYPE", "C", "D", "STS", "R", "DEP", "ARR",
110 | "RWY", "SIE", "SID", "S/PAD", "ALT", "CRZ", "ASSR"
111 | ],
112 | contextMenu: [
113 | {
114 | title: "Clearance",
115 | items: [
116 | "Unset",
117 | "Pending",
118 | "Ready"
119 | ]
120 | },
121 | {
122 | title: "Status",
123 | items: [
124 | "Stand",
125 | "Push",
126 | "Taxi",
127 | "Takeoff",
128 | "Climb",
129 | "Cruise",
130 | "Descend",
131 | "Approach"
132 | ]
133 | }
134 | ],
135 | key: '1',
136 | aircrafts: [
137 | {
138 | 'C/S': 'CALLSIGN',
139 | 'TYPE': 'TYPE',
140 | 'C': 'CLEARANCE',
141 | 'D': 'UNKNOWN',
142 | 'STS': 'STATUS',
143 | 'R': 'UNKNOWN',
144 | 'DEP': 'A',
145 | 'ARR': 'B',
146 | 'RWY': 'C',
147 | 'SIE': 'SIE',
148 | },
149 | {
150 | 'C/S': 'CALLSIGNB',
151 | 'TYPE': 'TYPE',
152 | 'C': 'CLEARANCE',
153 | 'D': 'UNKNOWN',
154 | 'STS': 'STATUS',
155 | 'R': 'UNKNOWN',
156 | 'DEP': 'A',
157 | 'ARR': 'B',
158 | 'RWY': 'C',
159 | 'SIE': 'SIE',
160 | }
161 | ]
162 | }, {
163 | title: 'Exit',
164 | key: '2',
165 | cols: [
166 | "RWY", "C/S", "TYPE", "DEP", "ARR", "SIE", "SID",
167 | "STE", "STAR", "NXT", "EXT", "COPN", "CRZ", "ASSR"
168 | ],
169 | contextMenu: [
170 | "Runway", "C/S", "TYPE", "DEP", "ARR", "SIE", "SID",
171 | "STE", "STAR", "NXT", "EXT", "COPN", "CRZ", "ASSR"
172 | ],
173 | aircrafts: [
174 | ]
175 | }, {
176 | title: 'Inbound',
177 | key: '3',
178 | cols: [
179 | "RWY", "C/S", "TYPE", "R", "DEP", "ARR", "STE", "STAR",
180 | "NXT", "S/PAD", "ENT", "COPN", "CRZ", "ASSR"
181 | ],
182 | contextMenu: [
183 | "RWY", "C/S", "TYPE", "R", "DEP", "ARR", "STE", "STAR",
184 | "NXT", "S/PAD", "ENT", "COPN", "CRZ", "ASSR"
185 | ],
186 | aircrafts: [
187 | ]
188 | }
189 | ]
190 | let obsAcfData = "";
191 | contextBridge.exposeInMainWorld('acflist', {
192 | init: () => {
193 | setInterval(() => {
194 | ipcRenderer.on(ipcChannel.app.update.obsAcfData, (e, arg) => {
195 | obsAcfData = arg
196 | })
197 | }, 5000)
198 | },
199 | aircraftData: () => {
200 | return aircraftData
201 | },
202 | getObsAcfData: () => {
203 | ipcRenderer.invoke(ipcChannel.app.update.obsAcfData, "ZYTL");
204 | return obsAcfData;
205 | }
206 | })
207 | function getTime() {
208 | const date = new Date()
209 | const year = date.getUTCFullYear().toString()
210 | const month = (date.getUTCMonth() + 1).toString()
211 | const day = date.getUTCDate().toString()
212 | const hrs = date.getUTCHours().toString().padStart(2, "0")
213 | const min = date.getUTCMinutes().toString().padStart(2, "0")
214 | const sec = date.getUTCSeconds().toString().padStart(2, "0")
215 | return `${month}/${day}/${year} ${hrs}:${min}:${sec}`
216 | }
217 | console.log('preloaded')
--------------------------------------------------------------------------------
/src/shims-vue.d.ts:
--------------------------------------------------------------------------------
1 | /* eslint-disable */
2 | declare module '*.vue' {
3 | import type { DefineComponent } from 'vue'
4 | const component: DefineComponent<{}, {}, any>
5 | export default component
6 | }
7 |
--------------------------------------------------------------------------------
/src/utils/drawer.ts:
--------------------------------------------------------------------------------
1 | import { AsrData, EseData, PrfData, SctData } from "@/lib/sectortype";
2 | import elementId from "../lib/elementId";
3 | import { LoadAsrFileSync, LoadPrfFileSync, LoadSctFileSync, LoadEseFileSync, ReadPrfData, ConvertEsePath, ReadSctFix, ReadSymbol, ReadEseFreeText, ReadSctGeo, ReadSctRegions, ReadSctDefine, AlignPath, ReadSctLoHiAw, ReadSctAirport, ReadSctVORNDB, ReadSctARTCC, ReadSctSidStar, ReadSctRunway } from "./prfsectorloader";
4 | import { VoiceData, SymbologyData, ProfileData } from "@/lib/settingtype";
5 | import { LoadSymbologySync, LoadVoiceSync, LoadProfileSync } from "./settingloader";
6 | // import { ipcRenderer } from "electron";
7 | // import ipcChannel from "../lib/ipcChannel";
8 | import path from 'path';
9 | import { SctSIDSTAR, SctVorNdb } from "@/lib/datatype";
10 | // import fs from 'fs';
11 | // import { DefaultSectorSettingFilePath } from "../lib/global";
12 |
13 | const SCROLL_INDEX = 1.2;
14 | const AP_FREETEXT_LIMIT = 20000;//要显示机场FREETEXT的最小缩放倍数
15 | const FIX_NAME_LIMIT = 150;
16 | const AW_NAME_LIMIT_MIN = 100;
17 | const AW_NAME_LIMIT_MAX = 150;
18 | const ZOOM_INDEX_MAX = 250000;//最大缩放倍数
19 | export class Drawer {
20 | public rootElement: HTMLElement | null;
21 | public canvas: HTMLCanvasElement;
22 | public canvasContext: CanvasRenderingContext2D | null;
23 | public coordIndicator: HTMLElement | null;
24 | public canvasIndex: number;
25 | public canvasPosX: number;
26 | public canvasPosY: number;
27 | public prfCache: PrfData | undefined;
28 | public asrCache: AsrData | undefined;
29 | public sectorCache: SctData | undefined;
30 | public eseCache: EseData | undefined;
31 | public symbolCache: SymbologyData | undefined;
32 | public voiceCache: VoiceData | undefined;
33 | public profileCache: ProfileData | undefined;
34 | constructor(rootElement: string) {
35 | this.canvas = document.createElement('canvas');
36 | this.canvasContext = this.canvas.getContext('2d');
37 | this.coordIndicator = document.getElementById(elementId.RadarWindow.Appbar.Tags.currentCoord);
38 | this.rootElement = document.getElementById(rootElement);
39 | this.canvas.id = "radar-drawer";
40 | this.rootElement?.appendChild(this.canvas);
41 | this.canvasIndex = 1;
42 | this.canvasPosX = 0;
43 | this.canvasPosY = 0;
44 | //当页面大小被改变时，重新进行绘制
45 | window.addEventListener('resize', () => {
46 | this.ClearCanvas();
47 | });
48 | }
49 | public Hide() {
50 | this.canvas.style.display = 'none'
51 | }
52 | public Show() {
53 | this.canvas.style.display = 'block'
54 | }
55 | public ClearCanvas(): void {
56 | this.canvas.height = window.innerHeight;
57 | this.canvas.width = window.innerWidth;
58 | this.Draw();
59 | }
60 | public UpdateCanvasIndex(event: WheelEvent): void {
61 | const xresult = this.canvasPosX + (event.movementX) / this.canvasIndex;
62 | const yresult = this.canvasPosY + (event.movementY) / this.canvasIndex;
63 | this.canvasPosX = xresult;
64 | this.canvasPosY = yresult;
65 | if (event.deltaY < 0) {
66 | const result = this.canvasIndex * SCROLL_INDEX;
67 | if (result < ZOOM_INDEX_MAX) this.canvasIndex = result;
68 | }
69 | else {
70 | const result = this.canvasIndex / SCROLL_INDEX;
71 | if (result > 1) this.canvasIndex = result;
72 | }
73 | /**
74 | * 检测canvasIndex是否小于绘制FREETEXT的最低要求
75 | */
76 | if (this.canvasIndex < AP_FREETEXT_LIMIT) {
77 | this.asrCache?.items.forEach((item) => {
78 | if (item.name.lastIndexOf("\\") !== -1) item.draw = false;
79 | });
80 | } else {
81 | this.asrCache?.items.forEach((item) => {
82 | if (item.name.lastIndexOf("\\") !== -1) item.draw = true;
83 | });
84 | }
85 | /**
86 | * 检测canvasIndex是否小于绘制FIXNAME的最低要求
87 | */
88 | if (this.canvasIndex < FIX_NAME_LIMIT) {
89 | this.asrCache?.items.forEach((item) => {
90 | if (item.type == "Fixes") item.draw = false;
91 | });
92 | } else {
93 | this.asrCache?.items.forEach((item) => {
94 | if (item.type == "Fixes") item.draw = true;
95 | });
96 | }
97 | /**
98 | * 检测canvasIndex是否在限定绘制Airways name的范围
99 | */
100 | if (this.canvasIndex > AW_NAME_LIMIT_MIN && this.canvasIndex < AW_NAME_LIMIT_MAX) {
101 | this.asrCache?.items.forEach((item) => {
102 | if (item.type.endsWith("airways") && item.flag == "name") item.draw = true;
103 | });
104 | } else {
105 | this.asrCache?.items.forEach((item) => {
106 | if (item.type.endsWith("airways") && item.flag == "name") item.draw = false;
107 | });
108 | }
109 | if (!this.coordIndicator) return;
110 | this.coordIndicator.innerText = `Lat: ${this.canvasPosY} Lon: ${-this.canvasPosX}`;
111 | this.ClearCanvas();
112 | }
113 | public UpdateCanvasPosE(e: MouseEvent): void {
114 | const xresult = this.canvasPosX + (e.movementX) / this.canvasIndex;
115 | const yresult = this.canvasPosY + (e.movementY) / this.canvasIndex;
116 | this.canvasPosX = xresult;
117 | this.canvasPosY = yresult;
118 | if (!this.coordIndicator) return;
119 | this.coordIndicator.innerText = `Lat: ${this.canvasPosY} Lon: ${-this.canvasPosX}`;
120 | }
121 | public UpdateCanvasPosXY(x:number,y:number){
122 | this.canvasPosX += x / this.canvasIndex;
123 | this.canvasPosY += y / this.canvasIndex;
124 | }
125 | /**
126 | * 更新绘制缓存
127 | * @param prfPath prf文件目录
128 | */
129 | public UpdateCache(prfPath: string): void {
130 | this.prfCache = LoadPrfFileSync(prfPath);
131 | let asrpath = ReadPrfData(this.prfCache, "Recent1");
132 | if (!asrpath) return;
133 | asrpath = path.join(prfPath, "..", AlignPath(asrpath));
134 | this.asrCache = LoadAsrFileSync(asrpath);
135 | let sctpath = ReadPrfData(this.prfCache, "sector");
136 | if (!sctpath) return;
137 | sctpath = path.join(prfPath, "..", AlignPath(sctpath));
138 | this.sectorCache = LoadSctFileSync(sctpath);
139 | const esepath = ConvertEsePath(sctpath);
140 | this.eseCache = LoadEseFileSync(esepath);
141 | let symbologypath = ReadPrfData(this.prfCache, "SettingsfileSYMBOLOGY");
142 | if (!symbologypath) return;
143 | symbologypath = path.join(prfPath, "..", AlignPath(symbologypath));
144 | this.symbolCache = LoadSymbologySync(symbologypath);
145 | const ap = document.getElementById('back');
146 | const backgroundColor = ReadSymbol(this.symbolCache.colors, "Sector", "active sector background")?.color;
147 | if (backgroundColor !== undefined) {
148 | this.canvas.style.backgroundColor = backgroundColor;
149 | if(ap) ap.style.backgroundColor = backgroundColor;
150 | }
151 | let voicepath = ReadPrfData(this.prfCache, "SettingsfileVOICE");
152 | if (!voicepath) return;
153 | voicepath = path.join(prfPath, "..", AlignPath(voicepath));
154 | this.voiceCache = LoadVoiceSync(voicepath);
155 | let profilepath = ReadPrfData(this.prfCache, "SettingsfilePROFILE");
156 | if (!profilepath) return;
157 | profilepath = path.join(prfPath, "..", AlignPath(profilepath));
158 | this.profileCache = LoadProfileSync(profilepath);
159 | }
160 | public UpdateAcfCache(): void {
161 | return
162 | }
163 | public Draw(): void {
164 | if (!this.canvasContext) return;
165 | this.canvasContext.translate(window.innerWidth / 2, window.innerHeight / 2);
166 | this.canvasContext.translate(this.canvasPosX, this.canvasPosY);
167 | this.canvasContext.translate(this.canvasPosX * (this.canvasIndex - 1), this.canvasPosY * (this.canvasIndex - 1));
168 | if (!this.asrCache) return;
169 | this.asrCache.items.forEach((item) => {
170 | if (!this.sectorCache || !this.symbolCache) return;
171 | if (item.type == "Regions") {
172 | const regions = ReadSctRegions(this.sectorCache.REGIONs, item.name);//从缓存中提取出对应regions区域
173 | if (!regions) return;//如果缓存中不存在该区域，则返回，进行下一次操作
174 | regions.items.forEach((item) => {//对每个提取出来的区域进行绘制
175 | if (!this.sectorCache || !this.canvasContext) return;
176 | this.canvasContext.beginPath();//开始绘制
177 | const color = ReadSctDefine(this.sectorCache.definitions, item.colorFlag);//从缓存中提取出对应的颜色，region的颜色被定义在sct中
178 | if (!color) return;//如果sct中不存在对应的颜色flag定义，说明扇区有问题或读取失败
179 | this.canvasContext.lineWidth = 0.1;
180 | this.canvasContext.strokeStyle = color;
181 | this.canvasContext.fillStyle = color;
182 | const count = item.coords.length;//获取坐标总数，为for循环做好准备
183 | const line = new Path2D();//新建一个二维路径
184 | line.moveTo(item.coords[0].longitude * this.canvasIndex, item.coords[0].latitude * this.canvasIndex);//将二维路径绘制点移动到初始坐标
185 | // this.canvasContext.moveTo(item.coords[0].longtitude * this.canvasIndex, item.coords[0].latitude * this.canvasIndex);
186 | for (let index = 1; index < count; index++) {//循环绘制下一个坐标
187 | const coord = item.coords[index];
188 | // console.log("drawing",coord.longtitude, coord.latitude);
189 | line.lineTo(coord.longitude * this.canvasIndex, coord.latitude * this.canvasIndex);
190 | // this.canvasContext.lineTo(coord.longtitude * this.canvasIndex, coord.latitude * this.canvasIndex);
191 | }
192 | // line.moveTo(coord0.longtitude * this.canvasIndex, coord0.latitude * this.canvasIndex);//将二维路径绘制点移动到初始坐标
193 | line.closePath();//闭合路径
194 | // this.canvasContext.closePath();
195 | this.canvasContext.stroke(line);
196 | this.canvasContext.fill(line);
197 | });
198 | }
199 | })
200 | this.asrCache.items.forEach((item) => {
201 | if (!item.draw) return;
202 | if (!this.canvasContext) return;
203 | if (!this.sectorCache || !this.symbolCache || !this.eseCache) return;
204 | if (item.type == "Fixes")//绘制fix的symbol或name
205 | {
206 | const coord = ReadSctFix(this.sectorCache.fixes, item.name);
207 | if (!coord) return;
208 | const symbol = ReadSymbol(this.symbolCache.colors, item.type, item.flag);
209 | if (!symbol) return;
210 | this.canvasContext.fillStyle = symbol.color;
211 | if (item.flag == "name") {
212 | this.canvasContext.font = symbol.fontSymbolSize * 2.5 + "px Arial";
213 | this.canvasContext.fillText(item.name, coord.longitude * this.canvasIndex, coord.latitude * this.canvasIndex);
214 | }
215 | else {
216 | //这里的代码后续需要实现DrawScript
217 | const size = symbol.fontSymbolSize;
218 | this.canvasContext.fillRect(coord.longitude * this.canvasIndex, coord.latitude * this.canvasIndex, size, size);
219 | }
220 | }
221 | if (item.type == "Geo")//绘制地面线
222 | {
223 | const geogroup = ReadSctGeo(this.sectorCache.GEOs, item.name);
224 | const symbol = ReadSymbol(this.symbolCache.colors, item.type, "line");
225 | if (!geogroup || !symbol) return;
226 | this.canvasContext.lineWidth = symbol.lineWeight + this.canvasIndex / 100000;
227 | geogroup.forEach((geo) => {
228 | if (!this.sectorCache || !this.canvasContext) return;
229 | const colorDef = ReadSctDefine(this.sectorCache.definitions, geo.colorFlag);
230 | if (!colorDef) return;
231 | const line = new Path2D();
232 | line.moveTo(geo.coordA.longitude * this.canvasIndex, geo.coordA.latitude * this.canvasIndex);
233 | line.lineTo(geo.coordB.longitude * this.canvasIndex, geo.coordB.latitude * this.canvasIndex);
234 | this.canvasContext.strokeStyle = colorDef;
235 | this.canvasContext.stroke(line);
236 | });
237 | }
238 | if (item.type == "High airways")//绘制高空航路
239 | {
240 | const aw = ReadSctLoHiAw(this.sectorCache.hiAirways, item.name);
241 | // console.log(aw)
242 | if (!aw) return;
243 | aw.coords.forEach(coord => {
244 | if (!coord || !this.symbolCache || !this.canvasContext) return;
245 | const symbol = ReadSymbol(this.symbolCache.colors, item.type, item.flag);
246 | if (!symbol) return;
247 | const line = new Path2D();
248 | line.moveTo(coord.coordA.longitude * this.canvasIndex, coord.coordA.latitude * this.canvasIndex);
249 | line.lineTo(coord.coordB.longitude * this.canvasIndex, coord.coordB.latitude * this.canvasIndex);
250 | if (item.flag == "name") {
251 | this.canvasContext.fillStyle = symbol.color;
252 | this.canvasContext.font = symbol.fontSymbolSize * 3 + "px Arial";
253 | this.canvasContext.fillText(aw.group, (coord.coordA.longitude * this.canvasIndex + coord.coordB.longitude * this.canvasIndex) / 2, (coord.coordA.latitude * this.canvasIndex + coord.coordB.latitude * this.canvasIndex) / 2)
254 | }
255 | else {
256 | this.canvasContext.lineWidth = symbol.lineWeight;
257 | this.canvasContext.strokeStyle = symbol.color;
258 | this.canvasContext.stroke(line);
259 | }
260 | });
261 | }
262 | if (item.type == "Low airways")//绘制低空航路
263 | {
264 | const aw = ReadSctLoHiAw(this.sectorCache.hiAirways, item.name);
265 | // console.log(aw);
266 | if (!aw) return;
267 | aw.coords.forEach(coord => {
268 | if (!coord || !this.symbolCache || !this.canvasContext) return;
269 | const symbol = ReadSymbol(this.symbolCache.colors, item.type, item.flag);
270 | if (!symbol) return;
271 | const line = new Path2D();
272 | line.moveTo(coord.coordA.longitude * this.canvasIndex, coord.coordA.latitude * this.canvasIndex);
273 | line.lineTo(coord.coordB.longitude * this.canvasIndex, coord.coordB.latitude * this.canvasIndex);
274 | if (item.flag == "name") {
275 | this.canvasContext.fillStyle = symbol.color;
276 | this.canvasContext.font = symbol.fontSymbolSize * 3 + "px Arial";
277 | this.canvasContext.fillText(aw.group, (coord.coordA.longitude * this.canvasIndex + coord.coordB.longitude * this.canvasIndex) / 2, (coord.coordA.latitude * this.canvasIndex + coord.coordB.latitude * this.canvasIndex) / 2)
278 | }
279 | else {
280 | this.canvasContext.lineWidth = symbol.lineWeight;
281 | this.canvasContext.setLineDash([15, 25]);
282 | this.canvasContext.strokeStyle = symbol.color;
283 | this.canvasContext.stroke(line);
284 | }
285 | });
286 | }
287 | if (item.type == "Runways") {
288 | const nameItems = item.name.split(" ");
289 | const runway = ReadSctRunway(this.sectorCache.runways, nameItems[0], nameItems[2]);
290 | const symbol = ReadSymbol(this.symbolCache.colors, item.type, item.flag);
291 | if (!runway || !symbol) return;
292 | this.canvasContext.strokeStyle = symbol.color;
293 | this.canvasContext.font = symbol.fontSymbolSize * 2.3 + "px Arial";
294 | if (item.flag == "name") {
295 | this.canvasContext.fillText(runway.endPointA, runway.coordA.longitude * this.canvasIndex, runway.coordA.latitude * this.canvasIndex);
296 | this.canvasContext.fillText(runway.endPointB, runway.coordB.longitude * this.canvasIndex, runway.coordB.latitude * this.canvasIndex);
297 | }
298 | else {
299 | const line = new Path2D();
300 | line.moveTo(runway.coordA.longitude * this.canvasIndex, runway.coordA.latitude * this.canvasIndex);
301 | line.lineTo(runway.coordB.longitude * this.canvasIndex, runway.coordB.latitude * this.canvasIndex);
302 | this.canvasContext.stroke(line);
303 | }
304 | }
305 | if (item.type == "NDBs" || item.type == "VORs") {
306 | let vorndb: SctVorNdb | undefined;
307 | if (item.type == "NDBs") vorndb = ReadSctVORNDB(this.sectorCache.ndbs, item.name);
308 | if (item.type == "VORs") vorndb = ReadSctVORNDB(this.sectorCache.vors, item.name);
309 | if (!vorndb) return;
310 | const symbol = ReadSymbol(this.symbolCache.colors, item.type, item.flag);
311 | if (!symbol) return;
312 | this.canvasContext.fillStyle = symbol.color;
313 | const size = symbol.fontSymbolSize;
314 | this.canvasContext.font = size * 2.3 + "px Arial";
315 | if (item.flag == "name") {
316 | this.canvasContext.fillText(vorndb.name, vorndb.coord.longitude * this.canvasIndex, vorndb.coord.latitude * this.canvasIndex);
317 | }
318 | else {
319 | //这里同样要实现绘制脚本
320 | this.canvasContext.fillRect(vorndb.coord.longitude * this.canvasIndex, vorndb.coord.latitude * this.canvasIndex, size, size)
321 | }
322 | }
323 | if (item.type == "Airports") {
324 | const airport = ReadSctAirport(this.sectorCache.airports, item.name);
325 | if (!airport) return;
326 | const symbol = ReadSymbol(this.symbolCache.colors, item.type, item.flag);
327 | if (!symbol) return;
328 | this.canvasContext.fillStyle = symbol.color;
329 | const size = symbol.fontSymbolSize;
330 | this.canvasContext.font = size * 2.3 + "px Arial";
331 | if (item.flag == "name") {
332 | this.canvasContext.fillText(airport.icao, airport.coord.longitude * this.canvasIndex, airport.coord.latitude * this.canvasIndex);
333 | }
334 | else {
335 | this.canvasContext.fillRect(airport.coord.longitude * this.canvasIndex, airport.coord.latitude * this.canvasIndex, size, size);
336 | }
337 | }
338 | if (item.type == "Free Text")//绘制freetext
339 | {
340 | const groupandtext = item.name.split("\\");
341 | const origincoord = ReadEseFreeText(this.eseCache.freetexts, groupandtext[0], groupandtext[1]);
342 | const symbol = ReadSymbol(this.symbolCache.colors, "Other", item.flag);
343 | if (!origincoord) return;
344 | if (!symbol) return;
345 | this.canvasContext.font = symbol.fontSymbolSize * 3.3 + "px Arial";
346 | this.canvasContext.fillText(groupandtext[1], origincoord.longitude * this.canvasIndex, origincoord.latitude * this.canvasIndex);
347 | }
348 | if (item.type == "ARTCC boundary") {
349 | const artcc = ReadSctARTCC(this.sectorCache.ARTCCs, item.name);
350 | const symbol = ReadSymbol(this.symbolCache.colors, item.type, "line");
351 | if (!symbol || !artcc) return;
352 | this.canvasContext.lineWidth = symbol.lineWeight;
353 | this.canvasContext.strokeStyle = symbol.color;
354 | artcc.coords.forEach((coord) => {
355 | const line = new Path2D();
356 | line.moveTo(coord.coordA.longitude * this.canvasIndex, coord.coordA.latitude * this.canvasIndex);
357 | line.lineTo(coord.coordB.longitude * this.canvasIndex, coord.coordB.latitude * this.canvasIndex);
358 | this.canvasContext?.stroke(line);
359 | });
360 | }
361 | if (item.type == "Sids" || item.type == "Stars") {
362 | let sidstar: SctSIDSTAR | undefined;
363 | if (item.type == "Sids") sidstar = ReadSctSidStar(this.sectorCache.sids, item.name);
364 | if (item.type == "Stars") sidstar = ReadSctSidStar(this.sectorCache.stars, item.name);
365 | const symbol = ReadSymbol(this.symbolCache.colors, item.type, "line");
366 | if (!sidstar || !symbol) return;
367 | this.canvasContext.lineWidth = symbol.lineWeight;
368 | this.canvasContext.strokeStyle = symbol.color;
369 | this.canvasContext.setLineDash([5, 5]);
370 | sidstar.coords.forEach((coordpair) => {
371 | const line = new Path2D();
372 | line.moveTo(coordpair.coordA.longitude * this.canvasIndex, coordpair.coordA.latitude * this.canvasIndex);
373 | line.lineTo(coordpair.coordB.longitude * this.canvasIndex, coordpair.coordB.latitude * this.canvasIndex);
374 | this.canvasContext?.stroke(line);
375 | });
376 | }
377 | });
378 | }
379 | }
380 |
381 | export default Drawer;
382 |
--------------------------------------------------------------------------------
/src/utils/settingloader.ts:
--------------------------------------------------------------------------------
1 | import fs from "fs";
2 | import * as jschardet from "iconv-jschardet";
3 | import { ProfileData, SymbologyData, VoiceData } from "../lib/settingtype";
4 |
5 | export function LoadSymbology(path: string, callback: (err: NodeJS.ErrnoException | null, data: SymbologyData) => void): void {
6 | if (fs.existsSync(path)) {
7 | const result: SymbologyData = new SymbologyData();
8 | fs.readFile(path, (err, data) => {
9 | const encodetype = jschardet.detect(data);
10 | let decodedData: string[];
11 | switch (encodetype.encoding) {
12 | case 'UTF-8':
13 | decodedData = data.toString('utf-8').split("\n");
14 | break;
15 | default:
16 | decodedData = jschardet.decode(data, 'gbk').split("\n");
17 | break;
18 | }
19 | decodedData.forEach((line) => {
20 | const dataline = line.split(":");
21 | if (dataline.length == 7) {
22 | const hexcolor = dataline[2];
23 | result.colors.push({
24 | type: dataline[0],
25 | flag: dataline[1],
26 | data: {
27 | color: hexcolor,
28 | fontSymbolSize: parseFloat(dataline[3]),
29 | lineWeight: parseFloat(dataline[4]) == 0 ? 0.5 : parseFloat(dataline[4]) / 3,
30 | lineStyle: parseInt(dataline[5]),
31 | alignment: parseInt(dataline[6])
32 | }
33 | });
34 | }
35 | else {
36 | if (dataline[0] == "SYMBOL") {
37 | result.scripts.push({
38 | ident: parseInt(dataline[1]),
39 | sciprts: []
40 | });
41 | }
42 | else if (dataline[0] == "SYMBOLITEM") {
43 | result.scripts[result.scripts.length - 1].sciprts.push(dataline[1]);
44 | }
45 | else if (dataline[0] == "m_ClipArea") {
46 | result.m_ClipArea = parseInt(dataline[1]);
47 | }
48 | }
49 | });
50 | callback(err, result);
51 | });
52 | }
53 | else {
54 | throw `path: ${path} does not exist.`;
55 | }
56 | }
57 |
58 | export function LoadSymbologySync(path: string): SymbologyData {
59 | if (fs.existsSync(path)) {
60 | const result: SymbologyData = new SymbologyData();
61 | const data = fs.readFileSync(path);
62 | const encodetype = jschardet.detect(data);
63 | let decodedData: string[];
64 | switch (encodetype.encoding) {
65 | case 'UTF-8':
66 | decodedData = data.toString('utf-8').split("\n");
67 | break;
68 | default:
69 | decodedData = jschardet.decode(data, 'gbk').split("\n");
70 | break;
71 | }
72 | decodedData.forEach((line) => {
73 | const dataline = line.split(":");
74 | if (dataline.length == 7) {
75 | const color = "#" + parseInt(dataline[2]).toString(16).padStart(6, "0");
76 | result.colors.push({
77 | type: dataline[0],
78 | flag: dataline[1],
79 | data: {
80 | color: color,
81 | fontSymbolSize: parseFloat(dataline[3]),
82 | lineWeight: parseFloat(dataline[4]) == 0 ? 0.5 : parseFloat(dataline[4]) / 3,
83 | lineStyle: parseInt(dataline[5]),
84 | alignment: parseInt(dataline[6])
85 | }
86 | });
87 | }
88 | else {
89 | if (dataline[0] == "SYMBOL") {
90 | result.scripts.push({
91 | ident: parseInt(dataline[1]),
92 | sciprts: []
93 | });
94 | }
95 | else if (dataline[0] == "SYMBOLITEM") {
96 | result.scripts[result.scripts.length - 1].sciprts.push(dataline[1]);
97 | }
98 | else if (dataline[0] == "m_ClipArea") {
99 | result.m_ClipArea = parseInt(dataline[1]);
100 | }
101 | }
102 | });
103 | return result;
104 | }
105 | else {
106 | throw `path: ${path} does not exist.`;
107 | }
108 | }
109 |
110 | export function LoadVoice(path: string, callback: (err: NodeJS.ErrnoException | null, data: VoiceData) => void): void {
111 | if (fs.existsSync(path)) {
112 | const result: VoiceData = new VoiceData();
113 | fs.readFile(path, (err, data) => {
114 | const encodetype = jschardet.detect(data);
115 | let decodedData: string[];
116 | switch (encodetype.encoding) {
117 | case 'UTF-8':
118 | decodedData = data.toString('utf-8').split("\n");
119 | break;
120 | default:
121 | decodedData = jschardet.decode(data, 'gbk').split("\n");
122 | break;
123 | }
124 | decodedData.forEach((line) => {
125 | const dataline = line.split(":");
126 | if (dataline.length == 5) {
127 | result.channels.push({
128 | type: dataline[0],
129 | name: dataline[1],
130 | frequency: dataline[2],
131 | server: dataline[3],
132 | callsign: dataline[4]
133 | });
134 | }
135 | });
136 | callback(err, result);
137 | });
138 | }
139 | else {
140 | throw `path: ${path} does not exist.`;
141 | }
142 | }
143 |
144 | export function LoadVoiceSync(path: string): VoiceData {
145 | if (fs.existsSync(path)) {
146 | const result: VoiceData = new VoiceData();
147 | const data = fs.readFileSync(path);
148 | const encodetype = jschardet.detect(data);
149 | let decodedData: string[];
150 | switch (encodetype.encoding) {
151 | case 'UTF-8':
152 | decodedData = data.toString('utf-8').split("\n");
153 | break;
154 | default:
155 | decodedData = jschardet.decode(data, 'gbk').split("\n");
156 | break;
157 | }
158 | decodedData.forEach((line) => {
159 | const dataline = line.split(":");
160 | if (dataline.length == 5) {
161 | result.channels.push({
162 | type: dataline[0],
163 | name: dataline[1],
164 | frequency: dataline[2],
165 | server: dataline[3],
166 | callsign: dataline[4]
167 | });
168 | }
169 | });
170 | return result;
171 | }
172 | else {
173 | throw `path: ${path} does not exist.`;
174 | }
175 | }
176 |
177 | export function LoadProfile(path: string, callback: (err: NodeJS.ErrnoException | null, data: ProfileData) => void): void {
178 | if (fs.existsSync(path)) {
179 | const result: ProfileData = new ProfileData();
180 | fs.readFile(path, (err, data) => {
181 | const encodetype = jschardet.detect(data);
182 | let decodedData: string[];
183 | switch (encodetype.encoding) {
184 | case 'UTF-8':
185 | decodedData = data.toString('utf-8').split("\n");
186 | break;
187 | default:
188 | decodedData = jschardet.decode(data, 'gbk').split("\n");
189 | break;
190 | }
191 | decodedData.forEach((line) => {
192 | //跳过空行
193 | if (line == "") return;
194 | //除去注释
195 | if (line.lastIndexOf(";") !== -1) line = line.split(";")[0];
196 | const dataline = line.split(":");
197 | if (dataline.length == 4) {
198 | if (dataline[0] == "PROFILE") {
199 | result.profile.push({
200 | info: {
201 | ident: dataline[1],
202 | range: parseInt(dataline[2]),
203 | facility: parseInt(dataline[3])
204 | },
205 | atis2: "",
206 | atis3: "",
207 | atis4: ""
208 | });
209 | }
210 | }
211 | if (dataline.length == 2) {
212 | if (dataline[0] == "ATIS2") {
213 | result.profile[result.profile.length - 1].atis2 = dataline[1];
214 | }
215 | else if (dataline[0] == "ATIS3") {
216 | result.profile[result.profile.length - 1].atis3 = dataline[1];
217 | }
218 | else if (dataline[0] == "ATIS4") {
219 | result.profile[result.profile.length - 1].atis4 = dataline[1];
220 | }
221 | }
222 | });
223 | callback(err, result);
224 | });
225 | }
226 | else {
227 | throw `path: ${path} does not exist.`;
228 | }
229 | }
230 |
231 | export function LoadProfileSync(path: string): ProfileData {
232 | if (fs.existsSync(path)) {
233 | const result: ProfileData = new ProfileData();
234 | const data = fs.readFileSync(path);
235 | const encodetype = jschardet.detect(data);
236 | let decodedData: string[];
237 | switch (encodetype.encoding) {
238 | case 'UTF-8':
239 | decodedData = data.toString('utf-8').split("\n");
240 | break;
241 | default:
242 | decodedData = jschardet.decode(data, 'gbk').split("\n");
243 | break;
244 | }
245 | decodedData.forEach((line) => {
246 | //跳过空行
247 | if (line == "") return;
248 | //除去注释
249 | if (line.lastIndexOf(";") !== -1) line = line.split(";")[0];
250 | const dataline = line.split(":");
251 | if (dataline.length == 4) {
252 | if (dataline[0] == "PROFILE") {
253 | result.profile.push({
254 | info: {
255 | ident: dataline[1],
256 | range: parseInt(dataline[2]),
257 | facility: parseInt(dataline[3])
258 | },
259 | atis2: "",
260 | atis3: "",
261 | atis4: ""
262 | });
263 | }
264 | }
265 | if (dataline.length == 2) {
266 | if (dataline[0] == "ATIS2") {
267 | result.profile[result.profile.length - 1].atis2 = dataline[1];
268 | }
269 | else if (dataline[0] == "ATIS3") {
270 | result.profile[result.profile.length - 1].atis3 = dataline[1];
271 | }
272 | else if (dataline[0] == "ATIS4") {
273 | result.profile[result.profile.length - 1].atis4 = dataline[1];
274 | }
275 | }
276 | });
277 | return result;
278 | }
279 | else {
280 | throw `path: ${path} does not exist.`;
281 | }
282 | }
283 |
284 | export default {
285 | LoadSymbology, LoadSymbologySync,
286 | LoadVoice, LoadVoiceSync,
287 | LoadProfile, LoadProfileSync
288 | }
--------------------------------------------------------------------------------
/src/utils/wxfetcher.worker.ts:
--------------------------------------------------------------------------------
1 | // import https from 'https'
2 | // https.get("https://metar.vatsim.net/ZBAA", (res) => {
3 | // res.on('data', (chunk: Buffer) => {
4 | // postMessage(chunk.toString())
5 | // })
6 | // });
7 | const httpRequest = new XMLHttpRequest();
8 | onmessage = function(e){
9 | httpRequest.open('GET','https://metar.vatsim.net/'+e.data,true)
10 | httpRequest.setRequestHeader("Referer","https://metar.vatsim.net")
11 | httpRequest.send()
12 | httpRequest.onreadystatechange = function(){
13 | if(httpRequest.readyState == 4 && httpRequest.status == 200){
14 | console.log(httpRequest.responseText)
15 | }
16 | }
17 | }
--------------------------------------------------------------------------------
/tsconfig.json:
--------------------------------------------------------------------------------
1 | {
2 | "compilerOptions": {
3 | "target": "ES6",
4 | "module": "CommonJS",
5 | "strict": true,
6 | "jsx": "preserve",
7 | "importHelpers": true,
8 | "moduleResolution": "node",
9 | "outDir": "dist_electron",
10 | "skipLibCheck": true,
11 | "esModuleInterop": true,
12 | "allowSyntheticDefaultImports": true,
13 | "forceConsistentCasingInFileNames": true,
14 | "useDefineForClassFields": true,
15 | "sourceMap": true,
16 | "baseUrl": ".",
17 | "types": [
18 | "webpack-env"
19 | ],
20 | "paths": {
21 | "@/*": [
22 | "src/*"
23 | ]
24 | },
25 | "lib": [
26 | "esnext",
27 | "dom",
28 | "dom.iterable",
29 | "scripthost"
30 | ]
31 | },
32 | "include": [
33 | "src/**/*.ts",
34 | "src/**/*.tsx",
35 | "src/**/*.vue",
36 | "tests/**/*.ts",
37 | "tests/**/*.tsx",
38 | "src/utils/wxfetcher.worker.tsrkersrc/utils/wxfetcher.worker.tscher.worker.ts"
39 | ],
40 | "exclude": [
41 | "node_modules"
42 | ]
43 | }
--------------------------------------------------------------------------------
4 | Weather Information
5 |
6 |
7 |
9 |
10 |
11 |
12 |
15 |
16 |
17 | METAR: {{ wX.metar }}
13 |last update at: {{ wX.updateTime }}
14 |