3 static enum { NSSM_TAB_APPLICATION, NSSM_TAB_DETAILS, NSSM_TAB_LOGON, NSSM_TAB_SHUTDOWN, NSSM_TAB_EXIT, NSSM_TAB_IO, NSSM_TAB_ROTATION, NSSM_TAB_ENVIRONMENT, NSSM_NUM_TABS };
\r
4 static HWND tablist[NSSM_NUM_TABS];
\r
5 static int selected_tab;
\r
7 int nssm_gui(int resource, nssm_service_t *service) {
\r
9 HWND dlg = CreateDialogParam(0, MAKEINTRESOURCE(resource), 0, nssm_dlg, (LPARAM) service);
\r
11 popup_message(MB_OK, NSSM_GUI_CREATEDIALOG_FAILED, error_string(GetLastError()));
\r
15 /* Display the window */
\r
17 ShowWindow(dlg, SW_SHOW);
\r
19 /* Set service name if given */
\r
20 if (service->name[0]) {
\r
21 SetDlgItemText(dlg, IDC_NAME, service->name);
\r
22 /* No point making user click remove if the name is already entered */
\r
23 if (resource == IDD_REMOVE) {
\r
24 HWND button = GetDlgItem(dlg, IDC_REMOVE);
\r
26 SendMessage(button, WM_LBUTTONDOWN, 0, 0);
\r
27 SendMessage(button, WM_LBUTTONUP, 0, 0);
\r
34 while (GetMessage(&message, 0, 0, 0)) {
\r
35 if (IsDialogMessage(dlg, &message)) continue;
\r
36 TranslateMessage(&message);
\r
37 DispatchMessage(&message);
\r
40 return (int) message.wParam;
\r
43 void centre_window(HWND window) {
\r
45 RECT size, desktop_size;
\r
48 if (! window) return;
\r
50 /* Find window size */
\r
51 if (! GetWindowRect(window, &size)) return;
\r
53 /* Find desktop window */
\r
54 desktop = GetDesktopWindow();
\r
55 if (! desktop) return;
\r
57 /* Find desktop window size */
\r
58 if (! GetWindowRect(desktop, &desktop_size)) return;
\r
61 x = (desktop_size.right - size.right) / 2;
\r
62 y = (desktop_size.bottom - size.bottom) / 2;
\r
63 MoveWindow(window, x, y, size.right - size.left, size.bottom - size.top, 0);
\r
66 static inline void check_stop_method(nssm_service_t *service, unsigned long method, unsigned long control) {
\r
67 if (SendDlgItemMessage(tablist[NSSM_TAB_SHUTDOWN], control, BM_GETCHECK, 0, 0) & BST_CHECKED) return;
\r
68 service->stop_method &= ~method;
\r
71 static inline void check_number(HWND tab, unsigned long control, unsigned long *timeout) {
\r
73 unsigned long configured = GetDlgItemInt(tab, control, &translated, 0);
\r
74 if (translated) *timeout = configured;
\r
77 static inline void set_timeout_enabled(unsigned long control, unsigned long dependent) {
\r
78 unsigned char enabled = 0;
\r
79 if (SendDlgItemMessage(tablist[NSSM_TAB_SHUTDOWN], control, BM_GETCHECK, 0, 0) & BST_CHECKED) enabled = 1;
\r
80 EnableWindow(GetDlgItem(tablist[NSSM_TAB_SHUTDOWN], dependent), enabled);
\r
83 static inline void set_logon_enabled(unsigned char enabled) {
\r
84 EnableWindow(GetDlgItem(tablist[NSSM_TAB_LOGON], IDC_INTERACT), ! enabled);
\r
85 EnableWindow(GetDlgItem(tablist[NSSM_TAB_LOGON], IDC_USERNAME), enabled);
\r
86 EnableWindow(GetDlgItem(tablist[NSSM_TAB_LOGON], IDC_PASSWORD1), enabled);
\r
87 EnableWindow(GetDlgItem(tablist[NSSM_TAB_LOGON], IDC_PASSWORD2), enabled);
\r
90 static inline void set_rotation_enabled(unsigned char enabled) {
\r
91 EnableWindow(GetDlgItem(tablist[NSSM_TAB_ROTATION], IDC_ROTATE_SECONDS), enabled);
\r
92 EnableWindow(GetDlgItem(tablist[NSSM_TAB_ROTATION], IDC_ROTATE_BYTES_LOW), enabled);
\r
95 static inline void check_io(TCHAR *name, TCHAR *buffer, unsigned long len, unsigned long control) {
\r
96 if (! SendMessage(GetDlgItem(tablist[NSSM_TAB_IO], control), WM_GETTEXTLENGTH, 0, 0)) return;
\r
97 if (GetDlgItemText(tablist[NSSM_TAB_IO], control, buffer, (int) len)) return;
\r
98 popup_message(MB_OK | MB_ICONEXCLAMATION, NSSM_MESSAGE_PATH_TOO_LONG, name);
\r
99 ZeroMemory(buffer, len * sizeof(TCHAR));
\r
102 /* Install the service. */
\r
103 int install(HWND window) {
\r
104 if (! window) return 1;
\r
106 nssm_service_t *service = alloc_nssm_service();
\r
108 set_nssm_service_defaults(service);
\r
110 /* Get service name. */
\r
111 if (! GetDlgItemText(window, IDC_NAME, service->name, _countof(service->name))) {
\r
112 popup_message(MB_OK | MB_ICONEXCLAMATION, NSSM_GUI_MISSING_SERVICE_NAME);
\r
113 cleanup_nssm_service(service);
\r
117 /* Get executable name */
\r
118 if (! GetDlgItemText(tablist[NSSM_TAB_APPLICATION], IDC_PATH, service->exe, _countof(service->exe))) {
\r
119 popup_message(MB_OK | MB_ICONEXCLAMATION, NSSM_GUI_MISSING_PATH);
\r
123 /* Get startup directory. */
\r
124 if (! GetDlgItemText(tablist[NSSM_TAB_APPLICATION], IDC_DIR, service->dir, _countof(service->dir))) {
\r
125 _sntprintf_s(service->dir, _countof(service->dir), _TRUNCATE, _T("%s"), service->exe);
\r
126 strip_basename(service->dir);
\r
130 if (SendMessage(GetDlgItem(tablist[NSSM_TAB_APPLICATION], IDC_FLAGS), WM_GETTEXTLENGTH, 0, 0)) {
\r
131 if (! GetDlgItemText(tablist[NSSM_TAB_APPLICATION], IDC_FLAGS, service->flags, _countof(service->flags))) {
\r
132 popup_message(MB_OK | MB_ICONEXCLAMATION, NSSM_GUI_INVALID_OPTIONS);
\r
138 if (SendMessage(GetDlgItem(tablist[NSSM_TAB_DETAILS], IDC_DISPLAYNAME), WM_GETTEXTLENGTH, 0, 0)) {
\r
139 if (! GetDlgItemText(tablist[NSSM_TAB_DETAILS], IDC_DISPLAYNAME, service->displayname, _countof(service->displayname))) {
\r
140 popup_message(MB_OK | MB_ICONEXCLAMATION, NSSM_GUI_INVALID_DISPLAYNAME);
\r
145 if (SendMessage(GetDlgItem(tablist[NSSM_TAB_DETAILS], IDC_DESCRIPTION), WM_GETTEXTLENGTH, 0, 0)) {
\r
146 if (! GetDlgItemText(tablist[NSSM_TAB_DETAILS], IDC_DESCRIPTION, service->description, _countof(service->description))) {
\r
147 popup_message(MB_OK | MB_ICONEXCLAMATION, NSSM_GUI_INVALID_DESCRIPTION);
\r
152 HWND combo = GetDlgItem(tablist[NSSM_TAB_DETAILS], IDC_STARTUP);
\r
153 service->startup = (unsigned long) SendMessage(combo, CB_GETCURSEL, 0, 0);
\r
154 if (service->startup == CB_ERR) service->startup = 0;
\r
156 /* Get logon stuff. */
\r
157 if (SendDlgItemMessage(tablist[NSSM_TAB_LOGON], IDC_LOCALSYSTEM, BM_GETCHECK, 0, 0) & BST_CHECKED) {
\r
158 if (SendDlgItemMessage(tablist[NSSM_TAB_LOGON], IDC_INTERACT, BM_GETCHECK, 0, 0) & BST_CHECKED) {
\r
159 service->type |= SERVICE_INTERACTIVE_PROCESS;
\r
164 service->usernamelen = SendMessage(GetDlgItem(tablist[NSSM_TAB_LOGON], IDC_USERNAME), WM_GETTEXTLENGTH, 0, 0);
\r
165 if (! service->usernamelen) {
\r
166 popup_message(MB_OK | MB_ICONEXCLAMATION, NSSM_GUI_MISSING_USERNAME);
\r
169 service->usernamelen++;
\r
171 service->username = (TCHAR *) HeapAlloc(GetProcessHeap(), 0, service->usernamelen * sizeof(TCHAR));
\r
172 if (! service->username) {
\r
173 popup_message(MB_OK | MB_ICONEXCLAMATION, NSSM_EVENT_OUT_OF_MEMORY, _T("account name"), _T("install()"));
\r
176 if (! GetDlgItemText(tablist[NSSM_TAB_LOGON], IDC_USERNAME, service->username, (int) service->usernamelen)) {
\r
177 HeapFree(GetProcessHeap(), 0, service->username);
\r
178 service->username = 0;
\r
179 service->usernamelen = 0;
\r
180 popup_message(MB_OK | MB_ICONEXCLAMATION, NSSM_GUI_INVALID_USERNAME);
\r
185 service->passwordlen = SendMessage(GetDlgItem(tablist[NSSM_TAB_LOGON], IDC_PASSWORD1), WM_GETTEXTLENGTH, 0, 0);
\r
186 if (! service->passwordlen) {
\r
187 popup_message(MB_OK | MB_ICONEXCLAMATION, NSSM_GUI_MISSING_PASSWORD);
\r
190 if (SendMessage(GetDlgItem(tablist[NSSM_TAB_LOGON], IDC_PASSWORD2), WM_GETTEXTLENGTH, 0, 0) != service->passwordlen) {
\r
191 popup_message(MB_OK | MB_ICONEXCLAMATION, NSSM_GUI_MISSING_PASSWORD);
\r
194 service->passwordlen++;
\r
196 /* Temporary buffer for password validation. */
\r
197 TCHAR *password = (TCHAR *) HeapAlloc(GetProcessHeap(), 0, service->passwordlen * sizeof(TCHAR));
\r
199 HeapFree(GetProcessHeap(), 0, service->username);
\r
200 service->username = 0;
\r
201 service->usernamelen = 0;
\r
202 popup_message(MB_OK | MB_ICONEXCLAMATION, NSSM_EVENT_OUT_OF_MEMORY, _T("password confirmation"), _T("install()"));
\r
206 /* Actual password buffer. */
\r
207 service->password = (TCHAR *) HeapAlloc(GetProcessHeap(), 0, service->passwordlen * sizeof(TCHAR));
\r
208 if (! service->password) {
\r
209 HeapFree(GetProcessHeap(), 0, password);
\r
210 HeapFree(GetProcessHeap(), 0, service->username);
\r
211 service->username = 0;
\r
212 service->usernamelen = 0;
\r
213 popup_message(MB_OK | MB_ICONEXCLAMATION, NSSM_EVENT_OUT_OF_MEMORY, _T("password"), _T("install()"));
\r
217 /* Get first password. */
\r
218 if (! GetDlgItemText(tablist[NSSM_TAB_LOGON], IDC_PASSWORD1, service->password, (int) service->passwordlen)) {
\r
219 HeapFree(GetProcessHeap(), 0, password);
\r
220 SecureZeroMemory(service->password, service->passwordlen);
\r
221 HeapFree(GetProcessHeap(), 0, service->password);
\r
222 service->password = 0;
\r
223 service->passwordlen = 0;
\r
224 HeapFree(GetProcessHeap(), 0, service->username);
\r
225 service->username = 0;
\r
226 service->usernamelen = 0;
\r
227 popup_message(MB_OK | MB_ICONEXCLAMATION, NSSM_GUI_INVALID_PASSWORD);
\r
231 /* Get confirmation. */
\r
232 if (! GetDlgItemText(tablist[NSSM_TAB_LOGON], IDC_PASSWORD2, password, (int) service->passwordlen)) {
\r
233 SecureZeroMemory(password, service->passwordlen);
\r
234 HeapFree(GetProcessHeap(), 0, password);
\r
235 SecureZeroMemory(service->password, service->passwordlen);
\r
236 HeapFree(GetProcessHeap(), 0, service->password);
\r
237 service->password = 0;
\r
238 service->passwordlen = 0;
\r
239 HeapFree(GetProcessHeap(), 0, service->username);
\r
240 service->username = 0;
\r
241 service->usernamelen = 0;
\r
242 popup_message(MB_OK | MB_ICONEXCLAMATION, NSSM_GUI_INVALID_PASSWORD);
\r
247 if (_tcsncmp(password, service->password, service->passwordlen)) {
\r
248 popup_message(MB_OK | MB_ICONEXCLAMATION, NSSM_GUI_MISSING_PASSWORD);
\r
249 SecureZeroMemory(password, service->passwordlen);
\r
250 HeapFree(GetProcessHeap(), 0, password);
\r
251 SecureZeroMemory(service->password, service->passwordlen);
\r
252 HeapFree(GetProcessHeap(), 0, service->password);
\r
253 service->password = 0;
\r
254 service->passwordlen = 0;
\r
255 HeapFree(GetProcessHeap(), 0, service->username);
\r
256 service->username = 0;
\r
257 service->usernamelen = 0;
\r
262 /* Get stop method stuff. */
\r
263 check_stop_method(service, NSSM_STOP_METHOD_CONSOLE, IDC_METHOD_CONSOLE);
\r
264 check_stop_method(service, NSSM_STOP_METHOD_WINDOW, IDC_METHOD_WINDOW);
\r
265 check_stop_method(service, NSSM_STOP_METHOD_THREADS, IDC_METHOD_THREADS);
\r
266 check_stop_method(service, NSSM_STOP_METHOD_TERMINATE, IDC_METHOD_TERMINATE);
\r
267 check_number(tablist[NSSM_TAB_SHUTDOWN], IDC_KILL_CONSOLE, &service->kill_console_delay);
\r
268 check_number(tablist[NSSM_TAB_SHUTDOWN], IDC_KILL_WINDOW, &service->kill_window_delay);
\r
269 check_number(tablist[NSSM_TAB_SHUTDOWN], IDC_KILL_THREADS, &service->kill_threads_delay);
\r
271 /* Get exit action stuff. */
\r
272 check_number(tablist[NSSM_TAB_EXIT], IDC_THROTTLE, &service->throttle_delay);
\r
273 combo = GetDlgItem(tablist[NSSM_TAB_EXIT], IDC_APPEXIT);
\r
274 service->default_exit_action = (unsigned long) SendMessage(combo, CB_GETCURSEL, 0, 0);
\r
275 if (service->default_exit_action == CB_ERR) service->default_exit_action = 0;
\r
277 /* Get I/O stuff. */
\r
278 check_io(_T("stdin"), service->stdin_path, _countof(service->stdin_path), IDC_STDIN);
\r
279 check_io(_T("stdout"), service->stdout_path, _countof(service->stdout_path), IDC_STDOUT);
\r
280 check_io(_T("stderr"), service->stderr_path, _countof(service->stderr_path), IDC_STDERR);
\r
282 /* Override stdout and/or stderr. */
\r
283 if (SendDlgItemMessage(tablist[NSSM_TAB_ROTATION], IDC_TRUNCATE, BM_GETCHECK, 0, 0) & BST_CHECKED) {
\r
284 if (service->stdout_path[0]) service->stdout_disposition = CREATE_ALWAYS;
\r
285 if (service->stderr_path[0]) service->stderr_disposition = CREATE_ALWAYS;
\r
288 /* Get rotation stuff. */
\r
289 if (SendDlgItemMessage(tablist[NSSM_TAB_ROTATION], IDC_ROTATE, BM_GETCHECK, 0, 0) & BST_CHECKED) {
\r
290 service->rotate_files = true;
\r
291 check_number(tablist[NSSM_TAB_ROTATION], IDC_ROTATE_SECONDS, &service->rotate_seconds);
\r
292 check_number(tablist[NSSM_TAB_ROTATION], IDC_ROTATE_BYTES_LOW, &service->rotate_bytes_low);
\r
295 /* Get environment. */
\r
296 unsigned long envlen = (unsigned long) SendMessage(GetDlgItem(tablist[NSSM_TAB_ENVIRONMENT], IDC_ENVIRONMENT), WM_GETTEXTLENGTH, 0, 0);
\r
298 TCHAR *env = (TCHAR *) HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, (envlen + 2) * sizeof(TCHAR));
\r
300 popup_message(MB_OK | MB_ICONEXCLAMATION, NSSM_EVENT_OUT_OF_MEMORY, _T("environment"), _T("install()"));
\r
301 cleanup_nssm_service(service);
\r
305 if (! GetDlgItemText(tablist[NSSM_TAB_ENVIRONMENT], IDC_ENVIRONMENT, env, envlen + 1)) {
\r
306 popup_message(MB_OK | MB_ICONEXCLAMATION, NSSM_GUI_INVALID_ENVIRONMENT);
\r
307 HeapFree(GetProcessHeap(), 0, env);
\r
308 cleanup_nssm_service(service);
\r
312 /* Strip CR and replace LF with NULL. */
\r
313 unsigned long newlen = 0;
\r
314 unsigned long i, j;
\r
315 for (i = 0; i < envlen; i++) if (env[i] != _T('\r')) newlen++;
\r
316 /* Must end with two NULLs. */
\r
319 TCHAR *newenv = (TCHAR *) HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, newlen * sizeof(TCHAR));
\r
321 HeapFree(GetProcessHeap(), 0, env);
\r
322 popup_message(MB_OK | MB_ICONEXCLAMATION, NSSM_EVENT_OUT_OF_MEMORY, _T("environment"), _T("install()"));
\r
323 cleanup_nssm_service(service);
\r
327 for (i = 0, j = 0; i < envlen; i++) {
\r
328 if (env[i] == _T('\r')) continue;
\r
329 if (env[i] == _T('\n')) newenv[j] = _T('\0');
\r
330 else newenv[j] = env[i];
\r
334 HeapFree(GetProcessHeap(), 0, env);
\r
338 /* Test the environment is valid. */
\r
339 if (test_environment(env)) {
\r
340 popup_message(MB_OK | MB_ICONEXCLAMATION, NSSM_GUI_INVALID_ENVIRONMENT);
\r
341 HeapFree(GetProcessHeap(), 0, env);
\r
342 cleanup_nssm_service(service);
\r
346 if (SendDlgItemMessage(tablist[NSSM_TAB_ENVIRONMENT], IDC_ENVIRONMENT_REPLACE, BM_GETCHECK, 0, 0) & BST_CHECKED) {
\r
347 service->env = env;
\r
348 service->envlen = envlen;
\r
351 service->env_extra = env;
\r
352 service->env_extralen = envlen;
\r
357 /* See if it works. */
\r
358 switch (install_service(service)) {
\r
360 popup_message(MB_OK | MB_ICONEXCLAMATION, NSSM_EVENT_OUT_OF_MEMORY, _T("service"), _T("install()"));
\r
361 cleanup_nssm_service(service);
\r
365 popup_message(MB_OK | MB_ICONEXCLAMATION, NSSM_MESSAGE_OPEN_SERVICE_MANAGER_FAILED);
\r
366 cleanup_nssm_service(service);
\r
370 popup_message(MB_OK | MB_ICONEXCLAMATION, NSSM_MESSAGE_PATH_TOO_LONG, NSSM);
\r
371 cleanup_nssm_service(service);
\r
375 popup_message(MB_OK | MB_ICONEXCLAMATION, NSSM_GUI_OUT_OF_MEMORY_FOR_IMAGEPATH);
\r
376 cleanup_nssm_service(service);
\r
380 popup_message(MB_OK | MB_ICONEXCLAMATION, NSSM_GUI_INSTALL_SERVICE_FAILED);
\r
381 cleanup_nssm_service(service);
\r
385 popup_message(MB_OK | MB_ICONEXCLAMATION, NSSM_GUI_CREATE_PARAMETERS_FAILED);
\r
386 cleanup_nssm_service(service);
\r
390 popup_message(MB_OK, NSSM_MESSAGE_SERVICE_INSTALLED, service->name);
\r
391 cleanup_nssm_service(service);
\r
395 /* Remove the service */
\r
396 int remove(HWND window) {
\r
397 if (! window) return 1;
\r
399 /* See if it works */
\r
400 nssm_service_t *service = alloc_nssm_service();
\r
402 /* Get service name */
\r
403 if (! GetDlgItemText(window, IDC_NAME, service->name, _countof(service->name))) {
\r
404 popup_message(MB_OK | MB_ICONEXCLAMATION, NSSM_GUI_MISSING_SERVICE_NAME);
\r
405 cleanup_nssm_service(service);
\r
410 if (popup_message(MB_YESNO, NSSM_GUI_ASK_REMOVE_SERVICE, service->name) != IDYES) {
\r
411 cleanup_nssm_service(service);
\r
416 switch (remove_service(service)) {
\r
418 popup_message(MB_OK | MB_ICONEXCLAMATION, NSSM_EVENT_OUT_OF_MEMORY, _T("service"), _T("remove()"));
\r
419 cleanup_nssm_service(service);
\r
423 popup_message(MB_OK | MB_ICONEXCLAMATION, NSSM_MESSAGE_OPEN_SERVICE_MANAGER_FAILED);
\r
424 cleanup_nssm_service(service);
\r
428 popup_message(MB_OK | MB_ICONEXCLAMATION, NSSM_GUI_SERVICE_NOT_INSTALLED);
\r
430 cleanup_nssm_service(service);
\r
433 popup_message(MB_OK | MB_ICONEXCLAMATION, NSSM_GUI_REMOVE_SERVICE_FAILED);
\r
434 cleanup_nssm_service(service);
\r
438 popup_message(MB_OK, NSSM_MESSAGE_SERVICE_REMOVED, service->name);
\r
439 cleanup_nssm_service(service);
\r
443 static TCHAR *browse_filter(int message) {
\r
445 case NSSM_GUI_BROWSE_FILTER_APPLICATIONS: return _T("*.exe;*.bat;*.cmd");
\r
446 case NSSM_GUI_BROWSE_FILTER_DIRECTORIES: return _T(".");
\r
447 case NSSM_GUI_BROWSE_FILTER_ALL_FILES: /* Fall through. */
\r
448 default: return _T("*.*");
\r
452 UINT_PTR CALLBACK browse_hook(HWND dlg, UINT message, WPARAM w, LPARAM l) {
\r
454 case WM_INITDIALOG:
\r
461 /* Browse for application */
\r
462 void browse(HWND window, TCHAR *current, unsigned long flags, ...) {
\r
463 if (! window) return;
\r
466 size_t bufsize = 256;
\r
467 size_t len = bufsize;
\r
471 ZeroMemory(&ofn, sizeof(ofn));
\r
472 ofn.lStructSize = sizeof(ofn);
\r
473 ofn.lpstrFilter = (TCHAR *) HeapAlloc(GetProcessHeap(), 0, bufsize * sizeof(TCHAR));
\r
474 /* XXX: Escaping nulls with FormatMessage is tricky */
\r
475 if (ofn.lpstrFilter) {
\r
476 ZeroMemory((void *) ofn.lpstrFilter, bufsize);
\r
478 /* "Applications" + NULL + "*.exe" + NULL */
\r
479 va_start(arg, flags);
\r
480 while (i = va_arg(arg, int)) {
\r
481 TCHAR *localised = message_string(i);
\r
482 _sntprintf_s((TCHAR *) ofn.lpstrFilter + len, bufsize, _TRUNCATE, localised);
\r
483 len += _tcslen(localised) + 1;
\r
484 LocalFree(localised);
\r
485 TCHAR *filter = browse_filter(i);
\r
486 _sntprintf_s((TCHAR *) ofn.lpstrFilter + len, bufsize - len, _TRUNCATE, _T("%s"), filter);
\r
487 len += _tcslen(filter) + 1;
\r
490 /* Remainder of the buffer is already zeroed */
\r
492 ofn.lpstrFile = new TCHAR[MAX_PATH];
\r
493 if (flags & OFN_NOVALIDATE) {
\r
494 /* Directory hack. */
\r
495 _sntprintf_s(ofn.lpstrFile, MAX_PATH, _TRUNCATE, _T(":%s:"), message_string(NSSM_GUI_BROWSE_FILTER_DIRECTORIES));
\r
497 else _sntprintf_s(ofn.lpstrFile, MAX_PATH, _TRUNCATE, _T("%s"), current);
\r
498 ofn.lpstrTitle = message_string(NSSM_GUI_BROWSE_TITLE);
\r
499 ofn.nMaxFile = MAX_PATH;
\r
500 ofn.Flags = OFN_EXPLORER | OFN_HIDEREADONLY | OFN_PATHMUSTEXIST | flags;
\r
502 if (GetOpenFileName(&ofn)) {
\r
503 /* Directory hack. */
\r
504 if (flags & OFN_NOVALIDATE) strip_basename(ofn.lpstrFile);
\r
505 SendMessage(window, WM_SETTEXT, 0, (LPARAM) ofn.lpstrFile);
\r
507 if (ofn.lpstrFilter) HeapFree(GetProcessHeap(), 0, (void *) ofn.lpstrFilter);
\r
509 delete[] ofn.lpstrFile;
\r
512 INT_PTR CALLBACK tab_dlg(HWND tab, UINT message, WPARAM w, LPARAM l) {
\r
514 case WM_INITDIALOG:
\r
517 /* Button was pressed or control was controlled. */
\r
520 TCHAR buffer[MAX_PATH];
\r
521 unsigned char enabled;
\r
523 switch (LOWORD(w)) {
\r
524 /* Browse for application. */
\r
526 dlg = GetDlgItem(tab, IDC_PATH);
\r
527 GetDlgItemText(tab, IDC_PATH, buffer, _countof(buffer));
\r
528 browse(dlg, buffer, OFN_FILEMUSTEXIST, NSSM_GUI_BROWSE_FILTER_APPLICATIONS, NSSM_GUI_BROWSE_FILTER_ALL_FILES, 0);
\r
529 /* Fill in startup directory if it wasn't already specified. */
\r
530 GetDlgItemText(tab, IDC_DIR, buffer, _countof(buffer));
\r
532 GetDlgItemText(tab, IDC_PATH, buffer, _countof(buffer));
\r
533 strip_basename(buffer);
\r
534 SetDlgItemText(tab, IDC_DIR, buffer);
\r
538 /* Browse for startup directory. */
\r
539 case IDC_BROWSE_DIR:
\r
540 dlg = GetDlgItem(tab, IDC_DIR);
\r
541 GetDlgItemText(tab, IDC_DIR, buffer, _countof(buffer));
\r
542 browse(dlg, buffer, OFN_NOVALIDATE, NSSM_GUI_BROWSE_FILTER_DIRECTORIES, 0);
\r
546 case IDC_LOCALSYSTEM:
\r
547 set_logon_enabled(0);
\r
551 set_logon_enabled(1);
\r
554 /* Shutdown methods. */
\r
555 case IDC_METHOD_CONSOLE:
\r
556 set_timeout_enabled(LOWORD(w), IDC_KILL_CONSOLE);
\r
559 case IDC_METHOD_WINDOW:
\r
560 set_timeout_enabled(LOWORD(w), IDC_KILL_WINDOW);
\r
563 case IDC_METHOD_THREADS:
\r
564 set_timeout_enabled(LOWORD(w), IDC_KILL_THREADS);
\r
567 /* Browse for stdin. */
\r
568 case IDC_BROWSE_STDIN:
\r
569 dlg = GetDlgItem(tab, IDC_STDIN);
\r
570 GetDlgItemText(tab, IDC_STDIN, buffer, _countof(buffer));
\r
571 browse(dlg, buffer, 0, NSSM_GUI_BROWSE_FILTER_ALL_FILES, 0);
\r
574 /* Browse for stdout. */
\r
575 case IDC_BROWSE_STDOUT:
\r
576 dlg = GetDlgItem(tab, IDC_STDOUT);
\r
577 GetDlgItemText(tab, IDC_STDOUT, buffer, _countof(buffer));
\r
578 browse(dlg, buffer, 0, NSSM_GUI_BROWSE_FILTER_ALL_FILES, 0);
\r
579 /* Fill in stderr if it wasn't already specified. */
\r
580 GetDlgItemText(tab, IDC_STDERR, buffer, _countof(buffer));
\r
582 GetDlgItemText(tab, IDC_STDOUT, buffer, _countof(buffer));
\r
583 SetDlgItemText(tab, IDC_STDERR, buffer);
\r
587 /* Browse for stderr. */
\r
588 case IDC_BROWSE_STDERR:
\r
589 dlg = GetDlgItem(tab, IDC_STDERR);
\r
590 GetDlgItemText(tab, IDC_STDERR, buffer, _countof(buffer));
\r
591 browse(dlg, buffer, 0, NSSM_GUI_BROWSE_FILTER_ALL_FILES, 0);
\r
596 if (SendDlgItemMessage(tab, LOWORD(w), BM_GETCHECK, 0, 0) & BST_CHECKED) enabled = 1;
\r
598 set_rotation_enabled(enabled);
\r
607 /* Install/remove dialogue callback */
\r
608 INT_PTR CALLBACK nssm_dlg(HWND window, UINT message, WPARAM w, LPARAM l) {
\r
610 /* Creating the dialogue */
\r
611 case WM_INITDIALOG:
\r
612 SetFocus(GetDlgItem(window, IDC_NAME));
\r
616 tabs = GetDlgItem(window, IDC_TAB1);
\r
617 if (! tabs) return 0;
\r
621 ZeroMemory(&tab, sizeof(tab));
\r
622 tab.mask = TCIF_TEXT;
\r
624 /* Application tab. */
\r
625 tab.pszText = message_string(NSSM_GUI_TAB_APPLICATION);
\r
626 tab.cchTextMax = (int) _tcslen(tab.pszText);
\r
627 SendMessage(tabs, TCM_INSERTITEM, NSSM_TAB_APPLICATION, (LPARAM) &tab);
\r
628 tablist[NSSM_TAB_APPLICATION] = CreateDialog(0, MAKEINTRESOURCE(IDD_APPLICATION), window, tab_dlg);
\r
629 ShowWindow(tablist[NSSM_TAB_APPLICATION], SW_SHOW);
\r
632 tab.pszText = message_string(NSSM_GUI_TAB_DETAILS);
\r
633 tab.cchTextMax = (int) _tcslen(tab.pszText);
\r
634 SendMessage(tabs, TCM_INSERTITEM, NSSM_TAB_DETAILS, (LPARAM) &tab);
\r
635 tablist[NSSM_TAB_DETAILS] = CreateDialog(0, MAKEINTRESOURCE(IDD_DETAILS), window, tab_dlg);
\r
636 ShowWindow(tablist[NSSM_TAB_DETAILS], SW_HIDE);
\r
638 /* Set defaults. */
\r
639 combo = GetDlgItem(tablist[NSSM_TAB_DETAILS], IDC_STARTUP);
\r
640 SendMessage(combo, CB_INSERTSTRING, NSSM_STARTUP_AUTOMATIC, (LPARAM) message_string(NSSM_GUI_STARTUP_AUTOMATIC));
\r
641 SendMessage(combo, CB_INSERTSTRING, NSSM_STARTUP_DELAYED, (LPARAM) message_string(NSSM_GUI_STARTUP_DELAYED));
\r
642 SendMessage(combo, CB_INSERTSTRING, NSSM_STARTUP_MANUAL, (LPARAM) message_string(NSSM_GUI_STARTUP_MANUAL));
\r
643 SendMessage(combo, CB_INSERTSTRING, NSSM_STARTUP_DISABLED, (LPARAM) message_string(NSSM_GUI_STARTUP_DISABLED));
\r
644 SendMessage(combo, CB_SETCURSEL, NSSM_STARTUP_AUTOMATIC, 0);
\r
647 tab.pszText = message_string(NSSM_GUI_TAB_LOGON);
\r
648 tab.cchTextMax = (int) _tcslen(tab.pszText);
\r
649 SendMessage(tabs, TCM_INSERTITEM, NSSM_TAB_LOGON, (LPARAM) &tab);
\r
650 tablist[NSSM_TAB_LOGON] = CreateDialog(0, MAKEINTRESOURCE(IDD_LOGON), window, tab_dlg);
\r
651 ShowWindow(tablist[NSSM_TAB_LOGON], SW_HIDE);
\r
653 /* Set defaults. */
\r
654 CheckRadioButton(tablist[NSSM_TAB_LOGON], IDC_LOCALSYSTEM, IDC_ACCOUNT, IDC_LOCALSYSTEM);
\r
655 set_logon_enabled(0);
\r
657 /* Shutdown tab. */
\r
658 tab.pszText = message_string(NSSM_GUI_TAB_SHUTDOWN);
\r
659 tab.cchTextMax = (int) _tcslen(tab.pszText);
\r
660 SendMessage(tabs, TCM_INSERTITEM, NSSM_TAB_SHUTDOWN, (LPARAM) &tab);
\r
661 tablist[NSSM_TAB_SHUTDOWN] = CreateDialog(0, MAKEINTRESOURCE(IDD_SHUTDOWN), window, tab_dlg);
\r
662 ShowWindow(tablist[NSSM_TAB_SHUTDOWN], SW_HIDE);
\r
664 /* Set defaults. */
\r
665 SendDlgItemMessage(tablist[NSSM_TAB_SHUTDOWN], IDC_METHOD_CONSOLE, BM_SETCHECK, BST_CHECKED, 0);
\r
666 SetDlgItemInt(tablist[NSSM_TAB_SHUTDOWN], IDC_KILL_CONSOLE, NSSM_KILL_CONSOLE_GRACE_PERIOD, 0);
\r
667 SendDlgItemMessage(tablist[NSSM_TAB_SHUTDOWN], IDC_METHOD_WINDOW, BM_SETCHECK, BST_CHECKED, 0);
\r
668 SetDlgItemInt(tablist[NSSM_TAB_SHUTDOWN], IDC_KILL_WINDOW, NSSM_KILL_WINDOW_GRACE_PERIOD, 0);
\r
669 SendDlgItemMessage(tablist[NSSM_TAB_SHUTDOWN], IDC_METHOD_THREADS, BM_SETCHECK, BST_CHECKED, 0);
\r
670 SetDlgItemInt(tablist[NSSM_TAB_SHUTDOWN], IDC_KILL_THREADS, NSSM_KILL_THREADS_GRACE_PERIOD, 0);
\r
671 SendDlgItemMessage(tablist[NSSM_TAB_SHUTDOWN], IDC_METHOD_TERMINATE, BM_SETCHECK, BST_CHECKED, 0);
\r
674 tab.pszText = message_string(NSSM_GUI_TAB_EXIT);
\r
675 tab.cchTextMax = (int) _tcslen(tab.pszText);
\r
676 SendMessage(tabs, TCM_INSERTITEM, NSSM_TAB_EXIT, (LPARAM) &tab);
\r
677 tablist[NSSM_TAB_EXIT] = CreateDialog(0, MAKEINTRESOURCE(IDD_APPEXIT), window, tab_dlg);
\r
678 ShowWindow(tablist[NSSM_TAB_EXIT], SW_HIDE);
\r
680 /* Set defaults. */
\r
681 SetDlgItemInt(tablist[NSSM_TAB_EXIT], IDC_THROTTLE, NSSM_RESET_THROTTLE_RESTART, 0);
\r
682 combo = GetDlgItem(tablist[NSSM_TAB_EXIT], IDC_APPEXIT);
\r
683 SendMessage(combo, CB_INSERTSTRING, NSSM_EXIT_RESTART, (LPARAM) message_string(NSSM_GUI_EXIT_RESTART));
\r
684 SendMessage(combo, CB_INSERTSTRING, NSSM_EXIT_IGNORE, (LPARAM) message_string(NSSM_GUI_EXIT_IGNORE));
\r
685 SendMessage(combo, CB_INSERTSTRING, NSSM_EXIT_REALLY, (LPARAM) message_string(NSSM_GUI_EXIT_REALLY));
\r
686 SendMessage(combo, CB_INSERTSTRING, NSSM_EXIT_UNCLEAN, (LPARAM) message_string(NSSM_GUI_EXIT_UNCLEAN));
\r
687 SendMessage(combo, CB_SETCURSEL, NSSM_EXIT_RESTART, 0);
\r
690 tab.pszText = message_string(NSSM_GUI_TAB_IO);
\r
691 tab.cchTextMax = (int) _tcslen(tab.pszText) + 1;
\r
692 SendMessage(tabs, TCM_INSERTITEM, NSSM_TAB_IO, (LPARAM) &tab);
\r
693 tablist[NSSM_TAB_IO] = CreateDialog(0, MAKEINTRESOURCE(IDD_IO), window, tab_dlg);
\r
694 ShowWindow(tablist[NSSM_TAB_IO], SW_HIDE);
\r
696 /* Rotation tab. */
\r
697 tab.pszText = message_string(NSSM_GUI_TAB_ROTATION);
\r
698 tab.cchTextMax = (int) _tcslen(tab.pszText) + 1;
\r
699 SendMessage(tabs, TCM_INSERTITEM, NSSM_TAB_ROTATION, (LPARAM) &tab);
\r
700 tablist[NSSM_TAB_ROTATION] = CreateDialog(0, MAKEINTRESOURCE(IDD_ROTATION), window, tab_dlg);
\r
701 ShowWindow(tablist[NSSM_TAB_ROTATION], SW_HIDE);
\r
703 /* Set defaults. */
\r
704 SetDlgItemInt(tablist[NSSM_TAB_ROTATION], IDC_ROTATE_SECONDS, 0, 0);
\r
705 SetDlgItemInt(tablist[NSSM_TAB_ROTATION], IDC_ROTATE_BYTES_LOW, 0, 0);
\r
706 set_rotation_enabled(0);
\r
708 /* Environment tab. */
\r
709 tab.pszText = message_string(NSSM_GUI_TAB_ENVIRONMENT);
\r
710 tab.cchTextMax = (int) _tcslen(tab.pszText) + 1;
\r
711 SendMessage(tabs, TCM_INSERTITEM, NSSM_TAB_ENVIRONMENT, (LPARAM) &tab);
\r
712 tablist[NSSM_TAB_ENVIRONMENT] = CreateDialog(0, MAKEINTRESOURCE(IDD_ENVIRONMENT), window, tab_dlg);
\r
713 ShowWindow(tablist[NSSM_TAB_ENVIRONMENT], SW_HIDE);
\r
721 NMHDR *notification;
\r
723 notification = (NMHDR *) l;
\r
724 switch (notification->code) {
\r
725 case TCN_SELCHANGE:
\r
729 tabs = GetDlgItem(window, IDC_TAB1);
\r
730 if (! tabs) return 0;
\r
732 selection = (int) SendMessage(tabs, TCM_GETCURSEL, 0, 0);
\r
733 if (selection != selected_tab) {
\r
734 ShowWindow(tablist[selected_tab], SW_HIDE);
\r
736 XXX: Sets focus to the service name which isn't ideal but is
\r
737 better than leaving it in another tab.
\r
739 ShowWindow(tablist[selection], SW_SHOWDEFAULT);
\r
740 SetFocus(tablist[selection]);
\r
741 selected_tab = selection;
\r
748 /* Button was pressed or control was controlled */
\r
750 switch (LOWORD(w)) {
\r
753 if (! install(window)) PostQuitMessage(0);
\r
756 /* Cancel button */
\r
758 DestroyWindow(window);
\r
761 /* Remove button */
\r
763 if (! remove(window)) PostQuitMessage(0);
\r
768 /* Window closing */
\r
770 DestroyWindow(window);
\r
773 PostQuitMessage(0);
\r