Develop and Download Open Source Software

Tera Term

Browse Subversion Repository

/[ttssh2]/trunk/teraterm/teraterm/addsetting.cpp

Contents of /trunk/teraterm/teraterm/addsetting.cpp

Parent Directory Parent Directory | Revision Log Revision Log

Revision 10744 - (show annotations) (download) (as text)
Wed Jun 7 15:28:47 2023 UTC (9 months ago) by zmatsuo
File MIME type: text/x-c++src
File size: 72648 byte(s) 
strftime()で使用する書式チェックを修正前に戻した

- r10739でVS2022のstrftime()で使えるものすべてに変更した
  - コンパイラプラットフォームで使える書式は変化する
  - Tera Term ではマニュアルにある書式(VS2005ベース)のみ使用できる仕様
- ログタブを最初に表示したときのフォーカスを正しく表示するようにした
- マニュアルを修正

Ticket #46476
1 /*
2 * Copyright (C) 2008- TeraTerm Project
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 *
9 * 1. Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 * 3. The name of the author may not be used to endorse or promote products
15 * derived from this software without specific prior written permission.
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR
18 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20 * IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY DIRECT, INDIRECT,
21 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 */
28
29 /*
30 * Additional settings dialog
31 */
32
33 #include <stdio.h>
34 #include <windows.h>
35 #include <commctrl.h>
36 //#include <dwmapi.h> // compat_win.h �������`���g�p�������� include ������
37 #define _CRTDBG_MAP_ALLOC
38 #include <stdlib.h>
39 #include <crtdbg.h>
40 #include <assert.h>
41
42 #include "teraterm.h"
43 #include "tttypes.h"
44 #include "ttwinman.h" // for ts
45 #include "dlglib.h"
46 #include "compat_win.h"
47 #include "helpid.h"
48 #include "addsetting.h"
49 #include "debug_pp.h"
50 #include "tipwin.h"
51 #include "i18n.h"
52 #include "codeconv.h"
53 #include "coding_pp.h"
54 #include "font_pp.h"
55 #include "asprintf.h"
56 #include "win32helper.h"
57 #include "themedlg.h"
58 #include "theme.h"
59 #include "ttcmn_notify2.h"
60 #include "filesys_log.h" // for FLogGetLogFilenameBase()
61
62 const mouse_cursor_t MouseCursor[] = {
63 {"ARROW", IDC_ARROW},
64 {"IBEAM", IDC_IBEAM},
65 {"CROSS", IDC_CROSS},
66 {"HAND", IDC_HAND},
67 {NULL, NULL},
68 };
69 #define MOUSE_CURSOR_MAX (sizeof(MouseCursor)/sizeof(MouseCursor[0]) - 1)
70
71 // CGeneralPropPageDlg �_�C�A���O
72
73 // General Page
74 class CGeneralPropPageDlg : public TTCPropertyPage
75 {
76 public:
77 CGeneralPropPageDlg(HINSTANCE inst);
78 virtual ~CGeneralPropPageDlg();
79 private:
80 void OnInitDialog();
81 void OnOK();
82 enum { IDD = IDD_TABSHEET_GENERAL };
83 void OnHelp();
84 BOOL OnCommand(WPARAM wParam, LPARAM lParam);
85 };
86
87 CGeneralPropPageDlg::CGeneralPropPageDlg(HINSTANCE inst)
88 : TTCPropertyPage(inst, CGeneralPropPageDlg::IDD)
89 {
90 wchar_t *UIMsg;
91 GetI18nStrWW("Tera Term", "DLG_TABSHEET_TITLE_GENERAL",
92 L"General", ts.UILanguageFileW, &UIMsg);
93 m_psp.pszTitle = UIMsg;
94 m_psp.dwFlags |= (PSP_USETITLE | PSP_HASHELP);
95 }
96
97 CGeneralPropPageDlg::~CGeneralPropPageDlg()
98 {
99 free((void *)m_psp.pszTitle);
100 }
101
102 // CGeneralPropPageDlg ���b�Z�[�W �n���h��
103
104 void CGeneralPropPageDlg::OnInitDialog()
105 {
106 TTCPropertyPage::OnInitDialog();
107
108 static const DlgTextInfo TextInfos[] = {
109 { IDC_CLICKABLE_URL, "DLG_TAB_GENERAL_CLICKURL" },
110 { IDC_DISABLE_SENDBREAK, "DLG_TAB_GENERAL_DISABLESENDBREAK" },
111 { IDC_ACCEPT_BROADCAST, "DLG_TAB_GENERAL_ACCEPTBROADCAST" },
112 { IDC_MOUSEWHEEL_SCROLL_LINE, "DLG_TAB_GENERAL_MOUSEWHEEL_SCROLL_LINE" },
113 { IDC_AUTOSCROLL_ONLY_IN_BOTTOM_LINE, "DLG_TAB_GENERAL_AUTOSCROLL_ONLY_IN_BOTTOM_LINE" },
114 { IDC_CLEAR_ON_RESIZE, "DLG_TAB_GENERAL_CLEAR_ON_RESIZE" },
115 { IDC_CURSOR_CHANGE_IME, "DLG_TAB_GENERAL_CURSOR_CHANGE_IME" },
116 { IDC_LIST_HIDDEN_FONTS, "DLG_TAB_GENERAL_LIST_HIDDEN_FONTS" },
117 { IDC_TITLEFMT_GROUP, "DLG_TAB_GENERAL_TITLEFMT_GROUP" },
118 { IDC_TITLEFMT_DISPHOSTNAME, "DLG_TAB_GENERAL_TITLEFMT_DISPHOSTNAME" },
119 { IDC_TITLEFMT_DISPSESSION, "DLG_TAB_GENERAL_TITLEFMT_DISPSESSION" },
120 { IDC_TITLEFMT_DISPVTTEK, "DLG_TAB_GENERAL_TITLEFMT_DISPVTTEK" },
121 { IDC_TITLEFMT_SWAPHOSTTITLE, "DLG_TAB_GENERAL_TITLEFMT_SWAPHOSTTITLE" },
122 { IDC_TITLEFMT_DISPTCPPORT, "DLG_TAB_GENERAL_TITLEFMT_DISPTCPPORT" },
123 { IDC_TITLEFMT_DISPSERIALSPEED, "DLG_TAB_GENERAL_TITLEFMT_DISPSERIALSPEED" },
124 { IDC_NOTIFICATION_TITLE, "DLG_TAB_GENERAL_NOTIFICATION_TITLE" },
125 { IDC_NOTIFY_SOUND, "DLG_TAB_GENERAL_NOTIFIY_SOUND" },
126 { IDC_NOTIFICATION_TEST_POPUP, "DLG_TAB_GENERAL_NOTIFICATION_TEST_POPUP" },
127 { IDC_NOTIFICATION_TEST_TRAY, "DLG_TAB_GENERAL_NOTIFICATION_TEST_TRAY" },
128 };
129 SetDlgTextsW(m_hWnd, TextInfos, _countof(TextInfos), ts.UILanguageFileW);
130
131 // (1)DisableAcceleratorSendBreak
132 SetCheck(IDC_DISABLE_SENDBREAK, ts.DisableAcceleratorSendBreak);
133
134 // (2)EnableClickableUrl
135 SetCheck(IDC_CLICKABLE_URL, ts.EnableClickableUrl);
136
137 // (3)AcceptBroadcast 337: 2007/03/20
138 SetCheck(IDC_ACCEPT_BROADCAST, ts.AcceptBroadcast);
139
140 // (4)IDC_MOUSEWHEEL_SCROLL_LINE
141 SetDlgItemNum(IDC_SCROLL_LINE, ts.MouseWheelScrollLine);
142
143 // (5)IDC_AUTOSCROLL_ONLY_IN_BOTTOM_LINE
144 SetCheck(IDC_AUTOSCROLL_ONLY_IN_BOTTOM_LINE, ts.AutoScrollOnlyInBottomLine);
145
146 // (6)IDC_CLEAR_ON_RESIZE
147 SetCheck(IDC_CLEAR_ON_RESIZE, (ts.TermFlag & TF_CLEARONRESIZE) != 0);
148
149 // (7)IDC_CURSOR_CHANGE_IME
150 SetCheck(IDC_CURSOR_CHANGE_IME, (ts.WindowFlag & WF_IMECURSORCHANGE) != 0);
151
152 // (8)IDC_LIST_HIDDEN_FONTS
153 SetCheck(IDC_LIST_HIDDEN_FONTS, ts.ListHiddenFonts);
154
155 // (9) Title Format
156 SetCheck(IDC_TITLEFMT_DISPHOSTNAME, (ts.TitleFormat & 1) != 0);
157 SetCheck(IDC_TITLEFMT_DISPSESSION, (ts.TitleFormat & (1<<1)) != 0);
158 SetCheck(IDC_TITLEFMT_DISPVTTEK, (ts.TitleFormat & (1<<2)) != 0);
159 SetCheck(IDC_TITLEFMT_SWAPHOSTTITLE, (ts.TitleFormat & (1<<3)) != 0);
160 SetCheck(IDC_TITLEFMT_DISPTCPPORT, (ts.TitleFormat & (1<<4)) != 0);
161 SetCheck(IDC_TITLEFMT_DISPSERIALSPEED, (ts.TitleFormat & (1<<5)) != 0);
162
163 // Notify
164 SetCheck(IDC_NOTIFY_SOUND, ts.NotifySound);
165
166 // �_�C�A���O���t�H�[�J�X�������� (2004.12.7 yutaka)
167 ::SetFocus(::GetDlgItem(GetSafeHwnd(), IDC_CLICKABLE_URL));
168 }
169
170 void CGeneralPropPageDlg::OnOK()
171 {
172 int val;
173
174 // (1)
175 ts.DisableAcceleratorSendBreak = GetCheck(IDC_DISABLE_SENDBREAK);
176
177 // (2)
178 ts.EnableClickableUrl = GetCheck(IDC_CLICKABLE_URL);
179
180 // (3) 337: 2007/03/20
181 ts.AcceptBroadcast = GetCheck(IDC_ACCEPT_BROADCAST);
182
183 // (4)IDC_MOUSEWHEEL_SCROLL_LINE
184 val = GetDlgItemInt(IDC_SCROLL_LINE);
185 if (val > 0)
186 ts.MouseWheelScrollLine = val;
187
188 // (5)IDC_AUTOSCROLL_ONLY_IN_BOTTOM_LINE
189 ts.AutoScrollOnlyInBottomLine = GetCheck(IDC_AUTOSCROLL_ONLY_IN_BOTTOM_LINE);
190
191 // (6)IDC_CLEAR_ON_RESIZE
192 if (((ts.TermFlag & TF_CLEARONRESIZE) != 0) != GetCheck(IDC_CLEAR_ON_RESIZE)) {
193 ts.TermFlag ^= TF_CLEARONRESIZE;
194 }
195
196 // (7)IDC_CURSOR_CHANGE_IME
197 if (((ts.WindowFlag & WF_IMECURSORCHANGE) != 0) != GetCheck(IDC_CURSOR_CHANGE_IME)) {
198 ts.WindowFlag ^= WF_IMECURSORCHANGE;
199 }
200
201 // (8)IDC_LIST_HIDDEN_FONTS
202 ts.ListHiddenFonts = GetCheck(IDC_LIST_HIDDEN_FONTS);
203
204 // (9) Title Format
205 ts.TitleFormat = GetCheck(IDC_TITLEFMT_DISPHOSTNAME) == BST_CHECKED;
206 ts.TitleFormat |= (GetCheck(IDC_TITLEFMT_DISPSESSION) == BST_CHECKED) << 1;
207 ts.TitleFormat |= (GetCheck(IDC_TITLEFMT_DISPVTTEK) == BST_CHECKED) << 2;
208 ts.TitleFormat |= (GetCheck(IDC_TITLEFMT_SWAPHOSTTITLE) == BST_CHECKED) << 3;
209 ts.TitleFormat |= (GetCheck(IDC_TITLEFMT_DISPTCPPORT) == BST_CHECKED) << 4;
210 ts.TitleFormat |= (GetCheck(IDC_TITLEFMT_DISPSERIALSPEED) == BST_CHECKED) << 5;
211
212 // Notify
213 {
214 BOOL notify_sound = (BOOL)GetCheck(IDC_NOTIFY_SOUND);
215 if (notify_sound != ts.NotifySound) {
216 ts.NotifySound = notify_sound;
217 Notify2SetSound((NotifyIcon *)cv.NotifyIcon, notify_sound);
218 }
219 }
220 }
221
222 void CGeneralPropPageDlg::OnHelp()
223 {
224 PostMessage(HVTWin, WM_USER_DLGHELP2, HlpMenuSetupAdditional, 0);
225 }
226
227 BOOL CGeneralPropPageDlg::OnCommand(WPARAM wParam, LPARAM lParam)
228 {
229 switch (wParam) {
230 case IDC_NOTIFICATION_TEST_POPUP | (BN_CLICKED << 16): {
231 // popup���o���e�X�g
232 NotifyIcon *ni = (NotifyIcon *)cv.NotifyIcon;
233 const wchar_t *msg = L"Test button was pushed";
234 BOOL prev_sound = Notify2GetSound(ni);
235 BOOL notify_sound = (BOOL)GetCheck(IDC_NOTIFY_SOUND);
236 Notify2SetSound(ni, notify_sound);
237 Notify2SetMessageW(ni, msg, NULL, 1);
238 Notify2SetSound(ni, prev_sound);
239 break;
240 }
241 case IDC_NOTIFICATION_TEST_TRAY | (BN_CLICKED << 16): {
242 // tray��icon���o��(��������������)
243 NotifyIcon *ni = (NotifyIcon *)cv.NotifyIcon;
244 BOOL prev_sound = Notify2GetSound(ni);
245 BOOL notify_sound = (BOOL)GetCheck(IDC_NOTIFY_SOUND);
246 Notify2SetSound(ni, notify_sound);
247 Notify2SetBallonDontHide(ni, TRUE);
248 Notify2SetMessageW(ni, NULL, NULL, 1);
249 Notify2SetSound(ni, prev_sound);
250
251 static const TTMessageBoxInfoW info = {
252 "Tera Term",
253 "MSG_TT_NOTICE", L"Tera Term: Notice",
254 NULL, L"You can change notify setting",
255 MB_OK };
256 TTMessageBoxW(m_hWnd, &info, ts.UILanguageFileW);
257
258 // ���m�������A�C�R��������
259 Notify2SetBallonDontHide(ni, FALSE);
260 Notify2Hide(ni);
261 break;
262 }
263 default:
264 break;
265 }
266 return TTCPropertyPage::OnCommand(wParam, lParam);
267 }
268
269 // CSequencePropPageDlg �_�C�A���O
270
271 CSequencePropPageDlg::CSequencePropPageDlg(HINSTANCE inst)
272 : TTCPropertyPage(inst, CSequencePropPageDlg::IDD)
273 {
274 wchar_t *UIMsg;
275 GetI18nStrWW("Tera Term", "DLG_TABSHEET_TITLE_SEQUENCE",
276 L"Control Sequence", ts.UILanguageFileW, &UIMsg);
277 m_psp.pszTitle = UIMsg;
278 m_psp.dwFlags |= (PSP_USETITLE | PSP_HASHELP);
279 }
280
281 CSequencePropPageDlg::~CSequencePropPageDlg()
282 {
283 free((void *)m_psp.pszTitle);
284 }
285
286 // CSequencePropPageDlg ���b�Z�[�W �n���h��
287
288 void CSequencePropPageDlg::OnInitDialog()
289 {
290 TTCPropertyPage::OnInitDialog();
291
292 static const DlgTextInfo TextInfos[] = {
293 { IDC_ACCEPT_MOUSE_EVENT_TRACKING, "DLG_TAB_SEQUENCE_ACCEPT_MOUSE_EVENT_TRACKING" },
294 { IDC_DISABLE_MOUSE_TRACKING_CTRL, "DLG_TAB_SEQUENCE_DISABLE_MOUSE_TRACKING_CTRL" },
295 { IDC_ACCEPT_TITLE_CHANGING_LABEL, "DLG_TAB_SEQUENCE_ACCEPT_TITLE_CHANGING" },
296 { IDC_CURSOR_CTRL_SEQ, "DLG_TAB_SEQUENCE_CURSOR_CTRL" },
297 { IDC_WINDOW_CTRL, "DLG_TAB_SEQUENCE_WINDOW_CTRL" },
298 { IDC_WINDOW_REPORT, "DLG_TAB_SEQUENCE_WINDOW_REPORT" },
299 { IDC_TITLE_REPORT_LABEL, "DLG_TAB_SEQUENCE_TITLE_REPORT" },
300 { IDC_CLIPBOARD_ACCESS_LABEL, "DLG_TAB_SEQUENCE_CLIPBOARD_ACCESS" },
301 { IDC_CLIPBOARD_NOTIFY, "DLG_TAB_SEQUENCE_CLIPBOARD_NOTIFY" },
302 { IDC_ACCEPT_CLEAR_SBUFF, "DLG_TAB_SEQUENCE_ACCEPT_CLEAR_SBUFF" },
303 { IDC_DISABLE_PRINT_START, "DLG_TAB_SEQUENCE_PRINT_START" },
304 { IDC_BEEP_LABEL, "DLG_TAB_SEQUENCE_BEEP_LABEL" },
305 };
306 SetDlgTextsW(m_hWnd, TextInfos, _countof(TextInfos), ts.UILanguageFileW);
307
308 const static I18nTextInfo accept_title_changing[] = {
309 { "DLG_TAB_SEQUENCE_ACCEPT_TITLE_CHANGING_OFF", L"off" },
310 { "DLG_TAB_SEQUENCE_ACCEPT_TITLE_CHANGING_OVERWRITE", L"overwrite" },
311 { "DLG_TAB_SEQUENCE_ACCEPT_TITLE_CHANGING_AHEAD", L"ahead" },
312 { "DLG_TAB_SEQUENCE_ACCEPT_TITLE_CHANGING_LAST", L"last" },
313 };
314 SetI18nListW("Tera Term", m_hWnd, IDC_ACCEPT_TITLE_CHANGING, accept_title_changing, _countof(accept_title_changing),
315 ts.UILanguageFileW, 0);
316
317 const static I18nTextInfo sequence_title_report[] = {
318 { "DLG_TAB_SEQUENCE_TITLE_REPORT_IGNORE", L"ignore" },
319 { "DLG_TAB_SEQUENCE_TITLE_REPORT_ACCEPT", L"accept" },
320 { "DLG_TAB_SEQUENCE_TITLE_REPORT_EMPTY", L"empty" },
321 };
322 SetI18nListW("Tera Term", m_hWnd, IDC_TITLE_REPORT, sequence_title_report, _countof(sequence_title_report),
323 ts.UILanguageFileW, 0);
324
325 const static I18nTextInfo sequence_clipboard_access[] = {
326 { "DLG_TAB_SEQUENCE_CLIPBOARD_ACCESS_OFF", L"off" },
327 { "DLG_TAB_SEQUENCE_CLIPBOARD_ACCESS_WRITE", L"write only" },
328 { "DLG_TAB_SEQUENCE_CLIPBOARD_ACCESS_READ", L"read only" },
329 { "DLG_TAB_SEQUENCE_CLIPBOARD_ACCESS_ON", L"read/write" },
330 };
331 SetI18nListW("Tera Term", m_hWnd, IDC_CLIPBOARD_ACCESS, sequence_clipboard_access,
332 _countof(sequence_clipboard_access), ts.UILanguageFileW, 0);
333
334 // (1)IDC_ACCEPT_MOUSE_EVENT_TRACKING
335 SetCheck(IDC_ACCEPT_MOUSE_EVENT_TRACKING, ts.MouseEventTracking);
336 EnableDlgItem(IDC_DISABLE_MOUSE_TRACKING_CTRL, ts.MouseEventTracking ? TRUE : FALSE);
337
338 // (2)IDC_DISABLE_MOUSE_TRACKING_CTRL
339 SetCheck(IDC_DISABLE_MOUSE_TRACKING_CTRL, ts.DisableMouseTrackingByCtrl);
340
341 // (3)IDC_ACCEPT_TITLE_CHANGING
342 SetCurSel(IDC_ACCEPT_TITLE_CHANGING, ts.AcceptTitleChangeRequest);
343
344 // (4)IDC_TITLE_REPORT
345 SetCurSel(IDC_TITLE_REPORT,
346 (ts.WindowFlag & WF_TITLEREPORT) == IdTitleReportIgnore ? 0 :
347 (ts.WindowFlag & WF_TITLEREPORT) == IdTitleReportAccept ? 1
348 /*(ts.WindowFlag & WF_TITLEREPORT) == IdTitleReportEmptye ? */ : 2);
349
350 // (5)IDC_WINDOW_CTRL
351 SetCheck(IDC_WINDOW_CTRL, (ts.WindowFlag & WF_WINDOWCHANGE) != 0);
352
353 // (6)IDC_WINDOW_REPORT
354 SetCheck(IDC_WINDOW_REPORT, (ts.WindowFlag & WF_WINDOWREPORT) != 0);
355
356 // (7)IDC_CURSOR_CTRL_SEQ
357 SetCheck(IDC_CURSOR_CTRL_SEQ, (ts.WindowFlag & WF_CURSORCHANGE) != 0);
358
359 // (8)IDC_CLIPBOARD_ACCESS
360 SetCurSel(IDC_CLIPBOARD_ACCESS,
361 (ts.CtrlFlag & CSF_CBRW) == CSF_CBRW ? 3 :
362 (ts.CtrlFlag & CSF_CBRW) == CSF_CBREAD ? 2 :
363 (ts.CtrlFlag & CSF_CBRW) == CSF_CBWRITE ? 1 :
364 0); // off
365
366 // (9)IDC_CLIPBOARD_NOTIFY
367 SetCheck(IDC_CLIPBOARD_NOTIFY, ts.NotifyClipboardAccess);
368 EnableDlgItem(IDC_CLIPBOARD_NOTIFY, HasBalloonTipSupport() ? TRUE : FALSE);
369
370 // (10)IDC_ACCEPT_CLEAR_SBUFF
371 SetCheck(IDC_ACCEPT_CLEAR_SBUFF, (ts.TermFlag & TF_REMOTECLEARSBUFF) != 0);
372
373 SetCheck(IDC_DISABLE_PRINT_START, (ts.TermFlag & TF_PRINTERCTRL) == 0);
374
375 const static I18nTextInfo beep_type[] = {
376 { "DLG_TAB_SEQUENCE_BEEP_DISABLE", L"disable" }, // IdBeepOff = 0
377 { "DLG_TAB_SEQUENCE_BEEP_SOUND", L"sound" }, // IdBeepOn = 1
378 { "DLG_TAB_SEQUENCE_BEEP_VISUALBELL", L"visualbell" }, // IdBeepVisual = 2
379 };
380 SetI18nListW("Tera Term", m_hWnd, IDC_BEEP_DROPDOWN, beep_type,
381 _countof(beep_type), ts.UILanguageFileW, ts.Beep);
382
383 // �_�C�A���O���t�H�[�J�X�������� (2004.12.7 yutaka)
384 ::SetFocus(::GetDlgItem(GetSafeHwnd(), IDC_ACCEPT_MOUSE_EVENT_TRACKING));
385 }
386
387 BOOL CSequencePropPageDlg::OnCommand(WPARAM wParam, LPARAM lParam)
388 {
389 switch (wParam) {
390 case IDC_ACCEPT_MOUSE_EVENT_TRACKING | (BN_CLICKED << 16):
391 EnableDlgItem(IDC_DISABLE_MOUSE_TRACKING_CTRL,
392 GetCheck(IDC_ACCEPT_MOUSE_EVENT_TRACKING) ? TRUE : FALSE);
393 return TRUE;
394 }
395 return TTCPropertyPage::OnCommand(wParam, lParam);
396 }
397
398 void CSequencePropPageDlg::OnOK()
399 {
400 // (1)IDC_ACCEPT_MOUSE_EVENT_TRACKING
401 ts.MouseEventTracking = GetCheck(IDC_ACCEPT_MOUSE_EVENT_TRACKING);
402
403 // (2)IDC_DISABLE_MOUSE_TRACKING_CTRL
404 ts.DisableMouseTrackingByCtrl = GetCheck(IDC_DISABLE_MOUSE_TRACKING_CTRL);
405
406 // (3)IDC_ACCEPT_TITLE_CHANGING
407 int sel = GetCurSel(IDC_ACCEPT_TITLE_CHANGING);
408 if (0 <= sel && sel <= IdTitleChangeRequestMax) {
409 ts.AcceptTitleChangeRequest = sel;
410 }
411
412 // (4)IDC_TITLE_REPORT
413 switch (GetCurSel(IDC_TITLE_REPORT)) {
414 case 0:
415 ts.WindowFlag &= ~WF_TITLEREPORT;
416 break;
417 case 1:
418 ts.WindowFlag &= ~WF_TITLEREPORT;
419 ts.WindowFlag |= IdTitleReportAccept;
420 break;
421 case 2:
422 ts.WindowFlag |= IdTitleReportEmpty;
423 break;
424 default: // Invalid value.
425 break;
426 }
427
428 // (5)IDC_WINDOW_CTRL
429 if (((ts.WindowFlag & WF_WINDOWCHANGE) != 0) != GetCheck(IDC_WINDOW_CTRL)) {
430 ts.WindowFlag ^= WF_WINDOWCHANGE;
431 }
432
433 // (6)IDC_WINDOW_REPORT
434 if (((ts.WindowFlag & WF_WINDOWREPORT) != 0) != GetCheck(IDC_WINDOW_REPORT)) {
435 ts.WindowFlag ^= WF_WINDOWREPORT;
436 }
437
438 // (7)IDC_CURSOR_CTRL_SEQ
439 if (((ts.WindowFlag & WF_CURSORCHANGE) != 0) != GetCheck(IDC_CURSOR_CTRL_SEQ)) {
440 ts.WindowFlag ^= WF_CURSORCHANGE;
441 }
442
443 // (8)IDC_CLIPBOARD_ACCESS
444 switch (GetCurSel(IDC_CLIPBOARD_ACCESS)) {
445 case 0: // off
446 ts.CtrlFlag &= ~CSF_CBRW;
447 break;
448 case 1: // write only
449 ts.CtrlFlag &= ~CSF_CBRW;
450 ts.CtrlFlag |= CSF_CBWRITE;
451 break;
452 case 2: // read only
453 ts.CtrlFlag &= ~CSF_CBRW;
454 ts.CtrlFlag |= CSF_CBREAD;
455 break;
456 case 3: // read/write
457 ts.CtrlFlag |= CSF_CBRW;
458 break;
459 default: // Invalid value.
460 break;
461 }
462
463 // (9)IDC_CLIPBOARD_ACCESS
464 ts.NotifyClipboardAccess = GetCheck(IDC_CLIPBOARD_NOTIFY);
465
466 // (10)IDC_ACCEPT_CLEAR_SBUFF
467 if (((ts.TermFlag & TF_REMOTECLEARSBUFF) != 0) != GetCheck(IDC_ACCEPT_CLEAR_SBUFF)) {
468 ts.TermFlag ^= TF_REMOTECLEARSBUFF;
469 }
470
471 if (GetCheck(IDC_DISABLE_PRINT_START) == 0) {
472 ts.TermFlag |= TF_PRINTERCTRL;
473 } else {
474 ts.TermFlag &= ~TF_PRINTERCTRL;
475 }
476
477 ts.Beep = GetCurSel(IDC_BEEP_DROPDOWN);
478 }
479
480 void CSequencePropPageDlg::OnHelp()
481 {
482 PostMessage(HVTWin, WM_USER_DLGHELP2, HlpMenuSetupAdditional, 0);
483 }
484
485 // CCopypastePropPageDlg �_�C�A���O
486
487 CCopypastePropPageDlg::CCopypastePropPageDlg(HINSTANCE inst)
488 : TTCPropertyPage(inst, CCopypastePropPageDlg::IDD)
489 {
490 wchar_t *UIMsg;
491 GetI18nStrWW("Tera Term", "DLG_TABSHEET_TITLE_COPYPASTE",
492 L"Copy and Paste", ts.UILanguageFileW, &UIMsg);
493 m_psp.pszTitle = UIMsg;
494 m_psp.dwFlags |= (PSP_USETITLE | PSP_HASHELP);
495 }
496
497 CCopypastePropPageDlg::~CCopypastePropPageDlg()
498 {
499 free((void *)m_psp.pszTitle);
500 }
501
502 // CCopypastePropPageDlg ���b�Z�[�W �n���h��
503
504 void CCopypastePropPageDlg::OnInitDialog()
505 {
506 TTCPropertyPage::OnInitDialog();
507
508 static const DlgTextInfo TextInfos[] = {
509 { IDC_LINECOPY, "DLG_TAB_COPYPASTE_CONTINUE" },
510 { IDC_DISABLE_PASTE_RBUTTON, "DLG_TAB_COPYPASTE_MOUSEPASTE" },
511 { IDC_CONFIRM_PASTE_RBUTTON, "DLG_TAB_COPYPASTE_CONFIRMPASTE" },
512 { IDC_DISABLE_PASTE_MBUTTON, "DLG_TAB_COPYPASTE_MOUSEPASTEM" },
513 { IDC_SELECT_LBUTTON, "DLG_TAB_COPYPASTE_SELECTLBUTTON" },
514 { IDC_TRIMNLCHAR, "DLG_TAB_COPYPASTE_TRIM_TRAILING_NL" },
515 { IDC_CONFIRM_CHANGE_PASTE, "DLG_TAB_COPYPASTE_CONFIRM_CHANGE_PASTE" },
516 { IDC_CONFIRM_STRING_FILE_LABEL, "DLG_TAB_COPYPASTE_STRINGFILE" },
517 { IDC_DELIMITER, "DLG_TAB_COPYPASTE_DELIMITER" },
518 { IDC_PASTEDELAY_LABEL, "DLG_TAB_COPYPASTE_PASTEDELAY" },
519 { IDC_PASTEDELAY_LABEL2, "DLG_TAB_COPYPASTE_PASTEDELAY2" },
520 { IDC_SELECT_ON_ACTIVATE, "DLG_TAB_COPYPASTE_SELECT_ON_ACTIVATE" }
521 };
522 SetDlgTextsW(m_hWnd, TextInfos, _countof(TextInfos), ts.UILanguageFileW);
523
524 // (1)Enable continued-line copy
525 SetCheck(IDC_LINECOPY, ts.EnableContinuedLineCopy);
526
527 // (2)DisablePasteMouseRButton
528 if (ts.PasteFlag & CPF_DISABLE_RBUTTON) {
529 SetCheck(IDC_DISABLE_PASTE_RBUTTON, BST_CHECKED);
530 EnableDlgItem(IDC_CONFIRM_PASTE_RBUTTON, FALSE);
531 } else {
532 SetCheck(IDC_DISABLE_PASTE_RBUTTON, BST_UNCHECKED);
533 EnableDlgItem(IDC_CONFIRM_PASTE_RBUTTON, TRUE);
534 }
535
536 // (3)ConfirmPasteMouseRButton
537 SetCheck(IDC_CONFIRM_PASTE_RBUTTON, (ts.PasteFlag & CPF_CONFIRM_RBUTTON)?BST_CHECKED:BST_UNCHECKED);
538
539 // (4)DisablePasteMouseMButton
540 SetCheck(IDC_DISABLE_PASTE_MBUTTON, (ts.PasteFlag & CPF_DISABLE_MBUTTON)?BST_CHECKED:BST_UNCHECKED);
541
542 // (5)SelectOnlyByLButton
543 SetCheck(IDC_SELECT_LBUTTON, ts.SelectOnlyByLButton);
544
545 // (6)TrimTrailingNLonPaste
546 SetCheck(IDC_TRIMNLCHAR, (ts.PasteFlag & CPF_TRIM_TRAILING_NL)?BST_CHECKED:BST_UNCHECKED);
547
548 // (7)ConfirmChangePaste
549 SetCheck(IDC_CONFIRM_CHANGE_PASTE, (ts.PasteFlag & CPF_CONFIRM_CHANGEPASTE)?BST_CHECKED:BST_UNCHECKED);
550
551 // �t�@�C���p�X
552 SetDlgItemTextA(IDC_CONFIRM_STRING_FILE, ts.ConfirmChangePasteStringFile);
553 if (ts.PasteFlag & CPF_CONFIRM_CHANGEPASTE) {
554 EnableDlgItem(IDC_CONFIRM_STRING_FILE, TRUE);
555 EnableDlgItem(IDC_CONFIRM_STRING_FILE_PATH, TRUE);
556 } else {
557 EnableDlgItem(IDC_CONFIRM_STRING_FILE, FALSE);
558 EnableDlgItem(IDC_CONFIRM_STRING_FILE_PATH, FALSE);
559 }
560
561 // (8)delimiter characters
562 SetDlgItemTextA(IDC_DELIM_LIST, ts.DelimList);
563
564 // (9)PasteDelayPerLine
565 SetDlgItemNum(IDC_PASTEDELAY_EDIT, ts.PasteDelayPerLine);
566
567 // (10) SelectOnActivate
568 SetCheck(IDC_SELECT_ON_ACTIVATE, ts.SelOnActive ? BST_CHECKED : BST_UNCHECKED);
569
570 // �_�C�A���O���t�H�[�J�X��������
571 ::SetFocus(::GetDlgItem(GetSafeHwnd(), IDC_LINECOPY));
572 }
573
574 BOOL CCopypastePropPageDlg::OnCommand(WPARAM wParam, LPARAM lParam)
575 {
576 switch (wParam) {
577 case IDC_DISABLE_PASTE_RBUTTON | (BN_CLICKED << 16):
578 EnableDlgItem(IDC_CONFIRM_PASTE_RBUTTON,
579 GetCheck(IDC_DISABLE_PASTE_RBUTTON) ? FALSE : TRUE);
580 return TRUE;
581
582 case IDC_CONFIRM_CHANGE_PASTE | (BN_CLICKED << 16):
583 if (GetCheck(IDC_CONFIRM_CHANGE_PASTE)) {
584 EnableDlgItem(IDC_CONFIRM_STRING_FILE, TRUE);
585 EnableDlgItem(IDC_CONFIRM_STRING_FILE_PATH, TRUE);
586 } else {
587 EnableDlgItem(IDC_CONFIRM_STRING_FILE, FALSE);
588 EnableDlgItem(IDC_CONFIRM_STRING_FILE_PATH, FALSE);
589 }
590 return TRUE;
591
592 case IDC_CONFIRM_STRING_FILE_PATH | (BN_CLICKED << 16):
593 {
594 wchar_t *def;
595 hGetDlgItemTextW(m_hWnd, IDC_CONFIRM_STRING_FILE, &def);
596
597 TTOPENFILENAMEW ofn = {};
598 ofn.hwndOwner = m_hWnd;GetSafeHwnd();
599 ofn.lpstrFilter = TTGetLangStrW("Tera Term", "FILEDLG_SELECT_CONFIRM_STRING_APP_FILTER", L"txt(*.txt)\\0*.txt\\0all(*.*)\\0*.*\\0\\0", ts.UILanguageFileW);
600 ofn.lpstrFile = def;
601 ofn.lpstrTitle = TTGetLangStrW("Tera Term", "FILEDLG_SELECT_CONFIRM_STRING_APP_TITLE", L"Choose a file including strings for ConfirmChangePaste", ts.UILanguageFileW);
602 ofn.lpstrInitialDir = ts.HomeDirW;
603 ofn.Flags = OFN_FILEMUSTEXIST | OFN_HIDEREADONLY;
604 wchar_t *filename;
605 BOOL ok = TTGetOpenFileNameW(&ofn, &filename);
606 if (ok) {
607 SetDlgItemTextW(IDC_CONFIRM_STRING_FILE, filename);
608 free(filename);
609 }
610 free(def);
611 free((void *)ofn.lpstrFilter);
612 free((void *)ofn.lpstrTitle);
613 }
614 return TRUE;
615 }
616
617 return TTCPropertyPage::OnCommand(wParam, lParam);
618 }
619
620 void CCopypastePropPageDlg::OnOK()
621 {
622 int val;
623
624 // (1)
625 ts.EnableContinuedLineCopy = GetCheck(IDC_LINECOPY);
626
627 // (2)
628 if (GetCheck(IDC_DISABLE_PASTE_RBUTTON)) {
629 ts.PasteFlag |= CPF_DISABLE_RBUTTON;
630 }
631 else {
632 ts.PasteFlag &= ~CPF_DISABLE_RBUTTON;
633 }
634
635 // (3)
636 if (GetCheck(IDC_CONFIRM_PASTE_RBUTTON)) {
637 ts.PasteFlag |= CPF_CONFIRM_RBUTTON;
638 }
639 else {
640 ts.PasteFlag &= ~CPF_CONFIRM_RBUTTON;
641 }
642
643 // (4)
644 if (GetCheck(IDC_DISABLE_PASTE_MBUTTON)) {
645 ts.PasteFlag |= CPF_DISABLE_MBUTTON;
646 }
647 else {
648 ts.PasteFlag &= ~CPF_DISABLE_MBUTTON;
649 }
650
651 // (5)
652 ts.SelectOnlyByLButton = GetCheck(IDC_SELECT_LBUTTON);
653
654 // (6)
655 if (GetCheck(IDC_TRIMNLCHAR)) {
656 ts.PasteFlag |= CPF_TRIM_TRAILING_NL;
657 }
658 else {
659 ts.PasteFlag &= ~CPF_TRIM_TRAILING_NL;
660 }
661
662 // (7)IDC_CONFIRM_CHANGE_PASTE
663 if (GetCheck(IDC_CONFIRM_CHANGE_PASTE)) {
664 ts.PasteFlag |= CPF_CONFIRM_CHANGEPASTE;
665 }
666 else {
667 ts.PasteFlag &= ~CPF_CONFIRM_CHANGEPASTE;
668 }
669 GetDlgItemTextA(IDC_CONFIRM_STRING_FILE, ts.ConfirmChangePasteStringFile, sizeof(ts.ConfirmChangePasteStringFile));
670
671 // (8)
672 GetDlgItemTextA(IDC_DELIM_LIST, ts.DelimList, sizeof(ts.DelimList));
673
674 // (9)
675 val = GetDlgItemInt(IDC_PASTEDELAY_EDIT);
676 ts.PasteDelayPerLine =
677 (val < 0) ? 0 :
678 (val > 5000) ? 5000 : val;
679
680 // (10) SelectOnActivate
681 ts.SelOnActive = (GetCheck(IDC_SELECT_ON_ACTIVATE) == BST_CHECKED);
682 }
683
684 void CCopypastePropPageDlg::OnHelp()
685 {
686 PostMessage(HVTWin, WM_USER_DLGHELP2, HlpMenuSetupAdditional, 0);
687 }
688
689 // CVisualPropPageDlg �_�C�A���O
690 class CVisualPropPageDlg : public TTCPropertyPage
691 {
692 public:
693 CVisualPropPageDlg(HINSTANCE inst);
694 virtual ~CVisualPropPageDlg();
695 private:
696 void OnInitDialog();
697 void OnOK();
698 HBRUSH OnCtlColor(HDC hDC, HWND hWnd);
699 enum { IDD = IDD_TABSHEET_VISUAL };
700 BOOL OnCommand(WPARAM wParam, LPARAM lParam);
701 void OnHScroll(UINT nSBCode, UINT nPos, HWND pScrollBar);
702 void SetupRGBbox(int index);
703 void OnHelp();
704 BOOL CheckColorChanged();
705 BOOL CheckThemeColor();
706 CTipWin* TipWin;
707 COLORREF ANSIColor[16];
708 };
709
710 CVisualPropPageDlg::CVisualPropPageDlg(HINSTANCE inst)
711 : TTCPropertyPage(inst, CVisualPropPageDlg::IDD)
712 {
713 wchar_t *UIMsg;
714 GetI18nStrWW("Tera Term", "DLG_TABSHEET_TITLE_VISUAL",
715 L"Visual", ts.UILanguageFileW, &UIMsg);
716 m_psp.pszTitle = UIMsg;
717 m_psp.dwFlags |= (PSP_USETITLE | PSP_HASHELP);
718 TipWin = new CTipWin(inst);
719 }
720
721 CVisualPropPageDlg::~CVisualPropPageDlg()
722 {
723 free((void *)m_psp.pszTitle);
724 TipWin->Destroy();
725 delete TipWin;
726 TipWin = NULL;
727 }
728
729 void CVisualPropPageDlg::SetupRGBbox(int index)
730 {
731 COLORREF Color = ANSIColor[index];
732 BYTE c;
733
734 c = GetRValue(Color);
735 SetDlgItemNum(IDC_COLOR_RED, c);
736
737 c = GetGValue(Color);
738 SetDlgItemNum(IDC_COLOR_GREEN, c);
739
740 c = GetBValue(Color);
741 SetDlgItemNum(IDC_COLOR_BLUE, c);
742 }
743
744 // CVisualPropPageDlg ���b�Z�[�W �n���h��
745
746 void CVisualPropPageDlg::OnInitDialog()
747 {
748 TTCPropertyPage::OnInitDialog();
749
750 static const DlgTextInfo TextInfos[] = {
751 { IDC_ALPHABLEND, "DLG_TAB_VISUAL_ALPHA" },
752 { IDC_ALPHA_BLEND_ACTIVE_LABEL, "DLG_TAB_VISUAL_ALPHA_ACTIVE" },
753 { IDC_ALPHA_BLEND_INACTIVE_LABEL, "DLG_TAB_VISUAL_ALPHA_INACTIVE" },
754 { IDC_MOUSE, "DLG_TAB_VISUAL_MOUSE" },
755 { IDC_FONT_QUALITY_LABEL, "DLG_TAB_VISUAL_FONT_QUALITY" },
756 { IDC_ANSICOLOR, "DLG_TAB_VISUAL_ANSICOLOR" },
757 { IDC_RED, "DLG_TAB_VISUAL_RED" },
758 { IDC_GREEN, "DLG_TAB_VISUAL_GREEN" },
759 { IDC_BLUE, "DLG_TAB_VISUAL_BLUE" },
760 { IDC_CHECK_CORNERDONTROUND, "DLG_TAB_VISUAL_CORNER_DONT_ROUND" },
761 { IDC_ENABLE_ATTR_COLOR_BOLD, "DLG_TAB_VISUAL_BOLD_COLOR" }, // SGR 1
762 { IDC_ENABLE_ATTR_FONT_BOLD, "DLG_TAB_VISUAL_BOLD_FONT" },
763 { IDC_ENABLE_ATTR_COLOR_UNDERLINE, "DLG_TAB_VISUAL_UNDERLINE_COLOR" }, // SGR 4
764 { IDC_ENABLE_ATTR_FONT_UNDERLINE, "DLG_TAB_VISUAL_UNDERLINE_FONT" },
765 { IDC_ENABLE_ATTR_COLOR_BLINK, "DLG_TAB_VISUAL_BLINK" }, // SGR 5
766 { IDC_ENABLE_ATTR_COLOR_REVERSE, "DLG_TAB_VISUAL_REVERSE" }, // SGR 7
767 { IDC_ENABLE_ATTR_COLOR_URL, "DLG_TAB_VISUAL_URL_COLOR" }, // URL Attribute
768 { IDC_ENABLE_ATTR_FONT_URL, "DLG_TAB_VISUAL_URL_FONT" },
769 { IDC_ENABLE_ANSI_COLOR, "DLG_TAB_VISUAL_ANSI" },
770 { IDC_CHECK_FAST_SIZE_MOVE, "DLG_TAB_VISUAL_FAST_SIZE_MOVE" },
771 };
772 SetDlgTextsW(m_hWnd, TextInfos, _countof(TextInfos), ts.UILanguageFileW);
773
774 const static I18nTextInfo visual_font_quality[] = {
775 { "DLG_TAB_VISUAL_FONT_QUALITY_DEFAULT", L"Default" },
776 { "DLG_TAB_VISUAL_FONT_QUALITY_NONANTIALIASED", L"Non-Antialiased" },
777 { "DLG_TAB_VISUAL_FONT_QUALITY_ANTIALIASED", L"Antialiased" },
778 { "DLG_TAB_VISUAL_FONT_QUALITY_CLEARTYPE", L"ClearType" },
779 };
780 SetI18nListW("Tera Term", m_hWnd, IDC_FONT_QUALITY, visual_font_quality, _countof(visual_font_quality),
781 ts.UILanguageFileW, 0);
782
783 // (1)AlphaBlend
784
785 SetDlgItemNum(IDC_ALPHA_BLEND_ACTIVE, ts.AlphaBlendActive);
786 SendDlgItemMessage(IDC_ALPHA_BLEND_ACTIVE_TRACKBAR, TBM_SETRANGE, TRUE, MAKELPARAM(0, 255));
787 SendDlgItemMessage(IDC_ALPHA_BLEND_ACTIVE_TRACKBAR, TBM_SETPOS, TRUE, ts.AlphaBlendActive);
788
789 SetDlgItemNum(IDC_ALPHA_BLEND_INACTIVE, ts.AlphaBlendInactive);
790 SendDlgItemMessage(IDC_ALPHA_BLEND_INACTIVE_TRACKBAR, TBM_SETRANGE, TRUE, MAKELPARAM(0, 255));
791 SendDlgItemMessage(IDC_ALPHA_BLEND_INACTIVE_TRACKBAR, TBM_SETPOS, TRUE, ts.AlphaBlendInactive);
792
793 BOOL isLayeredWindowSupported = (pSetLayeredWindowAttributes != NULL);
794 EnableDlgItem(IDC_ALPHA_BLEND_ACTIVE, isLayeredWindowSupported);
795 EnableDlgItem(IDC_ALPHA_BLEND_ACTIVE_TRACKBAR, isLayeredWindowSupported);
796 EnableDlgItem(IDC_ALPHA_BLEND_INACTIVE, isLayeredWindowSupported);
797 EnableDlgItem(IDC_ALPHA_BLEND_INACTIVE_TRACKBAR, isLayeredWindowSupported);
798
799 // (2) theme file
800 {
801 const static I18nTextInfo theme_select[] = {
802 { "DLG_TAB_VISUAL_THEME_STARTUP_NO_USE", L"no use" },
803 { "DLG_TAB_VISUAL_THEME_STARTUP_FIXED_THEME", L"fixed theme file" },
804 { "DLG_TAB_VISUAL_THEME_STARTUP_RANDOM_THEME", L"random theme file" },
805 };
806
807 int sel = ts.EtermLookfeel.BGEnable;
808 if (sel < 0) sel = 0;
809 if (sel > 2) sel = 2;
810 SetI18nListW("Tera Term", m_hWnd, IDC_THEME_FILE, theme_select, _countof(theme_select),
811 ts.UILanguageFileW, sel);
812 BOOL enable = (sel == 1) ? TRUE : FALSE;
813 EnableDlgItem(IDC_THEME_EDIT, enable);
814 EnableDlgItem(IDC_THEME_BUTTON, enable);
815
816 SetDlgItemTextW(IDC_THEME_EDIT, ts.EtermLookfeel.BGThemeFileW);
817 }
818
819 // (3)Mouse cursor type
820 int sel = 0;
821 for (int i = 0 ; MouseCursor[i].name ; i++) {
822 const char *name = MouseCursor[i].name;
823 SendDlgItemMessageA(IDC_MOUSE_CURSOR, CB_ADDSTRING, i, (LPARAM)name);
824 if (_stricmp(name, ts.MouseCursorName) == 0) {
825 sel = i;
826 }
827 }
828 SetCurSel(IDC_MOUSE_CURSOR, sel);
829
830 // (4)Font quality
831 switch (ts.FontQuality) {
832 case DEFAULT_QUALITY:
833 SetCurSel(IDC_FONT_QUALITY, 0);
834 break;
835 case NONANTIALIASED_QUALITY:
836 SetCurSel(IDC_FONT_QUALITY, 1);
837 break;
838 case ANTIALIASED_QUALITY:
839 SetCurSel(IDC_FONT_QUALITY, 2);
840 break;
841 default: // CLEARTYPE_QUALITY
842 SetCurSel(IDC_FONT_QUALITY, 3);
843 break;
844 }
845
846 // (5)ANSI color
847 for (int i = 0; i < 16; i++) {
848 ANSIColor[i] = ts.ANSIColor[i];
849 }
850 for (int i = 0 ; i < 16 ; i++) {
851 char buf[4];
852 _snprintf_s(buf, sizeof(buf), _TRUNCATE, "%d", i);
853 SendDlgItemMessageA(IDC_ANSI_COLOR, LB_INSERTSTRING, i, (LPARAM)buf);
854 }
855 SetupRGBbox(0);
856 SendDlgItemMessage(IDC_ANSI_COLOR, LB_SETCURSEL, 0, 0);
857 ::InvalidateRect(GetDlgItem(IDC_SAMPLE_COLOR), NULL, TRUE);
858
859 // (6)Bold Attr Color
860 SetCheck(IDC_ENABLE_ATTR_COLOR_BOLD, (ts.ColorFlag&CF_BOLDCOLOR) != 0);
861 SetCheck(IDC_ENABLE_ATTR_FONT_BOLD, (ts.FontFlag&FF_BOLD) != 0);
862
863 // (7)Blink Attr Color
864 SetCheck(IDC_ENABLE_ATTR_COLOR_BLINK, (ts.ColorFlag&CF_BLINKCOLOR) != 0);
865
866 // (8)Reverse Attr Color
867 SetCheck(IDC_ENABLE_ATTR_COLOR_REVERSE, (ts.ColorFlag&CF_REVERSECOLOR) != 0);
868
869 // Underline Attr
870 SetCheck(IDC_ENABLE_ATTR_COLOR_UNDERLINE, (ts.ColorFlag&CF_UNDERLINE) != 0);
871 SetCheck(IDC_ENABLE_ATTR_FONT_UNDERLINE, (ts.FontFlag&FF_UNDERLINE) != 0);
872
873 // URL Underline Attr
874 SetCheck(IDC_ENABLE_ATTR_COLOR_URL, (ts.ColorFlag&CF_URLCOLOR) != 0);
875 SetCheck(IDC_ENABLE_ATTR_FONT_URL, (ts.FontFlag&FF_URLUNDERLINE) != 0);
876
877 // Color
878 SetCheck(IDC_ENABLE_ANSI_COLOR, (ts.ColorFlag&CF_ANSICOLOR) != 0);
879
880 SetCheck(IDC_CHECK_FAST_SIZE_MOVE, ts.EtermLookfeel.BGFastSizeMove != 0);
881 SetCheck(IDC_CHECK_FLICKER_LESS_MOVE, ts.EtermLookfeel.BGNoCopyBits != 0);
882
883 // �E�B���h�E���p������������
884 SetCheck(IDC_CHECK_CORNERDONTROUND, (ts.WindowCornerDontround) != 0);
885 {
886 DWM_WINDOW_CORNER_PREFERENCE preference;
887 if (pDwmGetWindowAttribute == NULL ||
888 pDwmGetWindowAttribute(HVTWin, DWMWA_WINDOW_CORNER_PREFERENCE, &preference, sizeof(preference)) != S_OK) {
889 // �E�B���h�E���p�������������������������������� disable ������
890 // DwmGetWindowAttribute() API ������ or
891 // DwmGetWindowAttribute(DWMWA_WINDOW_CORNER_PREFERENCE) �� S_OK ����������
892 EnableDlgItem(IDC_CHECK_CORNERDONTROUND, FALSE);
893 }
894 }
895
896 SetCheck(IDC_THEME_ENABLE, ThemeIsEnabled() ? BST_CHECKED : BST_UNCHECKED);
897
898 SetDlgItemTextW(IDC_SPIPATH_EDIT, ts.EtermLookfeel.BGSPIPathW);
899
900 // �_�C�A���O���t�H�[�J�X��������
901 ::SetFocus(GetDlgItem(IDC_ALPHA_BLEND_ACTIVE));
902
903 // �c�[���`�b�v����
904 TipWin->Create(m_hWnd);
905 }
906
907 void CVisualPropPageDlg::OnHScroll(UINT nSBCode, UINT nPos, HWND pScrollBar)
908 {
909 int pos;
910 if ( pScrollBar == GetDlgItem(IDC_ALPHA_BLEND_ACTIVE_TRACKBAR) ) {
911 switch (nSBCode) {
912 case SB_TOP:
913 case SB_BOTTOM:
914 case SB_LINEDOWN:
915 case SB_LINEUP:
916 case SB_PAGEDOWN:
917 case SB_PAGEUP:
918 case SB_THUMBPOSITION:
919 case SB_THUMBTRACK:
920 pos = (int)SendDlgItemMessage(IDC_ALPHA_BLEND_ACTIVE_TRACKBAR, TBM_GETPOS, NULL, NULL);
921 SetDlgItemNum(IDC_ALPHA_BLEND_ACTIVE, pos);
922 break;
923 case SB_ENDSCROLL:
924 default:
925 return;
926 }
927 }
928 else if ( pScrollBar == GetDlgItem(IDC_ALPHA_BLEND_INACTIVE_TRACKBAR) ) {
929 switch (nSBCode) {
930 case SB_TOP:
931 case SB_BOTTOM:
932 case SB_LINEDOWN:
933 case SB_LINEUP:
934 case SB_PAGEDOWN:
935 case SB_PAGEUP:
936 case SB_THUMBPOSITION:
937 case SB_THUMBTRACK:
938 pos = (int)SendDlgItemMessage(IDC_ALPHA_BLEND_INACTIVE_TRACKBAR, TBM_GETPOS, NULL, NULL);
939 SetDlgItemNum(IDC_ALPHA_BLEND_INACTIVE, pos);
940 break;
941 case SB_ENDSCROLL:
942 default:
943 return;
944 }
945 }
946 }
947
948 static void OpacityTooltip(CTipWin* tip, HWND hDlg, int trackbar, int pos, const wchar_t *UILanguageFile)
949 {
950 wchar_t *uimsg;
951 GetI18nStrWW("Tera Term", "TOOLTIP_TITLEBAR_OPACITY", L"Opacity %.1f %%", UILanguageFile, &uimsg);
952 wchar_t *tipbuf;
953 aswprintf(&tipbuf, uimsg, (pos / 255.0) * 100);
954 RECT rc;
955 ::GetWindowRect(::GetDlgItem(hDlg, trackbar), &rc);
956 tip->SetText(tipbuf);
957 tip->SetPos(rc.right, rc.bottom);
958 tip->SetHideTimer(1000);
959 if (! tip->IsVisible()) {
960 tip->SetVisible(TRUE);
961 }
962 free(tipbuf);
963 free(uimsg);
964 }
965
966 BOOL CVisualPropPageDlg::OnCommand(WPARAM wParam, LPARAM lParam)
967 {
968 switch (wParam) {
969 case IDC_THEME_EDITOR_BUTTON | (BN_CLICKED << 16): {
970 ThemeDialog(m_hInst, m_hWnd, &cv);
971 break;
972 }
973 case IDC_THEME_FILE | (CBN_SELCHANGE << 16): {
974 int r = GetCurSel(IDC_THEME_FILE);
975 // �����������A�t�@�C��������������������������
976 BOOL enable = (r == 1) ? TRUE : FALSE;
977 EnableDlgItem(IDC_THEME_EDIT, enable);
978 EnableDlgItem(IDC_THEME_BUTTON, enable);
979 break;
980 }
981 case IDC_THEME_BUTTON | (BN_CLICKED << 16): {
982 // �e�[�}�t�@�C�����I������
983 wchar_t *theme_file;
984 hGetDlgItemTextW(m_hWnd, IDC_THEME_EDIT, &theme_file);
985
986 wchar_t *theme_dir;
987 aswprintf(&theme_dir, L"%s\\theme", ts.HomeDirW);
988
989 TTOPENFILENAMEW ofn = {};
990 ofn.hwndOwner = m_hWnd;
991 ofn.lpstrFilter = L"Theme Files(*.ini)\0*.ini\0All Files(*.*)\0*.*\0";
992 ofn.lpstrTitle = L"select theme file";
993 ofn.lpstrFile = theme_file;
994 ofn.lpstrInitialDir = theme_dir;
995 ofn.Flags = OFN_FILEMUSTEXIST | OFN_HIDEREADONLY;
996 wchar_t *filename;
997 BOOL ok = TTGetOpenFileNameW(&ofn, &filename);
998 if (ok) {
999 SetDlgItemTextW(IDC_THEME_EDIT, filename);
1000 free(filename);
1001 }
1002 free(theme_dir);
1003 free(theme_file);
1004 return TRUE;
1005 }
1006
1007 case IDC_ANSI_COLOR | (LBN_SELCHANGE << 16): {
1008 int sel = (int)SendDlgItemMessage(IDC_ANSI_COLOR, LB_GETCURSEL, 0, 0);
1009 if (sel != -1) {
1010 SetupRGBbox(sel);
1011 ::InvalidateRect(GetDlgItem(IDC_SAMPLE_COLOR), NULL, TRUE);
1012 }
1013 return TRUE;
1014 }
1015
1016 case IDC_COLOR_RED | (EN_CHANGE << 16) :
1017 case IDC_COLOR_GREEN | (EN_CHANGE << 16) :
1018 case IDC_COLOR_BLUE | (EN_CHANGE << 16) :
1019 {
1020 int r, g, b;
1021 int sel;
1022
1023 sel = GetCurSel(IDC_ANSI_COLOR);
1024 if (sel < 0 || sel > _countof(ANSIColor)-1) {
1025 return TRUE;
1026 }
1027
1028 r = GetDlgItemInt(IDC_COLOR_RED);
1029 if (r < 0) {
1030 r = 0;
1031 SetDlgItemNum(IDC_COLOR_RED, r);
1032 }
1033 else if (r > 255) {
1034 r = 255;
1035 SetDlgItemNum(IDC_COLOR_RED, r);
1036 }
1037
1038 g = GetDlgItemInt(IDC_COLOR_GREEN);
1039 if (g < 0) {
1040 g = 0;
1041 SetDlgItemNum(IDC_COLOR_GREEN, g);
1042 }
1043 else if (g > 255) {
1044 g = 255;
1045 SetDlgItemNum(IDC_COLOR_GREEN, g);
1046 }
1047
1048 b = GetDlgItemInt(IDC_COLOR_BLUE);
1049 if (b < 0) {
1050 b = 0;
1051 SetDlgItemNum(IDC_COLOR_BLUE, b);
1052 }
1053 else if (b > 255) {
1054 b = 255;
1055 SetDlgItemNum(IDC_COLOR_BLUE, b);
1056 }
1057
1058 ANSIColor[sel] = RGB(r, g, b);
1059
1060 ::InvalidateRect(GetDlgItem(IDC_SAMPLE_COLOR), NULL, TRUE);
1061 }
1062 return TRUE;
1063 case IDC_ALPHA_BLEND_ACTIVE | (EN_CHANGE << 16):
1064 {
1065 int pos;
1066 pos = GetDlgItemInt(IDC_ALPHA_BLEND_ACTIVE);
1067 if(pos < 0) {
1068 pos = 0;
1069 SetDlgItemNum(IDC_ALPHA_BLEND_ACTIVE, pos);
1070 }
1071 else if(pos > 255) {
1072 pos = 255;
1073 SetDlgItemNum(IDC_ALPHA_BLEND_ACTIVE, pos);
1074 }
1075 SendDlgItemMessage(IDC_ALPHA_BLEND_ACTIVE_TRACKBAR, TBM_SETPOS, TRUE, pos);
1076 OpacityTooltip(TipWin, m_hWnd, IDC_ALPHA_BLEND_ACTIVE, pos, ts.UILanguageFileW);
1077 return TRUE;
1078 }
1079 case IDC_ALPHA_BLEND_INACTIVE | (EN_CHANGE << 16):
1080 {
1081 int pos;
1082 pos = GetDlgItemInt(IDC_ALPHA_BLEND_INACTIVE);
1083 if(pos < 0) {
1084 pos = 0;
1085 SetDlgItemNum(IDC_ALPHA_BLEND_INACTIVE, pos);
1086 }
1087 else if(pos > 255) {
1088 pos = 255;
1089 SetDlgItemNum(IDC_ALPHA_BLEND_INACTIVE, pos);
1090 }
1091 SendDlgItemMessage(IDC_ALPHA_BLEND_INACTIVE_TRACKBAR, TBM_SETPOS, TRUE, pos);
1092 OpacityTooltip(TipWin, m_hWnd, IDC_ALPHA_BLEND_INACTIVE, pos, ts.UILanguageFileW);
1093 return TRUE;
1094 }
1095 case IDC_SPIPATH_BUTTON | (BN_CLICKED << 16): {
1096 wchar_t *def;
1097 hGetDlgItemTextW(m_hWnd, IDC_SPIPATH_EDIT, &def);
1098 if (GetFileAttributesW(def) == INVALID_FILE_ATTRIBUTES) {
1099 // �t�H���_������������(�����r��?,TT4�������s?)
1100 static const TTMessageBoxInfoW info = {
1101 "Tera Term",
1102 "MSG_TT_NOTICE", L"Tera Term: Notice",
1103 NULL, L"'%s' not exist\nUse home folder",
1104 MB_OK };
1105 TTMessageBoxW(m_hWnd, &info, ts.UILanguageFileW, def);
1106 free(def);
1107 def = _wcsdup(ts.HomeDirW);
1108 }
1109
1110 TTBROWSEINFOW bi = {};
1111 bi.hwndOwner = m_hWnd;
1112 bi.lpszTitle = L"Select Susie Plugin path";
1113 bi.ulFlags = BIF_RETURNONLYFSDIRS | BIF_EDITBOX | BIF_NEWDIALOGSTYLE;
1114
1115 wchar_t *folder;
1116 if (TTSHBrowseForFolderW(&bi, def, &folder)) {
1117 SetDlgItemTextW(IDC_SPIPATH_EDIT, folder);
1118 free(folder);
1119 }
1120 free(def);
1121 break;
1122 }
1123 }
1124
1125 return TTCPropertyPage::OnCommand(wParam, lParam);
1126 }
1127
1128 HBRUSH CVisualPropPageDlg::OnCtlColor(HDC hDC, HWND hWnd)
1129 {
1130 if ( hWnd == GetDlgItem(IDC_SAMPLE_COLOR) ) {
1131 BYTE r = (BYTE)GetDlgItemInt(IDC_COLOR_RED);
1132 BYTE g = (BYTE)GetDlgItemInt(IDC_COLOR_GREEN);
1133 BYTE b = (BYTE)GetDlgItemInt(IDC_COLOR_BLUE);
1134 SetBkMode(hDC, TRANSPARENT);
1135 SetTextColor(hDC, RGB(r, g, b) );
1136
1137 return (HBRUSH)GetStockObject(NULL_BRUSH);
1138 }
1139 return TTCPropertyPage::OnCtlColor(hDC, hWnd);
1140 }
1141
1142 /**
1143 * �F�����������X�������`�F�b�N����
1144 * @retval TRUE ���X����
1145 * @retval FALSE ���X����������
1146 */
1147 BOOL CVisualPropPageDlg::CheckColorChanged()
1148 {
1149 for (int i = 0; i < 16; i++) {
1150 if (ts.ANSIColor[i] != ANSIColor[i]) {
1151 return TRUE;
1152 }
1153 }
1154 return FALSE;
1155 }
1156
1157 /**
1158 * �e�[�}�J���[�����������������`�F�b�N����
1159 * @retval TRUE ��������������
1160 * @retval FALSE ����������������
1161 */
1162 BOOL CVisualPropPageDlg::CheckThemeColor()
1163 {
1164 TColorTheme def; // default color (=ts.ANSIColor[])
1165 ThemeGetColorDefault(&def);
1166 TColorTheme disp; // ���\�������������F
1167 ThemeGetColor(&disp);
1168 for (int i = 0; i < 16; i++) {
1169 if (disp.ansicolor.color[i] != def.ansicolor.color[i]) {
1170 return TRUE;
1171 }
1172 }
1173 return FALSE;
1174 }
1175
1176 void CVisualPropPageDlg::OnOK()
1177 {
1178 int sel;
1179 int i;
1180
1181 // (1)
1182 i = GetDlgItemInt(IDC_ALPHA_BLEND_ACTIVE);
1183 ts.AlphaBlendActive =
1184 (i < 0) ? 0 :
1185 (BYTE)((i > 255) ? 255 : i);
1186 i = GetDlgItemInt(IDC_ALPHA_BLEND_INACTIVE);
1187 ts.AlphaBlendInactive =
1188 (i < 0) ? 0 :
1189 (BYTE)((i > 255) ? 255 : i);
1190
1191 // (2) �e�[�}�t�@�C���I��
1192 {
1193 int r = GetCurSel(IDC_THEME_FILE);
1194 switch (r) {
1195 default:
1196 assert(FALSE);
1197 // fall through
1198 case 0:
1199 ts.EtermLookfeel.BGEnable = 0;
1200 break;
1201 case 1: {
1202 // �e�[�}�t�@�C���w��
1203 ts.EtermLookfeel.BGEnable = 1;
1204
1205 wchar_t* theme_file;
1206 hGetDlgItemTextW(m_hWnd, IDC_THEME_EDIT, &theme_file);
1207
1208 if (ts.EtermLookfeel.BGThemeFileW != NULL) {
1209 free(ts.EtermLookfeel.BGThemeFileW);
1210 }
1211 ts.EtermLookfeel.BGThemeFileW = theme_file;
1212 break;
1213 }
1214 case 2: {
1215 // �����_���e�[�}
1216 ts.EtermLookfeel.BGEnable = 2;
1217 if (ts.EtermLookfeel.BGThemeFileW != NULL) {
1218 free(ts.EtermLookfeel.BGThemeFileW);
1219 }
1220 ts.EtermLookfeel.BGThemeFileW = NULL;
1221 break;
1222 }
1223 }
1224 }
1225
1226
1227 // (3)
1228 sel = GetCurSel(IDC_MOUSE_CURSOR);
1229 if (sel >= 0 && sel < MOUSE_CURSOR_MAX) {
1230 strncpy_s(ts.MouseCursorName, sizeof(ts.MouseCursorName), MouseCursor[sel].name, _TRUNCATE);
1231 }
1232
1233 // (4)Font quality
1234 switch (GetCurSel(IDC_FONT_QUALITY)) {
1235 case 0:
1236 ts.FontQuality = DEFAULT_QUALITY;
1237 break;
1238 case 1:
1239 ts.FontQuality = NONANTIALIASED_QUALITY;
1240 break;
1241 case 2:
1242 ts.FontQuality = ANTIALIASED_QUALITY;
1243 break;
1244 case 3:
1245 ts.FontQuality = CLEARTYPE_QUALITY;
1246 break;
1247 default: // Invalid value.
1248 break;
1249 }
1250
1251 // (6) Attr Bold Color
1252 if (((ts.ColorFlag & CF_BOLDCOLOR) != 0) != GetCheck(IDC_ENABLE_ATTR_COLOR_BOLD)) {
1253 ts.ColorFlag ^= CF_BOLDCOLOR;
1254 }
1255 if (((ts.FontFlag & FF_BOLD) != 0) != GetCheck(IDC_ENABLE_ATTR_FONT_BOLD)) {
1256 ts.FontFlag ^= FF_BOLD;
1257 }
1258
1259 // (7) Attr Blink Color
1260 if (((ts.ColorFlag & CF_BLINKCOLOR) != 0) != GetCheck(IDC_ENABLE_ATTR_COLOR_BLINK)) {
1261 ts.ColorFlag ^= CF_BLINKCOLOR;
1262 }
1263
1264 // (8) Attr Reverse Color
1265 if (((ts.ColorFlag & CF_REVERSECOLOR) != 0) != GetCheck(IDC_ENABLE_ATTR_COLOR_REVERSE)) {
1266 ts.ColorFlag ^= CF_REVERSECOLOR;
1267 }
1268
1269 // Underline Attr
1270 if (((ts.FontFlag & FF_UNDERLINE) != 0) != GetCheck(IDC_ENABLE_ATTR_FONT_UNDERLINE)) {
1271 ts.FontFlag ^= FF_UNDERLINE;
1272 }
1273 if (((ts.ColorFlag & CF_UNDERLINE) != 0) != GetCheck(IDC_ENABLE_ATTR_COLOR_UNDERLINE)) {
1274 ts.ColorFlag ^= CF_UNDERLINE;
1275 }
1276
1277 // URL Underline Attr
1278 if (((ts.FontFlag & FF_URLUNDERLINE) != 0) != GetCheck(IDC_ENABLE_ATTR_FONT_URL)) {
1279 ts.FontFlag ^= FF_URLUNDERLINE;
1280 }
1281 if (((ts.ColorFlag & CF_URLCOLOR) != 0) != GetCheck(IDC_ENABLE_ATTR_COLOR_URL)) {
1282 ts.ColorFlag ^= CF_URLCOLOR;
1283 }
1284
1285 // Color
1286 if (((ts.ColorFlag & CF_ANSICOLOR) != 0) != GetCheck(IDC_ENABLE_ANSI_COLOR)) {
1287 ts.ColorFlag ^= CF_ANSICOLOR;
1288 }
1289
1290 ts.EtermLookfeel.BGFastSizeMove = GetCheck(IDC_CHECK_FAST_SIZE_MOVE);
1291 ts.EtermLookfeel.BGNoCopyBits = GetCheck(IDC_CHECK_FLICKER_LESS_MOVE);
1292
1293 // �E�B���h�E���p������������
1294 if (ts.WindowCornerDontround != GetCheck(IDC_CHECK_CORNERDONTROUND)) {
1295 ts.WindowCornerDontround = GetCheck(IDC_CHECK_CORNERDONTROUND);
1296 if (pDwmSetWindowAttribute != NULL) {
1297 DWM_WINDOW_CORNER_PREFERENCE preference = ts.WindowCornerDontround ? DWMWCP_DONOTROUND : DWMWCP_DEFAULT;
1298 pDwmSetWindowAttribute(HVTWin, DWMWA_WINDOW_CORNER_PREFERENCE, &preference, sizeof(preference));
1299 }
1300 }
1301
1302 // ANSI Color
1303 if (CheckColorChanged()) {
1304 // �F�����X���s������
1305 bool set_color = TRUE;
1306
1307 // �J���[�e�[�}���g�����F�����X����������?
1308 if (CheckThemeColor()) {
1309 static const TTMessageBoxInfoW info = {
1310 "Tera Term",
1311 "MSG_TT_NOTICE", L"Tera Term: Notice",
1312 NULL, L"Color settings have been changed.\nDo you want to display this?",
1313 MB_ICONQUESTION | MB_YESNO };
1314 int r = TTMessageBoxW(m_hWnd, &info, ts.UILanguageFileW);
1315 if (r == IDNO) {
1316 set_color = FALSE;
1317 }
1318 }
1319
1320 // �F������(�f�t�H���g�F)�����f
1321 for (i = 0; i < 16; i++) {
1322 ts.ANSIColor[i] = ANSIColor[i];
1323 }
1324
1325 // �����������F���\�������f
1326 if (set_color) {
1327 TColorTheme color;
1328 // �f�t�H���g�F����������
1329 ThemeGetColorDefault(&color);
1330 ThemeSetColor(&color);
1331 }
1332 }
1333
1334 if ((GetCheck(IDC_THEME_ENABLE) == BST_CHECKED) && ThemeIsEnabled() == FALSE) {
1335 // �e�[�}��enable������
1336 ThemeEnable(TRUE);
1337 }
1338 else if ((GetCheck(IDC_THEME_ENABLE) == BST_UNCHECKED) && ThemeIsEnabled() == TRUE) {
1339 // �e�[�}��disable������
1340 ThemeEnable(FALSE);
1341 }
1342
1343 wchar_t *spi_path;
1344 hGetDlgItemTextW(m_hWnd, IDC_SPIPATH_EDIT, &spi_path);
1345 free(ts.EtermLookfeel.BGSPIPathW);
1346 ts.EtermLookfeel.BGSPIPathW = spi_path;
1347 }
1348
1349 void CVisualPropPageDlg::OnHelp()
1350 {
1351 PostMessage(HVTWin, WM_USER_DLGHELP2, HlpMenuSetupAdditionalVisual, 0);
1352 }
1353
1354 // CLogPropPageDlg �_�C�A���O
1355 class CLogPropPageDlg : public TTCPropertyPage
1356 {
1357 public:
1358 CLogPropPageDlg(HINSTANCE inst);
1359 virtual ~CLogPropPageDlg();
1360 private:
1361 void OnInitDialog();
1362 void OnOK();
1363 void OnOKLogFilename();
1364 enum { IDD = IDD_TABSHEET_LOG };
1365 BOOL OnCommand(WPARAM wParam, LPARAM lParam);
1366 void OnHelp();
1367 wchar_t *MakePreviewStr(const wchar_t *format, const wchar_t *UILanguageFile);
1368 CTipWin *m_TipWin;
1369 };
1370
1371 CLogPropPageDlg::CLogPropPageDlg(HINSTANCE inst)
1372 : TTCPropertyPage(inst, CLogPropPageDlg::IDD)
1373 {
1374 wchar_t *UIMsg;
1375 GetI18nStrWW("Tera Term", "DLG_TABSHEET_TITLE_Log",
1376 L"Log", ts.UILanguageFileW, &UIMsg);
1377 m_psp.pszTitle = UIMsg;
1378 m_psp.dwFlags |= (PSP_USETITLE | PSP_HASHELP);
1379 m_TipWin = new CTipWin(inst);
1380 }
1381
1382 CLogPropPageDlg::~CLogPropPageDlg()
1383 {
1384 free((void *)m_psp.pszTitle);
1385 m_TipWin->Destroy();
1386 delete m_TipWin;
1387 m_TipWin = NULL;
1388 }
1389
1390 // CLogPropPageDlg ���b�Z�[�W �n���h��
1391
1392 #define LOG_ROTATE_SIZETYPE_NUM 3
1393 static const char *LogRotateSizeType[] = {
1394 "Byte", "KB", "MB"
1395 };
1396
1397 static const char *GetLogRotateSizeType(int val)
1398 {
1399 if (val >= LOG_ROTATE_SIZETYPE_NUM)
1400 val = 0;
1401
1402 return LogRotateSizeType[val];
1403 }
1404
1405 void CLogPropPageDlg::OnInitDialog()
1406 {
1407 TTCPropertyPage::OnInitDialog();
1408
1409 static const DlgTextInfo TextInfos[] = {
1410 { IDC_VIEWLOG_LABEL, "DLG_TAB_LOG_EDITOR" },
1411 { IDC_DEFAULTNAME_LABEL, "DLG_TAB_LOG_FILENAME" },
1412 { IDC_DEFAULTPATH_LABEL, "DLG_TAB_LOG_FILEPATH" },
1413 { IDC_AUTOSTART, "DLG_TAB_LOG_AUTOSTART" },
1414 // Log rotate
1415 { IDC_LOG_ROTATE, "DLG_TAB_LOG_ROTATE" },
1416 { IDC_ROTATE_SIZE_TEXT, "DLG_TAB_LOG_ROTATE_SIZE_TEXT" },
1417 { IDC_ROTATE_STEP_TEXT, "DLG_TAB_LOG_ROTATESTEP" },
1418 // Log options
1419 // FIXME: ���b�Z�[�W�J�^���O�����������O�I�v�V���������������p�������A�A�N�Z�����[�^�L�[���d�������������������B
1420 { IDC_LOG_OPTION_GROUP, "DLG_FOPT" },
1421 { IDC_OPT_BINARY, "DLG_FOPT_BINARY" },
1422 { IDC_OPT_APPEND, "DLG_FOPT_APPEND" },
1423 { IDC_OPT_PLAINTEXT, "DLG_FOPT_PLAIN" },
1424 { IDC_OPT_HIDEDLG, "DLG_FOPT_HIDEDIALOG" },
1425 { IDC_OPT_INCBUF, "DLG_FOPT_ALLBUFFINFIRST" },
1426 { IDC_OPT_TIMESTAMP, "DLG_FOPT_TIMESTAMP" },
1427 };
1428 SetDlgTextsW(m_hWnd, TextInfos, _countof(TextInfos), ts.UILanguageFileW);
1429
1430 const static I18nTextInfo fopt_timestamp[] = {
1431 { "DLG_FOPT_TIMESTAMP_LOCAL", L"Local Time" },
1432 { "DLG_FOPT_TIMESTAMP_UTC", L"UTC" },
1433 { "DLG_FOPT_TIMESTAMP_ELAPSED_LOGGING", L"Elapsed Time (Logging)" },
1434 { "DLG_FOPT_TIMESTAMP_ELAPSED_CONNECTION", L"Elapsed Time (Connection)" },
1435 };
1436 SetI18nListW("Tera Term", m_hWnd, IDC_OPT_TIMESTAMP_TYPE, fopt_timestamp, _countof(fopt_timestamp),
1437 ts.UILanguageFileW, 0);
1438
1439 // Viewlog Editor path (2005.1.29 yutaka)
1440 SetDlgItemTextA(IDC_VIEWLOG_EDITOR, ts.ViewlogEditor);
1441
1442 // Log Default File Name
1443 static const wchar_t *logfile_patterns[] = {
1444 L"teraterm.log",
1445 L"%H%M%S.log",
1446 L"%y%m%d%H%M%S.log",
1447 L"%Y%m%d_%H%M%S.log",
1448 L"%y%m%d_%H%M%S.log",
1449 L"teraterm_%y%m%d%H%M%S.log",
1450 L"%y%m%d_%H%M%S_&h.log",
1451 L"%Y%m%d_%H%M%S_%z.log",
1452 L"%y%m%d_%H%M%S_%z.log",
1453 L"%Y%m%dT%H%M%S%z.log",
1454 };
1455 for (int i = 0; i < _countof(logfile_patterns); i++) {
1456 const wchar_t *pattern = logfile_patterns[i];
1457 SendDlgItemMessageW(IDC_DEFAULTNAME_EDITOR, CB_ADDSTRING, 0, (LPARAM)pattern);
1458 }
1459 ExpandCBWidth(m_hWnd, IDC_DEFAULTNAME_EDITOR);
1460 SetDlgItemTextW(IDC_DEFAULTNAME_EDITOR, ts.LogDefaultNameW);
1461
1462 // Log Default File Path (2007.5.30 maya)
1463 SetDlgItemTextW(IDC_DEFAULTPATH_EDITOR, ts.LogDefaultPathW);
1464
1465 /* Auto start logging (2007.5.31 maya) */
1466 SetCheck(IDC_AUTOSTART, ts.LogAutoStart);
1467
1468 // Log rotate
1469 SetCheck(IDC_LOG_ROTATE, ts.LogRotate != ROTATE_NONE);
1470
1471 for (int i = 0 ; i < LOG_ROTATE_SIZETYPE_NUM ; i++) {
1472 SendDlgItemMessageA(IDC_ROTATE_SIZE_TYPE, CB_ADDSTRING, 0, (LPARAM)LogRotateSizeType[i]);
1473 }
1474 int TmpLogRotateSize = ts.LogRotateSize;
1475 for (int i = 0 ; i < ts.LogRotateSizeType ; i++)
1476 TmpLogRotateSize /= 1024;
1477 SetDlgItemInt(IDC_ROTATE_SIZE, TmpLogRotateSize, FALSE);
1478 SendDlgItemMessageA(IDC_ROTATE_SIZE_TYPE, CB_SELECTSTRING, -1, (LPARAM)GetLogRotateSizeType(ts.LogRotateSizeType));
1479 SetDlgItemInt(IDC_ROTATE_STEP, ts.LogRotateStep, FALSE);
1480 if (ts.LogRotate == ROTATE_NONE) {
1481 EnableDlgItem(IDC_ROTATE_SIZE_TEXT, FALSE);
1482 EnableDlgItem(IDC_ROTATE_SIZE, FALSE);
1483 EnableDlgItem(IDC_ROTATE_SIZE_TYPE, FALSE);
1484 EnableDlgItem(IDC_ROTATE_STEP_TEXT, FALSE);
1485 EnableDlgItem(IDC_ROTATE_STEP, FALSE);
1486 } else {
1487 EnableDlgItem(IDC_ROTATE_SIZE_TEXT, TRUE);
1488 EnableDlgItem(IDC_ROTATE_SIZE, TRUE);
1489 EnableDlgItem(IDC_ROTATE_SIZE_TYPE, TRUE);
1490 EnableDlgItem(IDC_ROTATE_STEP_TEXT, TRUE);
1491 EnableDlgItem(IDC_ROTATE_STEP, TRUE);
1492 }
1493
1494 // Log options
1495 SetCheck(IDC_OPT_BINARY, ts.LogBinary != 0);
1496 if (ts.LogBinary) {
1497 EnableDlgItem(IDC_OPT_PLAINTEXT, FALSE);
1498 EnableDlgItem(IDC_OPT_TIMESTAMP, FALSE);
1499 } else {
1500 EnableDlgItem(IDC_OPT_PLAINTEXT, TRUE);
1501 EnableDlgItem(IDC_OPT_TIMESTAMP, TRUE);
1502 }
1503 SetCheck(IDC_OPT_APPEND, ts.Append != 0);
1504 SetCheck(IDC_OPT_PLAINTEXT, ts.LogTypePlainText != 0);
1505 SetCheck(IDC_OPT_HIDEDLG, ts.LogHideDialog != 0);
1506 SetCheck(IDC_OPT_INCBUF, ts.LogAllBuffIncludedInFirst != 0);
1507 SetCheck(IDC_OPT_TIMESTAMP, ts.LogTimestamp != 0);
1508
1509 SetCurSel(IDC_OPT_TIMESTAMP_TYPE, ts.LogTimestampType);
1510 if (ts.LogBinary || !ts.LogTimestamp) {
1511 EnableDlgItem(IDC_OPT_TIMESTAMP_TYPE, FALSE);
1512 }
1513 else {
1514 EnableDlgItem(IDC_OPT_TIMESTAMP_TYPE, TRUE);
1515 }
1516 /*
1517 switch (ts.LogTimestampType) {
1518 case CSF_CBRW:
1519 cmb->SetCurSel(3);
1520 break;
1521 case CSF_CBREAD:
1522 cmb->SetCurSel(2);
1523 break;
1524 case CSF_CBWRITE:
1525 cmb->SetCurSel(1);
1526 break;
1527 default: // off
1528 cmb->SetCurSel(0);
1529 break;
1530 }
1531 */
1532 m_TipWin->Create(m_hWnd);
1533
1534 PostMessage(m_hWnd, WM_NEXTDLGCTL,
1535 (WPARAM)GetDlgItem(IDC_VIEWLOG_EDITOR), TRUE);
1536 }
1537
1538 wchar_t *CLogPropPageDlg::MakePreviewStr(const wchar_t *format, const wchar_t *UILanguageFile)
1539 {
1540 wchar_t *str = FLogGetLogFilenameBase(format);
1541
1542 wchar_t *message = NULL;
1543 if (isInvalidStrftimeCharW(format)) {
1544 wchar_t *msg;
1545 GetI18nStrWW("Tera Term", "MSG_LOGFILE_INVALID_CHAR_ERROR",
1546 L"Invalid character is included in log file name.",
1547 UILanguageFile, &msg);
1548 awcscats(&message, L"\r\n", msg, L"(strftime)", NULL);
1549 free(msg);
1550 }
1551
1552 if (isInvalidFileNameCharW(format)) {
1553 wchar_t *msg;
1554 GetI18nStrWW("Tera Term", "MSG_LOGFILE_INVALID_CHAR_ERROR",
1555 L"Invalid character is included in log file name.",
1556 UILanguageFile, &msg);
1557 awcscats(&message, L"\r\n", msg, L"(char)", NULL);
1558 free(msg);
1559 }
1560
1561 if (message != NULL) {
1562 awcscat(&str, message);
1563 free(message);
1564 }
1565
1566 return str;
1567 }
1568
1569 BOOL CLogPropPageDlg::OnCommand(WPARAM wParam, LPARAM lParam)
1570 {
1571 switch (wParam) {
1572 case IDC_VIEWLOG_PATH | (BN_CLICKED << 16):
1573 {
1574 wchar_t *editor;
1575 hGetDlgItemTextW(m_hWnd, IDC_VIEWLOG_EDITOR, &editor);
1576
1577 TTOPENFILENAMEW ofn = {};
1578 ofn.hwndOwner = m_hWnd;
1579 ofn.lpstrFilter = TTGetLangStrW("Tera Term", "FILEDLG_SELECT_LOGVIEW_APP_FILTER", L"exe(*.exe)\\0*.exe\\0all(*.*)\\0*.*\\0\\0", ts.UILanguageFileW);
1580 ofn.lpstrFile = editor;
1581 ofn.lpstrTitle = TTGetLangStrW("Tera Term", "FILEDLG_SELECT_LOGVIEW_APP_TITLE", L"Choose a executing file with launching logging file", ts.UILanguageFileW);
1582 ofn.Flags = OFN_FILEMUSTEXIST | OFN_HIDEREADONLY;
1583 wchar_t *filew;
1584 BOOL ok = TTGetOpenFileNameW(&ofn, &filew);
1585 if (ok) {
1586 SetDlgItemTextW(IDC_VIEWLOG_EDITOR, filew);
1587 free(filew);
1588 }
1589 free((void *)ofn.lpstrFilter);
1590 free((void *)ofn.lpstrTitle);
1591 free(editor);
1592 }
1593 return TRUE;
1594
1595 case IDC_DEFAULTPATH_PUSH | (BN_CLICKED << 16):
1596 // ���O�f�B���N�g�����I���_�C�A���O
1597 {
1598 wchar_t *title = TTGetLangStrW("Tera Term", "FILEDLG_SELECT_LOGDIR_TITLE", L"Select log folder", ts.UILanguageFileW);
1599 wchar_t *default_path;
1600 hGetDlgItemTextW(m_hWnd, IDC_DEFAULTPATH_EDITOR, &default_path);
1601 if (default_path[0] == 0) {
1602 free(default_path);
1603 default_path = _wcsdup(ts.LogDirW);
1604 }
1605 wchar_t *new_path;
1606 if (doSelectFolderW(GetSafeHwnd(), default_path, title, &new_path)) {
1607 SetDlgItemTextW(IDC_DEFAULTPATH_EDITOR, new_path);
1608 free(new_path);
1609 }
1610 free(default_path);
1611 free(title);
1612 }
1613
1614 return TRUE;
1615
1616 case IDC_LOG_ROTATE | (BN_CLICKED << 16):
1617 {
1618 if (GetCheck(IDC_LOG_ROTATE)) {
1619 EnableDlgItem(IDC_ROTATE_SIZE_TEXT, TRUE);
1620 EnableDlgItem(IDC_ROTATE_SIZE, TRUE);
1621 EnableDlgItem(IDC_ROTATE_SIZE_TYPE, TRUE);
1622 EnableDlgItem(IDC_ROTATE_STEP_TEXT, TRUE);
1623 EnableDlgItem(IDC_ROTATE_STEP, TRUE);
1624 } else {
1625 EnableDlgItem(IDC_ROTATE_SIZE_TEXT, FALSE);
1626 EnableDlgItem(IDC_ROTATE_SIZE, FALSE);
1627 EnableDlgItem(IDC_ROTATE_SIZE_TYPE, FALSE);
1628 EnableDlgItem(IDC_ROTATE_STEP_TEXT, FALSE);
1629 EnableDlgItem(IDC_ROTATE_STEP, FALSE);
1630 }
1631
1632 }
1633 return TRUE;
1634
1635 case IDC_OPT_BINARY | (BN_CLICKED << 16):
1636 {
1637 if (GetCheck(IDC_OPT_BINARY)) {
1638 EnableDlgItem(IDC_OPT_PLAINTEXT, FALSE);
1639 EnableDlgItem(IDC_OPT_TIMESTAMP, FALSE);
1640 EnableDlgItem(IDC_OPT_TIMESTAMP_TYPE, FALSE);
1641 } else {
1642 EnableDlgItem(IDC_OPT_PLAINTEXT, TRUE);
1643 EnableDlgItem(IDC_OPT_TIMESTAMP, TRUE);
1644
1645 if (GetCheck(IDC_OPT_TIMESTAMP)) {
1646 EnableDlgItem(IDC_OPT_TIMESTAMP_TYPE, TRUE);
1647 }
1648 }
1649 }
1650 return TRUE;
1651
1652 case IDC_OPT_TIMESTAMP | (BN_CLICKED << 16):
1653 {
1654 if (GetCheck(IDC_OPT_TIMESTAMP)) {
1655 EnableDlgItem(IDC_OPT_TIMESTAMP_TYPE, TRUE);
1656 } else {
1657 EnableDlgItem(IDC_OPT_TIMESTAMP_TYPE, FALSE);
1658 }
1659 }
1660 return TRUE;
1661
1662 case IDC_DEFAULTNAME_EDITOR | (CBN_SELCHANGE << 16) :
1663 case IDC_DEFAULTNAME_EDITOR | (CBN_EDITCHANGE << 16):
1664 case IDC_DEFAULTNAME_EDITOR | (CBN_CLOSEUP << 16):
1665 case IDC_DEFAULTNAME_EDITOR | (CBN_SETFOCUS << 16): {
1666 wchar_t *format = NULL;
1667 if (wParam == (IDC_DEFAULTNAME_EDITOR | (CBN_SELCHANGE << 16))) {
1668 LRESULT r = SendDlgItemMessageW(IDC_DEFAULTNAME_EDITOR, CB_GETCURSEL, 0, 0);
1669 if (r != CB_ERR) {
1670 LRESULT len = SendDlgItemMessageW(IDC_DEFAULTNAME_EDITOR, CB_GETLBTEXTLEN, r, 0);
1671 format = (wchar_t*)malloc((len + 1) * sizeof(wchar_t));
1672 SendDlgItemMessageW(IDC_DEFAULTNAME_EDITOR, CB_GETLBTEXT, r, (LPARAM)format);
1673 }
1674 }
1675 if (format == NULL) {
1676 hGetDlgItemTextW(m_hWnd, IDC_DEFAULTNAME_EDITOR, &format);
1677 }
1678 wchar_t *preview = MakePreviewStr(format, ts.UILanguageFileW);
1679 if (preview[0] != 0 && wcscmp(format, preview) != 0) {
1680 RECT rc;
1681 ::GetWindowRect(::GetDlgItem(m_hWnd, IDC_DEFAULTNAME_EDITOR), &rc);
1682 m_TipWin->SetText(preview);
1683 m_TipWin->SetPos(rc.left, rc.bottom);
1684 m_TipWin->SetHideTimer(5 * 1000); // �\������
1685 if (!m_TipWin->IsVisible()) {
1686 m_TipWin->SetVisible(TRUE);
1687 }
1688 }
1689 else {
1690 m_TipWin->SetVisible(FALSE);
1691 }
1692 free(preview);
1693 free(format);
1694 return TRUE;
1695 }
1696
1697 case IDC_DEFAULTNAME_EDITOR | (CBN_KILLFOCUS << 16): {
1698 if (m_TipWin->IsVisible()) {
1699 m_TipWin->SetVisible(FALSE);
1700 }
1701 return TRUE;
1702 }
1703 }
1704
1705 return TTCPropertyPage::OnCommand(wParam, lParam);
1706 }
1707
1708 void CLogPropPageDlg::OnOKLogFilename()
1709 {
1710 wchar_t *def_name;
1711 time_t time_local;
1712 struct tm tm_local;
1713
1714 hGetDlgItemTextW(m_hWnd, IDC_DEFAULTNAME_EDITOR, &def_name);
1715 if (isInvalidStrftimeCharW(def_name)) {
1716 static const TTMessageBoxInfoW info = {
1717 "Tera Term",
1718 "MSG_ERROR", L"ERROR",
1719 "MSG_LOGFILE_INVALID_CHAR_ERROR", L"Invalid character is included in log file name.",
1720 MB_ICONEXCLAMATION };
1721 TTMessageBoxW(m_hWnd, &info, ts.UILanguageFileW);
1722 return;
1723 }
1724
1725 // ��������������
1726 time(&time_local);
1727 localtime_s(&tm_local, & time_local);
1728 // ����������������
1729 wchar_t buf2[MAX_PATH];
1730 if (wcslen(def_name) != 0 && wcsftime(buf2, _countof(buf2), def_name, &tm_local) == 0) {
1731 static const TTMessageBoxInfoW info = {
1732 "Tera Term",
1733 "MSG_ERROR", L"ERROR",
1734 "MSG_LOGFILE_TOOLONG_ERROR", L"The log file name is too long.",
1735 MB_ICONEXCLAMATION };
1736 TTMessageBoxW(m_hWnd, &info, ts.UILanguageFileW);
1737 free(def_name);
1738 return;
1739 }
1740
1741 wchar_t *buf3 = replaceInvalidFileNameCharW(buf2, '_');
1742
1743 if (isInvalidFileNameCharW(buf3)) {
1744 static const TTMessageBoxInfoW info = {
1745 "Tera Term",
1746 "MSG_ERROR", L"ERROR",
1747 "MSG_LOGFILE_INVALID_CHAR_ERROR", L"Invalid character is included in log file name.",
1748 MB_ICONEXCLAMATION };
1749 TTMessageBoxW(m_hWnd, &info, ts.UILanguageFileW);
1750 free(def_name);
1751 free(buf3);
1752 return;
1753 }
1754
1755 free(ts.LogDefaultNameW);
1756 ts.LogDefaultNameW = def_name;
1757 free(buf3);
1758 }
1759
1760 void CLogPropPageDlg::OnOK()
1761 {
1762 // Viewlog Editor path (2005.1.29 yutaka)
1763 GetDlgItemTextA(IDC_VIEWLOG_EDITOR, ts.ViewlogEditor, _countof(ts.ViewlogEditor));
1764
1765 // Log Default File Name
1766 OnOKLogFilename();
1767
1768 // Log Default File Path (2007.5.30 maya)
1769 free(ts.LogDefaultPathW);
1770 hGetDlgItemTextW(m_hWnd, IDC_DEFAULTPATH_EDITOR, &ts.LogDefaultPathW);
1771
1772 /* Auto start logging (2007.5.31 maya) */
1773 ts.LogAutoStart = GetCheck(IDC_AUTOSTART);
1774
1775 /* Log Rotate */
1776 if (GetCheck(IDC_LOG_ROTATE)) { /* on */
1777 char buf[80];
1778 ts.LogRotate = ROTATE_SIZE;
1779 GetDlgItemTextA(IDC_ROTATE_SIZE_TYPE, buf, _countof(buf));
1780 ts.LogRotateSizeType = 0;
1781 for (int i = 0 ; i < LOG_ROTATE_SIZETYPE_NUM ; i++) {
1782 if (strcmp(buf, LogRotateSizeType[i]) == 0) {
1783 ts.LogRotateSizeType = i;
1784 break;
1785 }
1786 }
1787 ts.LogRotateSize = GetDlgItemInt(IDC_ROTATE_SIZE);
1788 for (int i = 0 ; i < ts.LogRotateSizeType ; i++)
1789 ts.LogRotateSize *= 1024;
1790
1791 ts.LogRotateStep = GetDlgItemInt(IDC_ROTATE_STEP);
1792
1793 } else { /* off */
1794 ts.LogRotate = ROTATE_NONE;
1795 /* �c���������o�[�����}�I���������c���B*/
1796 }
1797
1798 // Log Options
1799 if (GetCheck(IDC_OPT_BINARY)) {
1800 ts.LogBinary = 1;
1801 }
1802 else {
1803 ts.LogBinary = 0;
1804 }
1805
1806 if (GetCheck(IDC_OPT_APPEND)) {
1807 ts.Append = 1;
1808 }
1809 else {
1810 ts.Append = 0;
1811 }
1812
1813 if (GetCheck(IDC_OPT_PLAINTEXT)) {
1814 ts.LogTypePlainText = 1;
1815 }
1816 else {
1817 ts.LogTypePlainText = 0;
1818 }
1819
1820 if (GetCheck(IDC_OPT_HIDEDLG)) {
1821 ts.LogHideDialog = 1;
1822 }
1823 else {
1824 ts.LogHideDialog = 0;
1825 }
1826
1827 if (GetCheck(IDC_OPT_INCBUF)) {
1828 ts.LogAllBuffIncludedInFirst = 1;
1829 }
1830 else {
1831 ts.LogAllBuffIncludedInFirst = 0;
1832 }
1833
1834 if (GetCheck(IDC_OPT_TIMESTAMP)) {
1835 ts.LogTimestamp = 1;
1836 }
1837 else {
1838 ts.LogTimestamp = 0;
1839 }
1840
1841 ts.LogTimestampType = GetCurSel(IDC_OPT_TIMESTAMP_TYPE);
1842 }
1843
1844 void CLogPropPageDlg::OnHelp()
1845 {
1846 PostMessage(HVTWin, WM_USER_DLGHELP2, HlpMenuSetupAdditionalLog, 0);
1847 }
1848
1849 /////////////////////////////
1850 // cygterm.cfg ��������
1851
1852 #define CYGTERM_FILE "cygterm.cfg" // CygTerm configuration file
1853 #define CYGTERM_FILE_MAXLINE 100
1854
1855 void ReadCygtermConfFile(const char *homedir, cygterm_t *psettings)
1856 {
1857 const char *cfgfile = CYGTERM_FILE; // CygTerm configuration file
1858 char cfg[MAX_PATH];
1859 FILE *fp;
1860 char buf[256], *head, *body;
1861 cygterm_t settings;
1862
1863 // try to read CygTerm config file
1864 memset(&settings, 0, sizeof(settings));
1865 _snprintf_s(settings.term, sizeof(settings.term), _TRUNCATE, "ttermpro.exe %%s %%d /E /KR=UTF8 /KT=UTF8 /VTICON=CygTerm /nossh");
1866 _snprintf_s(settings.term_type, sizeof(settings.term_type), _TRUNCATE, "vt100");
1867 _snprintf_s(settings.port_start, sizeof(settings.port_start), _TRUNCATE, "20000");
1868 _snprintf_s(settings.port_range, sizeof(settings.port_range), _TRUNCATE, "40");
1869 _snprintf_s(settings.shell, sizeof(settings.shell), _TRUNCATE, "auto");
1870 _snprintf_s(settings.env1, sizeof(settings.env1), _TRUNCATE, "");
1871 _snprintf_s(settings.env2, sizeof(settings.env2), _TRUNCATE, "");
1872 settings.login_shell = FALSE;
1873 settings.home_chdir = FALSE;
1874 settings.agent_proxy = FALSE;
1875
1876 strncpy_s(cfg, sizeof(cfg), homedir, _TRUNCATE);
1877 AppendSlash(cfg, sizeof(cfg));
1878 strncat_s(cfg, sizeof(cfg), cfgfile, _TRUNCATE);
1879
1880 fp = fopen(cfg, "r");
1881 if (fp != NULL) {
1882 while (fgets(buf, sizeof(buf), fp) != NULL) {
1883 size_t len = strlen(buf);
1884
1885 if (buf[len - 1] == '\n')
1886 buf[len - 1] = '\0';
1887
1888 split_buffer(buf, '=', &head, &body);
1889 if (head == NULL || body == NULL)
1890 continue;
1891
1892 if (_stricmp(head, "TERM") == 0) {
1893 _snprintf_s(settings.term, sizeof(settings.term), _TRUNCATE, "%s", body);
1894
1895 }
1896 else if (_stricmp(head, "TERM_TYPE") == 0) {
1897 _snprintf_s(settings.term_type, sizeof(settings.term_type), _TRUNCATE, "%s", body);
1898
1899 }
1900 else if (_stricmp(head, "PORT_START") == 0) {
1901 _snprintf_s(settings.port_start, sizeof(settings.port_start), _TRUNCATE, "%s", body);
1902
1903 }
1904 else if (_stricmp(head, "PORT_RANGE") == 0) {
1905 _snprintf_s(settings.port_range, sizeof(settings.port_range), _TRUNCATE, "%s", body);
1906
1907 }
1908 else if (_stricmp(head, "SHELL") == 0) {
1909 _snprintf_s(settings.shell, sizeof(settings.shell), _TRUNCATE, "%s", body);
1910
1911 }
1912 else if (_stricmp(head, "ENV_1") == 0) {
1913 _snprintf_s(settings.env1, sizeof(settings.env1), _TRUNCATE, "%s", body);
1914
1915 }
1916 else if (_stricmp(head, "ENV_2") == 0) {
1917 _snprintf_s(settings.env2, sizeof(settings.env2), _TRUNCATE, "%s", body);
1918
1919 }
1920 else if (_stricmp(head, "LOGIN_SHELL") == 0) {
1921 if (strchr("YyTt", *body)) {
1922 settings.login_shell = TRUE;
1923 }
1924
1925 }
1926 else if (_stricmp(head, "HOME_CHDIR") == 0) {
1927 if (strchr("YyTt", *body)) {
1928 settings.home_chdir = TRUE;
1929 }
1930
1931 }
1932 else if (_stricmp(head, "SSH_AGENT_PROXY") == 0) {
1933 if (strchr("YyTt", *body)) {
1934 settings.agent_proxy = TRUE;
1935 }
1936
1937 }
1938 else {
1939 // TODO: error check
1940
1941 }
1942 }
1943 fclose(fp);
1944 }
1945
1946 memcpy(psettings, &settings, sizeof(cygterm_t));
1947 }
1948
1949 BOOL WriteCygtermConfFile(const char *homedir, cygterm_t *psettings)
1950 {
1951 const char *cfgfile = CYGTERM_FILE; // CygTerm configuration file
1952 const char *tmpfile = "cygterm.tmp";
1953 char cfg[MAX_PATH];
1954 char tmp[MAX_PATH];
1955 FILE *fp;
1956 FILE *tmp_fp;
1957 char buf[256], *head, *body;
1958 cygterm_t settings;
1959 char *line[CYGTERM_FILE_MAXLINE];
1960 int i, linenum;
1961
1962 memcpy(&settings, psettings, sizeof(cygterm_t));
1963
1964 strncpy_s(cfg, sizeof(cfg), homedir, _TRUNCATE);
1965 AppendSlash(cfg, sizeof(cfg));
1966 strncat_s(cfg, sizeof(cfg), cfgfile, _TRUNCATE);
1967
1968 strncpy_s(tmp, sizeof(tmp), homedir, _TRUNCATE);
1969 AppendSlash(tmp, sizeof(tmp));
1970 strncat_s(tmp, sizeof(tmp), tmpfile, _TRUNCATE);
1971
1972 // cygterm.cfg �������������A�������������������������������B
1973 memset(line, 0, sizeof(line));
1974 linenum = 0;
1975 fp = fopen(cfg, "r");
1976 if (fp) {
1977 i = 0;
1978 while (fgets(buf, sizeof(buf), fp) != NULL) {
1979 size_t len = strlen(buf);
1980 if (buf[len - 1] == '\n')
1981 buf[len - 1] = '\0';
1982 if (i < CYGTERM_FILE_MAXLINE)
1983 line[i++] = _strdup(buf);
1984 else
1985 break;
1986 }
1987 linenum = i;
1988 fclose(fp);
1989 }
1990
1991 tmp_fp = fopen(cfg, "w");
1992 if (tmp_fp == NULL) {
1993 return FALSE;
1994 }
1995 else {
1996 if (linenum > 0) {
1997 for (i = 0; i < linenum; i++) {
1998 split_buffer(line[i], '=', &head, &body);
1999 if (head == NULL || body == NULL) {
2000 fprintf(tmp_fp, "%s\n", line[i]);
2001 }
2002 else if (_stricmp(head, "TERM") == 0) {
2003 fprintf(tmp_fp, "TERM = %s\n", settings.term);
2004 settings.term[0] = '\0';
2005 }
2006 else if (_stricmp(head, "TERM_TYPE") == 0) {
2007 fprintf(tmp_fp, "TERM_TYPE = %s\n", settings.term_type);
2008 settings.term_type[0] = '\0';
2009 }
2010 else if (_stricmp(head, "PORT_START") == 0) {
2011 fprintf(tmp_fp, "PORT_START = %s\n", settings.port_start);
2012 settings.port_start[0] = '\0';
2013 }
2014 else if (_stricmp(head, "PORT_RANGE") == 0) {
2015 fprintf(tmp_fp, "PORT_RANGE = %s\n", settings.port_range);
2016 settings.port_range[0] = '\0';
2017 }
2018 else if (_stricmp(head, "SHELL") == 0) {
2019 fprintf(tmp_fp, "SHELL = %s\n", settings.shell);
2020 settings.shell[0] = '\0';
2021 }
2022 else if (_stricmp(head, "ENV_1") == 0) {
2023 fprintf(tmp_fp, "ENV_1 = %s\n", settings.env1);
2024 settings.env1[0] = '\0';
2025 }
2026 else if (_stricmp(head, "ENV_2") == 0) {
2027 fprintf(tmp_fp, "ENV_2 = %s\n", settings.env2);
2028 settings.env2[0] = '\0';
2029 }
2030 else if (_stricmp(head, "LOGIN_SHELL") == 0) {
2031 fprintf(tmp_fp, "LOGIN_SHELL = %s\n", (settings.login_shell == TRUE) ? "yes" : "no");
2032 settings.login_shell = FALSE;
2033 }
2034 else if (_stricmp(head, "HOME_CHDIR") == 0) {
2035 fprintf(tmp_fp, "HOME_CHDIR = %s\n", (settings.home_chdir == TRUE) ? "yes" : "no");
2036 settings.home_chdir = FALSE;
2037 }
2038 else if (_stricmp(head, "SSH_AGENT_PROXY") == 0) {
2039 fprintf(tmp_fp, "SSH_AGENT_PROXY = %s\n", (settings.agent_proxy == TRUE) ? "yes" : "no");
2040 settings.agent_proxy = FALSE;
2041 }
2042 else {
2043 fprintf(tmp_fp, "%s = %s\n", head, body);
2044 }
2045 }
2046 }
2047 else {
2048 fputs("# CygTerm setting\n", tmp_fp);
2049 fputs("\n", tmp_fp);
2050 }
2051 if (settings.term[0] != '\0') {
2052 fprintf(tmp_fp, "TERM = %s\n", settings.term);
2053 }
2054 if (settings.term_type[0] != '\0') {
2055 fprintf(tmp_fp, "TERM_TYPE = %s\n", settings.term_type);
2056 }
2057 if (settings.port_start[0] != '\0') {
2058 fprintf(tmp_fp, "PORT_START = %s\n", settings.port_start);
2059 }
2060 if (settings.port_range[0] != '\0') {
2061 fprintf(tmp_fp, "PORT_RANGE = %s\n", settings.port_range);
2062 }
2063 if (settings.shell[0] != '\0') {
2064 fprintf(tmp_fp, "SHELL = %s\n", settings.shell);
2065 }
2066 if (settings.env1[0] != '\0') {
2067 fprintf(tmp_fp, "ENV_1 = %s\n", settings.env1);
2068 }
2069 if (settings.env2[0] != '\0') {
2070 fprintf(tmp_fp, "ENV_2 = %s\n", settings.env2);
2071 }
2072 if (settings.login_shell) {
2073 fprintf(tmp_fp, "LOGIN_SHELL = yes\n");
2074 }
2075 if (settings.home_chdir) {
2076 fprintf(tmp_fp, "HOME_CHDIR = yes\n");
2077 }
2078 if (settings.agent_proxy) {
2079 fprintf(tmp_fp, "SSH_AGENT_PROXY = yes\n");
2080 }
2081 fclose(tmp_fp);
2082
2083 // �_�C���N�g���t�@�C���������������������������A���L�������s�v�B
2084 #if 0
2085 if (remove(cfg) != 0 && errno != ENOENT) {
2086 get_lang_msg("MSG_ERROR", uimsg, sizeof(uimsg), "ERROR", ts->UILanguageFile);
2087 get_lang_msg("MSG_CYGTERM_CONF_REMOVEFILE_ERROR", ts->UIMsg, sizeof(ts->UIMsg),
2088 "Can't remove old CygTerm configuration file (%d).", ts->UILanguageFile);
2089 _snprintf_s(buf, sizeof(buf), _TRUNCATE, ts->UIMsg, GetLastError());
2090 MessageBox(NULL, buf, uimsg, MB_ICONEXCLAMATION);
2091 }
2092 else if (rename(tmp, cfg) != 0) {
2093 get_lang_msg("MSG_ERROR", uimsg, sizeof(uimsg), "ERROR", ts->UILanguageFile);
2094 get_lang_msg("MSG_CYGTERM_CONF_RENAMEFILE_ERROR", ts->UIMsg, sizeof(ts->UIMsg),
2095 "Can't rename CygTerm configuration file (%d).", ts->UILanguageFile);
2096 _snprintf_s(buf, sizeof(buf), _TRUNCATE, ts->UIMsg, GetLastError());
2097 MessageBox(NULL, buf, uimsg, MB_ICONEXCLAMATION);
2098 }
2099 else {
2100 // cygterm.cfg �t�@�C�����������������������A���b�Z�[�W�_�C�A���O���\�������B
2101 // �������ASave setup�����s�����K�v�������������������N�����B
2102 // (2012.5.1 yutaka)
2103 // Save setup ���s�����ACygTerm�������������������������������������A
2104 // �_�C�A���O�\�����s�v�����������A���������B
2105 // (2015.11.12 yutaka)
2106 get_lang_msg("MSG_TT_NOTICE", uimsg, sizeof(uimsg), "MSG_TT_NOTICE", ts->UILanguageFile);
2107 get_lang_msg("MSG_CYGTERM_CONF_SAVED_NOTICE", ts->UIMsg, sizeof(ts->UIMsg),
2108 "%s has been saved. Do not do save setup.", ts->UILanguageFile);
2109 _snprintf_s(buf, sizeof(buf), _TRUNCATE, ts->UIMsg, CYGTERM_FILE);
2110 MessageBox(NULL, buf, uimsg, MB_OK | MB_ICONINFORMATION);
2111 }
2112 #endif
2113 }
2114
2115 // �Y�������������t���[���������B
2116 for (i = 0; i < linenum; i++) {
2117 free(line[i]);
2118 }
2119
2120 return TRUE;
2121 }
2122
2123 /////////////////////////////
2124
2125 // CCygwinPropPageDlg �_�C�A���O
2126
2127 CCygwinPropPageDlg::CCygwinPropPageDlg(HINSTANCE inst)
2128 : TTCPropertyPage(inst, CCygwinPropPageDlg::IDD)
2129 {
2130 wchar_t *UIMsg;
2131 GetI18nStrWW("Tera Term", "DLG_TABSHEET_TITLE_CYGWIN",
2132 L"Cygwin", ts.UILanguageFileW, &UIMsg);
2133 m_psp.pszTitle = UIMsg;
2134 m_psp.dwFlags |= (PSP_USETITLE | PSP_HASHELP);
2135 }
2136
2137 CCygwinPropPageDlg::~CCygwinPropPageDlg()
2138 {
2139 free((void *)m_psp.pszTitle);
2140 }
2141
2142 // CCygwinPropPageDlg ���b�Z�[�W �n���h��
2143
2144 void CCygwinPropPageDlg::OnInitDialog()
2145 {
2146 TTCPropertyPage::OnInitDialog();
2147
2148 static const DlgTextInfo TextInfos[] = {
2149 { IDC_CYGWIN_PATH_LABEL, "DLG_TAB_CYGWIN_PATH" }
2150 };
2151 SetDlgTextsW(m_hWnd, TextInfos, _countof(TextInfos), ts.UILanguageFileW);
2152
2153 ReadCygtermConfFile(ts.HomeDir, &settings);
2154
2155 SetDlgItemTextA(IDC_TERM_EDIT, settings.term);
2156 SetDlgItemTextA(IDC_TERM_TYPE, settings.term_type);
2157 SetDlgItemTextA(IDC_PORT_START, settings.port_start);
2158 SetDlgItemTextA(IDC_PORT_RANGE, settings.port_range);
2159 SetDlgItemTextA(IDC_SHELL, settings.shell);
2160 SetDlgItemTextA(IDC_ENV1, settings.env1);
2161 SetDlgItemTextA(IDC_ENV2, settings.env2);
2162
2163 SetCheck(IDC_LOGIN_SHELL, settings.login_shell);
2164 SetCheck(IDC_HOME_CHDIR, settings.home_chdir);
2165 SetCheck(IDC_AGENT_PROXY, settings.agent_proxy);
2166
2167 // Cygwin install path
2168 SetDlgItemTextA(IDC_CYGWIN_PATH, ts.CygwinDirectory);
2169
2170 // �_�C�A���O���t�H�[�J�X��������
2171 ::SetFocus(::GetDlgItem(GetSafeHwnd(), IDC_CYGWIN_PATH));
2172 }
2173
2174 BOOL CCygwinPropPageDlg::OnCommand(WPARAM wParam, LPARAM lParam)
2175 {
2176 switch (wParam) {
2177 case IDC_SELECT_FILE | (BN_CLICKED << 16):
2178 // Cygwin install �f�B���N�g�����I���_�C�A���O
2179 wchar_t *title = TTGetLangStrW("Tera Term", "DIRDLG_CYGTERM_DIR_TITLE", L"Select Cygwin directory", ts.UILanguageFileW);
2180 wchar_t *buf;
2181 hGetDlgItemTextW(m_hWnd, IDC_CYGWIN_PATH, &buf);
2182 wchar_t *path;
2183 if (doSelectFolderW(GetSafeHwnd(), buf, title, &path)) {
2184 SetDlgItemTextW(IDC_CYGWIN_PATH, path);
2185 free(path);
2186 }
2187 free(buf);
2188 free(title);
2189 return TRUE;
2190 }
2191
2192 return TTCPropertyPage::OnCommand(wParam, lParam);
2193 }
2194
2195 /**
2196 * @brief cygterm_t�����r����
2197 * @param a cygterm_t
2198 * @param b cygterm_t
2199 * @retval TRUE ����
2200 * @retval FALSE ������
2201 */
2202 BOOL CmpCygtermConfFile(const cygterm_t *a, const cygterm_t *b)
2203 {
2204 if ((strcmp(a->term, b->term) != 0) ||
2205 (strcmp(a->term_type, b->term_type) != 0) ||
2206 (strcmp(a->port_start, b->port_start) != 0) ||
2207 (strcmp(a->port_range, b->port_range) != 0) ||
2208 (strcmp(a->shell, b->shell) != 0) ||
2209 (strcmp(a->env1, b->env1) != 0) ||
2210 (strcmp(a->env2, b->env2) != 0) ||
2211 (a->login_shell != b->login_shell) ||
2212 (a->home_chdir != b->home_chdir) ||
2213 (a->agent_proxy != b->agent_proxy)) {
2214 return FALSE;
2215 }
2216 return TRUE;
2217 }
2218
2219 void CCygwinPropPageDlg::OnOK()
2220 {
2221 cygterm_t settings_prop;
2222
2223 // �v���p�e�B�[�V�[�g�����l����������
2224 GetDlgItemTextA(IDC_TERM_EDIT, settings_prop.term, sizeof(settings_prop.term));
2225 GetDlgItemTextA(IDC_TERM_TYPE, settings_prop.term_type, sizeof(settings_prop.term_type));
2226 GetDlgItemTextA(IDC_PORT_START, settings_prop.port_start, sizeof(settings_prop.port_start));
2227 GetDlgItemTextA(IDC_PORT_RANGE, settings_prop.port_range, sizeof(settings_prop.port_range));
2228 GetDlgItemTextA(IDC_SHELL, settings_prop.shell, sizeof(settings_prop.shell));
2229 GetDlgItemTextA(IDC_ENV1, settings_prop.env1, sizeof(settings_prop.env1));
2230 GetDlgItemTextA(IDC_ENV2, settings_prop.env2, sizeof(settings_prop.env2));
2231
2232 settings_prop.login_shell = GetCheck(IDC_LOGIN_SHELL);
2233 settings_prop.home_chdir = GetCheck(IDC_HOME_CHDIR);
2234 settings_prop.agent_proxy = GetCheck(IDC_AGENT_PROXY);
2235
2236 // ���X�������������� cygterm.cfg ����������
2237 if (CmpCygtermConfFile(&settings_prop, &settings) == FALSE) {
2238 if (WriteCygtermConfFile(ts.HomeDir, &settings_prop) == FALSE) {
2239 static const TTMessageBoxInfoW info = {
2240 "Tera Term",
2241 "MSG_ERROR", L"ERROR",
2242 "MSG_CYGTERM_CONF_WRITEFILE_ERROR", L"Can't write CygTerm configuration file (%d).",
2243 MB_ICONEXCLAMATION };
2244 DWORD e = GetLastError();
2245 TTMessageBoxW(m_hWnd, &info, ts.UILanguageFileW, e);
2246 }
2247 }
2248
2249 // Cygwin install path
2250 GetDlgItemTextA(IDC_CYGWIN_PATH, ts.CygwinDirectory, sizeof(ts.CygwinDirectory));
2251 }
2252
2253 void CCygwinPropPageDlg::OnHelp()
2254 {
2255 PostMessage(HVTWin, WM_USER_DLGHELP2, HlpMenuSetupAdditional, 0);
2256 }
2257
2258 //////////////////////////////////////////////////////////////////////////////
2259
2260 // CAddSettingPropSheetDlg
2261 CAddSettingPropSheetDlg::CAddSettingPropSheetDlg(HINSTANCE hInstance, HWND hParentWnd):
2262 TTCPropSheetDlg(hInstance, hParentWnd, ts.UILanguageFileW)
2263 {
2264 // CPP,tmfc��TTCPropertyPage�h���N���X��������
2265 int i = 0;
2266 m_Page[i++] = new CGeneralPropPageDlg(hInstance);
2267 m_Page[i++] = new CSequencePropPageDlg(hInstance);
2268 m_Page[i++] = new CCopypastePropPageDlg(hInstance);
2269 m_Page[i++] = new CVisualPropPageDlg(hInstance);
2270 m_Page[i++] = new CLogPropPageDlg(hInstance);
2271 m_Page[i++] = new CCygwinPropPageDlg(hInstance);
2272 if ((GetKeyState(VK_CONTROL) & 0x8000) != 0 ||
2273 (GetKeyState(VK_SHIFT) & 0x8000) != 0 ) {
2274 m_Page[i++] = new CDebugPropPage(hInstance);
2275 }
2276 m_PageCountCPP = i;
2277
2278 HPROPSHEETPAGE page;
2279 for (i = 0; i < m_PageCountCPP; i++) {
2280 page = m_Page[i]->CreatePropertySheetPage();
2281 AddPage(page);
2282 }
2283
2284 // TTCPropertyPage ���g�p������ PropertyPage
2285 page = CodingPageCreate(hInstance, &ts);
2286 AddPage(page);
2287 page = FontPageCreate(hInstance, &ts);
2288 AddPage(page);
2289
2290 wchar_t *title = TTGetLangStrW("Tera Term", "DLG_TABSHEET_TITLE", L"Tera Term: Additional settings", ts.UILanguageFileW);
2291 SetCaption(title);
2292 free(title);
2293 }
2294
2295 CAddSettingPropSheetDlg::~CAddSettingPropSheetDlg()
2296 {
2297 for (int i = 0; i < m_PageCountCPP; i++) {
2298 delete m_Page[i];
2299 }
2300 }
2301
2302 void CAddSettingPropSheetDlg::SetStartPage(Page page)
2303 {
2304 int start_page = page == DefaultPage ? 0: 7;
2305 TTCPropSheetDlg::SetStartPage(start_page);
2306 }
Back to OSDN">Back to OSDN
 ViewVC Help
Powered by ViewVC 1.1.26  
About OSDN
Find Software
Develop Software
Help