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 10443 - (show annotations) (download) (as text)
Thu Dec 29 16:43:20 2022 UTC (15 months, 1 week ago) by zmatsuo
File MIME type: text/x-c++src
File size: 72896 byte(s) 
ログタブの標準ファイル名に設定できない文字があったので修正

- 修正前の動作
  - strftime() で %c %x %X %Z などにファイル名に使えない文字が含まれる時、
  - ダイアログで設定できない
    - OKボタンを押した後エラーが出て設定されない
    - 時間や日付の区切りに':','/'が使われるため(ロケール=日本)
  - 設定ファイル(TERATERM.INI)に直接設定すると使用できる
- ダイアログでのファイル名の判定方法を変更
  - strftime()でフォーマット後に使用できない文字を置換するようにした
  - 日本以外のロケールでも使用できる
- フォーマット後のプレビューを出すようにした
- ダイアログでのファイル名の扱いUnicode化した
- ログファイル名でよく使うと思われるパターンをドロップダウンで選択できるようにした

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