nhyatt/putty-source
1
0
Fork 0
mirror of https://git.tartarus.org/simon/putty.git synced 2025-01-09 17:38:00 +00:00
Code Issues Projects Releases Wiki Activity
pre-0.83
putty-source/windows/window.c

5950 lines
208 KiB
C
Raw Permalink Normal View History

Sprinkle some header comments in various files in an attempt to explain what they're for. [originally from svn r6639]
2006-04-23 18:26:03 +00:00
/*
Special backend init error handling for pterm. Fixes a cosmetic issue where the new ConPTY error added in 4ae8b742ab had an ugly "Unable to open connection to". (Arguably this ought to test a backend property rather than cmdline_tooltype.)
2022-05-24 12:32:55 +00:00
* window.c - the PuTTY(tel)/pterm main program, which runs a PuTTY
* terminal emulator and backend in a window.
Sprinkle some header comments in various files in an attempt to explain what they're for. [originally from svn r6639]
2006-04-23 18:26:03 +00:00
*/
Initial checkin: beta 0.43 [originally from svn r11]
1999-01-08 13:02:13 +00:00
#include <stdio.h>
#include <stdlib.h>
Cleanups to remove warnings for GNU/mingw32 compilation [originally from svn r325]
1999-11-22 10:07:24 +00:00
#include <ctype.h>
Robert de Bath's big patch: - cope with strange WinSock wrappers not supporting SIOCATMARK - define yet more terminal compatibility modes - support UK-ASCII (just like US-ASCII but # is a sterling sign) - support connection keepalives at a configurable interval [originally from svn r692]
2000-10-09 12:53:32 +00:00
#include <time.h>
Start using notify_remote_exit() in the Windows front end, in place of the previous ad-hockery which depended on the return value from select_result() and hence which will not adapt sensibly to a world in which the primary session is something local rather than a network connection. [originally from svn r6802]
2006-08-26 10:04:46 +00:00
#include <limits.h>
Implement writing RTF to the clipboard (off by default), so that if you enable it text will paste into Word et al in the same font as PuTTY itself is displaying in. In particular, this will be a fixed- pitch font, so tables and `ls' and the like will naturally line up. [originally from svn r1373]
2001-11-07 22:22:53 +00:00
#include <assert.h>
More assorted Winelib warning fixes. The previous fix on pre-0.77 was non-disruptive and just enough to get through my Coverity build (which uses winelib); but now that I look at the rest of the Winelib build output, there are some further warnings I should fix on main. Most of them are more long/LONG confusion (specific to Winelib, rather than real Windows); also, there's a multiple macro definition in jump-list.c because Winelib defines _PROPVARIANT_INIT_DEFINED_ in place of _PROPVARIANTINIT_DEFINED_ which we were testing for. (Bah.) And in windows/window.c I used wcscmp without including <wchar.h>. In spite of long vs LONG I still had to turn off one or two more DLL-loading typechecks.
2022-05-08 10:06:14 +00:00
#include <wchar.h>
Initial checkin: beta 0.43 [originally from svn r11]
1999-01-08 13:02:13 +00:00
Update WINVER to 0x500 to avoid build failures from Jacob's FlashWindow changes. Also fiddle with the <multimon.h> include, which was subtly broken in turn by that. [originally from svn r7120]
2007-01-16 21:32:02 +00:00
#define COMPILE_MULTIMON_STUBS
Initial checkin: beta 0.43 [originally from svn r11]
1999-01-08 13:02:13 +00:00
#include "putty.h"
Add some missing #includes. My experimental build with clang-cl at -Wall did show up a few things that are safe enough to fix right now. One was this list of missing includes, which was causing a lot of -Wmissing-prototype warnings, and is a real risk because it means the declarations in headers weren't being type-checked against the actual function definitions. Happily, no actual mismatches.
2022-09-03 10:43:46 +00:00
#include "ssh.h"
Major destabilisation, phase 1. In this phase I've moved (I think) all the global and function-static variables out of terminal.c into a dynamically allocated data structure. Note that this does not yet confer the ability to run more than one of them in the same process, because other things (the line discipline, the back end) are still global, and also in particular the address of the dynamically allocated terminal-data structure is held in a global variable `term'. But what I've got here represents a reasonable stopping point at which to check things in. In _theory_ this should all still work happily, on both Unix and Windows. In practice, who knows? [originally from svn r2115]
2002-10-22 16:11:33 +00:00
#include "terminal.h"
Rationalised host key storage. Also started code reorg: persistent-state routines have been moved out into a replaceable module winstore.c. [originally from svn r639]
2000-09-27 15:21:04 +00:00
#include "storage.h"
Rename most of the platform source files. This gets rid of all those annoying 'win', 'ux' and 'gtk' prefixes which made filenames annoying to type and to tab-complete. Also, as with my other recent renaming sprees, I've taken the opportunity to expand and clarify some of the names so that they're not such cryptic abbreviations.
2021-04-23 05:19:05 +00:00
#include "putty-rc.h"
#include "security-api.h"
#include "win-gui-seat.h"
Implement true-colour in write_clip for Windows This allows text copied from PuTTY to a rich-text program to retain the true-colour attribute.
2017-06-13 04:55:57 +00:00
#include "tree234.h"
Initial checkin: beta 0.43 [originally from svn r11]
1999-01-08 13:02:13 +00:00
Replace mkfiles.pl with a CMake build system. This brings various concrete advantages over the previous system: - consistent support for out-of-tree builds on all platforms - more thorough support for Visual Studio IDE project files - support for Ninja-based builds, which is particularly useful on Windows where the alternative nmake has no parallel option - a really simple set of build instructions that work the same way on all the major platforms (look how much shorter README is!) - better decoupling of the project configuration from the toolchain configuration, so that my Windows cross-building doesn't need (much) special treatment in CMakeLists.txt - configure-time tests on Windows as well as Linux, so that a lot of ad-hoc #ifdefs second-guessing a particular feature's presence from the compiler version can now be replaced by tests of the feature itself Also some longer-term software-engineering advantages: - other people have actually heard of CMake, so they'll be able to produce patches to the new build setup more easily - unlike the old mkfiles.pl, CMake is not my personal problem to maintain - most importantly, mkfiles.pl was just a horrible pile of unmaintainable cruft, which even I found it painful to make changes to or to use, and desperately needed throwing in the bin. I've already thrown away all the variants of it I had in other projects of mine, and was only delaying this one so we could make the 0.75 release branch first. This change comes with a noticeable build-level restructuring. The previous Recipe worked by compiling every object file exactly once, and then making each executable by linking a precisely specified subset of the same object files. But in CMake, that's not the natural way to work - if you write the obvious command that puts the same source file into two executable targets, CMake generates a makefile that compiles it once per target. That can be an advantage, because it gives you the freedom to compile it differently in each case (e.g. with a #define telling it which program it's part of). But in a project that has many executable targets and had carefully contrived to _never_ need to build any module more than once, all it does is bloat the build time pointlessly! To avoid slowing down the build by a large factor, I've put most of the modules of the code base into a collection of static libraries organised vaguely thematically (SSH, other backends, crypto, network, ...). That means all those modules can still be compiled just once each, because once each library is built it's reused unchanged for all the executable targets. One upside of this library-based structure is that now I don't have to manually specify exactly which objects go into which programs any more - it's enough to specify which libraries are needed, and the linker will figure out the fine detail automatically. So there's less maintenance to do in CMakeLists.txt when the source code changes. But that reorganisation also adds fragility, because of the trad Unix linker semantics of walking along the library list once each, so that cyclic references between your libraries will provoke link errors. The current setup builds successfully, but I suspect it only just manages it. (In particular, I've found that MinGW is the most finicky on this score of the Windows compilers I've tried building with. So I've included a MinGW test build in the new-look Buildscr, because otherwise I think there'd be a significant risk of introducing MinGW-only build failures due to library search order, which wasn't a risk in the previous library-free build organisation.) In the longer term I hope to be able to reduce the risk of that, via gradual reorganisation (in particular, breaking up too-monolithic modules, to reduce the risk of knock-on references when you included a module for function A and it also contains function B with an unsatisfied dependency you didn't really need). Ideally I want to reach a state in which the libraries all have sensibly described purposes, a clearly documented (partial) order in which they're permitted to depend on each other, and a specification of what stubs you have to put where if you're leaving one of them out (e.g. nocrypto) and what callbacks you have to define in your non-library objects to satisfy dependencies from things low in the stack (e.g. out_of_memory()). One thing that's gone completely missing in this migration, unfortunately, is the unfinished MacOS port linked against Quartz GTK. That's because it turned out that I can't currently build it myself, on my own Mac: my previous installation of GTK had bit-rotted as a side effect of an Xcode upgrade, and I haven't yet been able to persuade jhbuild to make me a new one. So I can't even build the MacOS port with the _old_ makefiles, and hence, I have no way of checking that the new ones also work. I hope to bring that port back to life at some point, but I don't want it to block the rest of this change.
2021-04-10 14:21:11 +00:00
#ifdef NO_MULTIMON
The WinSock library is now loaded at run-time, which means we can attempt to load WS2 and then fall back to WS1 if that fails. This should allow us to use WS2-specific functionality to find out the local system's list of IP addresses, thus fixing winnet-if2lo, while degrading gracefully back to the previous behaviour if that functionality is unavailable. (I haven't yet actually done this; I've just laid the groundwork.) This checkin _may_ cause instability; it seemed fine to me on initial testing, but it's a bit of an upheaval and I wouldn't like to make bets on it just yet. [originally from svn r3502]
2003-10-12 13:46:12 +00:00
#include <multimon.h>
#endif
#include <imm.h>
#include <commctrl.h>
#include <richedit.h>
#include <mmsystem.h>
Simon has reminded me _why_ menu identifiers were spaced every sixteen, so let's add a comment so that we don't forget again. Source: <http://msdn.microsoft.com/library/default.asp?url=/library/en-us/winui/winui/windowsuserinterface/userinput/keyboardaccelerators/keyboardacceleratorreference/keyboardacceleratormessages/wm_syscommand.asp> [originally from svn r4732]
2004-11-02 22:30:24 +00:00
/* From MSDN: In the WM_SYSCOMMAND message, the four low-order bits of
* wParam are used by Windows, and should be masked off, so we shouldn't
* attempt to store information in them. Hence all these identifiers have
Go back to using intervals of 16 for the saved session identifiers for the system menu, but expand from 256 entries to 1024 as there seems to be plenty of space. Also remove a couple of unused IDM_* constants. [originally from svn r4733]
2004-11-02 23:06:20 +00:00
* the low 4 bits clear. Also, identifiers should < 0xF000. */
Simon has reminded me _why_ menu identifiers were spaced every sixteen, so let's add a comment so that we don't forget again. Source: <http://msdn.microsoft.com/library/default.asp?url=/library/en-us/winui/winui/windowsuserinterface/userinput/keyboardaccelerators/keyboardacceleratorreference/keyboardacceleratormessages/wm_syscommand.asp> [originally from svn r4732]
2004-11-02 22:30:24 +00:00
Stop putting meaning in bottom four bits of WM_SYSCOMMAND wParam [originally from svn r265]
1999-10-28 16:29:06 +00:00
#define IDM_SHOWLOG 0x0010
#define IDM_NEWSESS 0x0020
#define IDM_DUPSESS 0x0030
Implement `Restart Session', in both Unix and Windows PuTTY. Largely because Owen questioned whether it was really easy enough to be labelled `fun' in the bug database :-) [originally from svn r4453]
2004-08-14 13:04:18 +00:00
#define IDM_RESTART 0x0040
#define IDM_RECONF 0x0050
#define IDM_CLRSB 0x0060
#define IDM_RESET 0x0070
Integrate PuTTY and its help file. Now that's what I call a good lunchtime's work :-) [originally from svn r1458]
2001-12-06 13:28:02 +00:00
#define IDM_HELP 0x0140
#define IDM_ABOUT 0x0150
#define IDM_SAVEDSESS 0x0160
#define IDM_COPYALL 0x0170
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
#define IDM_FULLSCREEN 0x0180
Add GUI configuration for choice of clipboards. On all platforms, you can now configure which clipboard the mouse pastes from, which clipboard Ctrl-Ins and Shift-Ins access, and which Ctrl-Shift-C and Ctrl-Shift-V access. In each case, the options are: - nothing at all - a clipboard which is implicitly written by the act of mouse selection (the PRIMARY selection on X, CLIP_LOCAL everywhere else) - the standard clipboard written by explicit copy/paste UI actions (CLIPBOARD on X, the unique system clipboard elsewhere). Also, you can control whether selecting text with the mouse _also_ writes to the explicitly accessed clipboard. The wording of the various messages changes between platforms, but the basic UI shape is the same everywhere.
2017-12-10 17:16:50 +00:00
#define IDM_COPY 0x0190
#define IDM_PASTE 0x01A0
Users of Virtual Dimension are reporting that the "Close" menu item and button tend to get disabled on login. After a suggestion by "Tkil", change the way we handle the specials menu to be robust against the window menu being externally modified. [originally from svn r6546] [this svn revision also touched putty-wishlist]
2006-02-09 23:06:57 +00:00
#define IDM_SPECIALSEP 0x0200
Stop putting meaning in bottom four bits of WM_SYSCOMMAND wParam [originally from svn r265]
1999-10-28 16:29:06 +00:00
Turned the old `Telnet Command' System-submenu into a more general `Special Command' menu, in which any backend can place its own list of magical things the user might want to ask the backend to do. In particular I've implemented the recently proposed "break" extension in SSH2 using this mechanism. NB this checkin slightly breaks the Mac build, since it needs to provide at least a stub form of update_specials_menu(). [originally from svn r3054]
2003-04-04 20:21:05 +00:00
#define IDM_SPECIAL_MIN 0x0400
#define IDM_SPECIAL_MAX 0x0800
Stop putting meaning in bottom four bits of WM_SYSCOMMAND wParam [originally from svn r265]
1999-10-28 16:29:06 +00:00
#define IDM_SAVED_MIN 0x1000
Go back to using intervals of 16 for the saved session identifiers for the system menu, but expand from 256 entries to 1024 as there seems to be plenty of space. Also remove a couple of unused IDM_* constants. [originally from svn r4733]
2004-11-02 23:06:20 +00:00
#define IDM_SAVED_MAX 0x5000
#define MENU_SAVED_STEP 16
Since neither I nor Owen know why the IDM_ values for the saved-sessions submenu were going up in steps of 16, I've changed to steps of 1, thus increasing the possible number of sessions from ~256 to 4096, since a recent report seemed to indicate that the previous limit might not be enough for someone (!) I can't find any documentation that puts an upper limit on the number of menu items, and it seems to work on Win98, which is where I'd expect it to break if anywhere. Also a number of other tweaks to this code. [originally from svn r4731]
2004-11-02 17:44:06 +00:00
/* Maximum number of sessions on saved-session submenu */
Go back to using intervals of 16 for the saved session identifiers for the system menu, but expand from 256 entries to 1024 as there seems to be plenty of space. Also remove a couple of unused IDM_* constants. [originally from svn r4733]
2004-11-02 23:06:20 +00:00
#define MENU_SAVED_MAX ((IDM_SAVED_MAX-IDM_SAVED_MIN) / MENU_SAVED_STEP)
Initial checkin: beta 0.43 [originally from svn r11]
1999-01-08 13:02:13 +00:00
Ben Rudiak-Gould points out that we should be using WM_APP as the base for our app-private window messages, which is considerably higher than the WM_XUSER we arbitrarily chose. (This isn't known to be causing any actual problems. The fix seems not to have obviously broken anything.) [originally from svn r6183] [this svn revision also touched putty-wishlist]
2005-08-10 18:31:24 +00:00
#define WM_IGNORE_CLIP (WM_APP + 2)
#define WM_FULLSCR_ON_MAX (WM_APP + 3)
Remove agent_schedule_callback(). This is another piece of the old 2003 attempt at async agent requests. Nothing ever calls this function (in particular, the new working version of async-agent doesn't need it). Remove it completely, and all its special-window-message implementations too. (If we _were_ still using this function, then it would surely be possible to fold it into the more recently introduced general toplevel-callback system, and get rid of all this single-use special code. But we're not, so removing it completely is even easier.) In particular, this system was the only reason why Windows Plink paid any attention to its message queue. So now I can make it call plain WaitForMultipleObjects instead of MsgWaitForMultipleObjects.
2020-01-30 06:40:21 +00:00
#define WM_GOT_CLIPDATA (WM_APP + 4)
Initial checkin: beta 0.43 [originally from svn r11]
1999-01-08 13:02:13 +00:00
Chinese support patch from zmx@cdpa.nsysu.edu.tw [originally from svn r740]
2000-10-20 18:36:15 +00:00
/* Needed for Chinese support and apparently not always defined. */
#ifndef VK_PROCESSKEY
#define VK_PROCESSKEY 0xE5
#endif
Replace the definition of WHEEL_DELTA which was removed in rev 1.185 [r1499]. For some reason Borland builds were working perfectly OK without it, but VC builds were failing. *shrug* [originally from svn r1500] [r1499 == d6016149bfd0fe316629ff74e32e06f42948cf87]
2001-12-16 12:11:56 +00:00
/* Mouse wheel support. */
Define WM_MOUSEWHEEL (to 0x20A) if it's not defined by windows.h. [originally from svn r1115]
2001-05-13 11:19:20 +00:00
#ifndef WM_MOUSEWHEEL
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
#define WM_MOUSEWHEEL 0x020A /* not defined in earlier SDKs */
Replace the definition of WHEEL_DELTA which was removed in rev 1.185 [r1499]. For some reason Borland builds were working perfectly OK without it, but VC builds were failing. *shrug* [originally from svn r1500] [r1499 == d6016149bfd0fe316629ff74e32e06f42948cf87]
2001-12-16 12:11:56 +00:00
#endif
Support horizontal scroll events in mouse tracking. Horizontal scroll events aren't generated by the traditional mouse wheel, but they can be generated by trackpad gestures, though this isn't always configured on. The cross-platform and Windows parts of this patch is due to Christopher Plewright; I added the GTK support.
2022-11-22 18:36:23 +00:00
#ifndef WM_MOUSEHWHEEL
#define WM_MOUSEHWHEEL 0x020E /* not defined in earlier SDKs */
#endif
Replace the definition of WHEEL_DELTA which was removed in rev 1.185 [r1499]. For some reason Borland builds were working perfectly OK without it, but VC builds were failing. *shrug* [originally from svn r1500] [r1499 == d6016149bfd0fe316629ff74e32e06f42948cf87]
2001-12-16 12:11:56 +00:00
#ifndef WHEEL_DELTA
#define WHEEL_DELTA 120
Define WM_MOUSEWHEEL (to 0x20A) if it's not defined by windows.h. [originally from svn r1115]
2001-05-13 11:19:20 +00:00
#endif
Windows 10: add per monitor DPI awareness support. On a system with 2 or more displays with different DPI settings, moving the PuTTY window from one display to another will make Windows resize the window using its "bitmap" strategy, stretching/compressing the text, making it fuzzy and harder to read. This change makes PuTTY resize its window and font size to accurately fit the DPI of the display it is on. We process the WM_DPICHANGED message, saving the new DPI, window size and position. We proceed to then reset the window, recreating the fonts using the new DPI and calculate the new window size and position based on the new font size, user display options (ie. with/without scrollbar) and the suggested window position provided by Windows. The suggested window size is usually not a perfect fit, therefore we must add a small offset to the new window position in order to avoid issues with repeated DPI changes while dragging the window from one display to another.
2021-03-29 15:31:13 +00:00
/* DPI awareness support */
#ifndef WM_DPICHANGED
#define WM_DPICHANGED 0x02E0
#define WM_DPICHANGED_BEFOREPARENT 0x02E2
#define WM_DPICHANGED_AFTERPARENT 0x02E3
#define WM_GETDPISCALEDSIZE 0x02E4
#endif
Handle the VK_PACKET virtual key code. This is generated in response to the SendInput() Windows API call, if that in turn is passed an KEYBDINPUT structure with KEYEVENTF_UNICODE set. That method of input generation is used by programs such as 'WinCompose' to send an arbitrary Unicode character as if it had been typed at the keyboard, even if the keyboard doesn't actually provide a key for it. Like VK_PROCESSKEY, this key code is an exception to our usual policy of manually translating keystrokes: we handle it by calling TranslateMessage, to get back the Unicode character it contains as a WM_CHAR message. (If that Unicode character in turn is outside the BMP, it may come back as a pair of WM_CHARs in succession containing UTF-16 surrogates; if so, that's OK, because the new Unicode WM_CHAR handler can cope.)
2015-07-27 19:06:02 +00:00
/* VK_PACKET, used to send Unicode characters in WM_KEYDOWNs */
#ifndef VK_PACKET
#define VK_PACKET 0xE7
#endif
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
static Mouse_Button translate_button(WinGuiSeat *wgs, Mouse_Button button);
static void show_mouseptr(WinGuiSeat *wgs, bool show);
Run entire source base through GNU indent to tidy up the varying coding styles of the various contributors! Woohoo! [originally from svn r1098]
2001-05-06 14:35:20 +00:00
static LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
static int TranslateKey(WinGuiSeat *wgs, UINT message, WPARAM wParam,
LPARAM lParam, unsigned char *output);
static void init_palette(WinGuiSeat *wgs);
static void init_fonts(WinGuiSeat *wgs, int, int);
static void init_dpi_info(WinGuiSeat *wgs);
static void another_font(WinGuiSeat *wgs, int);
static void deinit_fonts(WinGuiSeat *wgs);
static void set_input_locale(WinGuiSeat *wgs, HKL);
static void update_savedsess_menu(WinGuiSeat *wgs);
Find ToUnicodeEx() at run time, not load time. This restores PuTTY's backward compatibility to versions of Windows too old to have ToUnicodeEx in their system libraries, which was accidentally broken in 0.63. [originally from svn r10061]
2013-11-17 14:03:20 +00:00
static void init_winfuncs(void);
Initial checkin: beta 0.43 [originally from svn r11]
1999-01-08 13:02:13 +00:00
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
static bool is_full_screen(WinGuiSeat *wgs);
static void make_full_screen(WinGuiSeat *wgs);
static void clear_full_screen(WinGuiSeat *wgs);
static void flip_full_screen(WinGuiSeat *wgs);
static void process_clipdata(WinGuiSeat *wgs, HGLOBAL clipdata, bool unicode);
Add GUI configuration for choice of clipboards. On all platforms, you can now configure which clipboard the mouse pastes from, which clipboard Ctrl-Ins and Shift-Ins access, and which Ctrl-Shift-C and Ctrl-Shift-V access. In each case, the options are: - nothing at all - a clipboard which is implicitly written by the act of mouse selection (the PRIMARY selection on X, CLIP_LOCAL everywhere else) - the standard clipboard written by explicit copy/paste UI actions (CLIPBOARD on X, the unique system clipboard elsewhere). Also, you can control whether selecting text with the mouse _also_ writes to the explicitly accessed clipboard. The wording of the various messages changes between platforms, but the basic UI shape is the same everywhere.
2017-12-10 17:16:50 +00:00
static void setup_clipboards(Terminal *, Conf *);
FIFTH ATTEMPT at getting full-screen mode right. This new attempt (which I'll comment at some stage) should combine the believable semantics of RDB's fullscreen-by-maximise mode with the multi- monitor friendliness of Wez Furlong's approach while also working on Win98. If we're lucky. [originally from svn r1464]
2001-12-07 21:21:03 +00:00
Three more patches from RDB: one to make Atomica work right, one to fiddle with the widths of characters in DBCS screen fonts, and (the big one) one to enable a mode in which resizing the window locks the terminal size and lets the font change, instead of vice versa. That should shut up a few feature requests! [originally from svn r1269]
2001-09-15 15:54:24 +00:00
/* Window layout information */
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
static void reset_window(WinGuiSeat *wgs, int reinit);
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
static void flash_window(WinGuiSeat *wgs, int mode);
static void sys_cursor_update(WinGuiSeat *wgs);
static bool get_fullscreen_rect(WinGuiSeat *wgs, RECT *ss);
Ensure the whole window is visible at startup During startup, calculate the top/left position of the window so that the whole window is visible. Without this change, sometimes the window is clipped vertically and you can't see the bottom. Thanks to Bruno Kraychete da Costa for the original version of this patch; I've tweaked it slightly, but the basic strategy of adjusting the output of GetWindowRect against the monitor's working area is all his.
2024-10-16 07:00:32 +00:00
static bool get_workingarea_rect(WinGuiSeat *wgs, RECT *ss);
RDB's patch: - use WM_TIMER for various things (blinking cursor; updates while moving/sizing; coping with overloading influx of netevents) - clip text output to avoid underlines outside character cell - even more careful font selection (we can now do OEMANSI by default) - a few extra keyboard mappings from the VTxxx terminals [originally from svn r418]
2000-03-17 10:34:41 +00:00
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
static void conf_cache_data(WinGuiSeat *wgs);
Having laid all the groundwork, we can now remove the global `cfg' completely from putty.h. It's now static in each of the command-line front ends, shared only between window.c and windlg.c in PuTTY proper (I've tested this by doing #define cfg cfgsillyname in those two files only, and it still links so nobody else is using that symbol!), and part of the `inst' structure in pterm. I think that only leaves the Unicode module as the last stubborn holdout in the anti-global-variables campaign. [originally from svn r2568]
2003-01-12 15:32:31 +00:00
If a new session was saved from Change Settings, a side-effect on Windows was that the global `sesslist' got out of sync with the saved-sessions submenu, causing the latter to launch the wrong sessions. Also, Change Settings wasn't getting a fresh session list, so if the set of sessions had changed since session startup it wouldn't reflect that (at least until a session was saved). Fixed (on all platforms). Therefore, since the global sesslist didn't seem to be useful, I've got rid of it; config.c creates one as needed, as do the frontends. (Not tried compiling Mac changes.) Also, we now build the saved-sessions submenu on demand on Windows and Unix. (This should probably also be done on the Mac.) [originally from svn r5609]
2005-04-07 01:36:28 +00:00
static struct sesslist sesslist; /* for saved-session menu */
Further deglobalisation: settings.c now has a more sensible interface. [originally from svn r2162]
2002-10-30 18:12:46 +00:00
Windows 10: add per monitor DPI awareness support. On a system with 2 or more displays with different DPI settings, moving the PuTTY window from one display to another will make Windows resize the window using its "bitmap" strategy, stretching/compressing the text, making it fuzzy and harder to read. This change makes PuTTY resize its window and font size to accurately fit the DPI of the display it is on. We process the WM_DPICHANGED message, saving the new DPI, window size and position. We proceed to then reset the window, recreating the fonts using the new DPI and calculate the new window size and position based on the new font size, user display options (ie. with/without scrollbar) and the suggested window position provided by Windows. The suggested window size is usually not a perfect fit, therefore we must add a small offset to the new window position in order to avoid issues with repeated DPI changes while dragging the window from one display to another.
2021-03-29 15:31:13 +00:00
enum MONITOR_DPI_TYPE { MDT_EFFECTIVE_DPI, MDT_ANGULAR_DPI, MDT_RAW_DPI, MDT_DEFAULT };
Remove hard dependencies on multi-monitor functions. These are more functions that don't exist on all our supported legacy versions of Windows, so we need to follow the same policy as everywhere else, by trying to acquire them at run time and having a fallback if they aren't available.
2022-03-11 18:32:26 +00:00
DECL_WINDOWS_FUNCTION(static, BOOL, GetMonitorInfoA, (HMONITOR, LPMONITORINFO));
DECL_WINDOWS_FUNCTION(static, HMONITOR, MonitorFromPoint, (POINT, DWORD));
DECL_WINDOWS_FUNCTION(static, HMONITOR, MonitorFromWindow, (HWND, DWORD));
Windows 10: add per monitor DPI awareness support. On a system with 2 or more displays with different DPI settings, moving the PuTTY window from one display to another will make Windows resize the window using its "bitmap" strategy, stretching/compressing the text, making it fuzzy and harder to read. This change makes PuTTY resize its window and font size to accurately fit the DPI of the display it is on. We process the WM_DPICHANGED message, saving the new DPI, window size and position. We proceed to then reset the window, recreating the fonts using the new DPI and calculate the new window size and position based on the new font size, user display options (ie. with/without scrollbar) and the suggested window position provided by Windows. The suggested window size is usually not a perfect fit, therefore we must add a small offset to the new window position in order to avoid issues with repeated DPI changes while dragging the window from one display to another.
2021-03-29 15:31:13 +00:00
DECL_WINDOWS_FUNCTION(static, HRESULT, GetDpiForMonitor, (HMONITOR hmonitor, enum MONITOR_DPI_TYPE dpiType, UINT *dpiX, UINT *dpiY));
DECL_WINDOWS_FUNCTION(static, HRESULT, GetSystemMetricsForDpi, (int nIndex, UINT dpi));
DECL_WINDOWS_FUNCTION(static, HRESULT, AdjustWindowRectExForDpi, (LPRECT lpRect, DWORD dwStyle, BOOL bMenu, DWORD dwExStyle, UINT dpi));
A contributor tells me that WM_MOUSEWHEEL is not supported in Win95, and offers a patch that uses RegisterMessage() to acquire the correct dynamic message number to use instead. [originally from svn r1499]
2001-12-15 14:30:58 +00:00
static UINT wm_mousewheel = WM_MOUSEWHEEL;
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
struct WinGuiSeatListNode wgslisthead = {
.next = &wgslisthead, .prev = &wgslisthead,
};
Patch from Yoshida Masato to fill in the missing pieces of Windows UTF-16 support. High Unicode characters in the terminal are now converted back into surrogates during copy and draw operations, and the Windows drawing code takes account of that when splitting up the UTF-16 string for display. Meanwhile, accidental uses of wchar_t have been replaced with 32-bit integers in parts of the cross-platform code which were expecting not to have to deal with UTF-16. [originally from svn r9409]
2012-02-17 19:28:55 +00:00
#define IS_HIGH_VARSEL(wch1, wch2) \
((wch1) == 0xDB40 && ((wch2) >= 0xDD00 && (wch2) <= 0xDDEF))
#define IS_LOW_VARSEL(wch) \
(((wch) >= 0x180B && (wch) <= 0x180D) || /* MONGOLIAN FREE VARIATION SELECTOR */ \
((wch) >= 0xFE00 && (wch) <= 0xFE0F)) /* VARIATION SELECTOR 1-16 */
Convert a lot of 'int' variables to 'bool'. My normal habit these days, in new code, is to treat int and bool as _almost_ completely separate types. I'm still willing to use C's implicit test for zero on an integer (e.g. 'if (!blob.len)' is fine, no need to spell it out as blob.len != 0), but generally, if a variable is going to be conceptually a boolean, I like to declare it bool and assign to it using 'true' or 'false' rather than 0 or 1. PuTTY is an exception, because it predates the C99 bool, and I've stuck to its existing coding style even when adding new code to it. But it's been annoying me more and more, so now that I've decided C99 bool is an acceptable thing to require from our toolchain in the first place, here's a quite thorough trawl through the source doing 'boolification'. Many variables and function parameters are now typed as bool rather than int; many assignments of 0 or 1 to those variables are now spelled 'true' or 'false'. I managed this thorough conversion with the help of a custom clang plugin that I wrote to trawl the AST and apply heuristics to point out where things might want changing. So I've even managed to do a decent job on parts of the code I haven't looked at in years! To make the plugin's work easier, I pushed platform front ends generally in the direction of using standard 'bool' in preference to platform-specific boolean types like Windows BOOL or GTK's gboolean; I've left the platform booleans in places they _have_ to be for the platform APIs to work right, but variables only used by my own code have been converted wherever I found them. In a few places there are int values that look very like booleans in _most_ of the places they're used, but have a rarely-used third value, or a distinction between different nonzero values that most users don't care about. In these cases, I've _removed_ uses of 'true' and 'false' for the return values, to emphasise that there's something more subtle going on than a simple boolean answer: - the 'multisel' field in dialog.h's list box structure, for which the GTK front end in particular recognises a difference between 1 and 2 but nearly everything else treats as boolean - the 'urgent' parameter to plug_receive, where 1 vs 2 tells you something about the specific location of the urgent pointer, but most clients only care about 0 vs 'something nonzero' - the return value of wc_match, where -1 indicates a syntax error in the wildcard. - the return values from SSH-1 RSA-key loading functions, which use -1 for 'wrong passphrase' and 0 for all other failures (so any caller which already knows it's not loading an _encrypted private_ key can treat them as boolean) - term->esc_query, and the 'query' parameter in toggle_mode in terminal.c, which _usually_ hold 0 for ESC[123h or 1 for ESC[?123h, but can also hold -1 for some other intervening character that we don't support. In a few places there's an integer that I haven't turned into a bool even though it really _can_ only take values 0 or 1 (and, as above, tried to make the call sites consistent in not calling those values true and false), on the grounds that I thought it would make it more confusing to imply that the 0 value was in some sense 'negative' or bad and the 1 positive or good: - the return value of plug_accepting uses the POSIXish convention of 0=success and nonzero=error; I think if I made it bool then I'd also want to reverse its sense, and that's a job for a separate piece of work. - the 'screen' parameter to lineptr() in terminal.c, where 0 and 1 represent the default and alternate screens. There's no obvious reason why one of those should be considered 'true' or 'positive' or 'success' - they're just indices - so I've left it as int. ssh_scp_recv had particularly confusing semantics for its previous int return value: its call sites used '<= 0' to check for error, but it never actually returned a negative number, just 0 or 1. Now the function and its call sites agree that it's a bool. In a couple of places I've renamed variables called 'ret', because I don't like that name any more - it's unclear whether it means the return value (in preparation) for the _containing_ function or the return value received from a subroutine call, and occasionally I've accidentally used the same variable for both and introduced a bug. So where one of those got in my way, I've renamed it to 'toret' or 'retd' (the latter short for 'returned') in line with my usual modern practice, but I haven't done a thorough job of finding all of them. Finally, one amusing side effect of doing this is that I've had to separate quite a few chained assignments. It used to be perfectly fine to write 'a = b = c = TRUE' when a,b,c were int and TRUE was just a the 'true' defined by stdbool.h, that idiom provokes a warning from gcc: 'suggest parentheses around assignment used as truth value'!
2018-11-02 19:23:19 +00:00
static bool wintw_setup_draw_ctx(TermWin *);
Remove the 'Frontend' type and replace it with a vtable. After the recent Seat and LogContext revamps, _nearly_ all the remaining uses of the type 'Frontend' were in terminal.c, which needs all sorts of interactions with the GUI window the terminal lives in, from the obvious (actually drawing text on the window, reading and writing the clipboard) to the obscure (minimising, maximising and moving the window in response to particular escape sequences). All of those functions are now provided by an abstraction called TermWin. The few remaining uses of Frontend after _that_ are internal to a particular platform directory, so as to spread the implementation of that particular kind of Frontend between multiple source files; so I've renamed all of those so that they take a more specifically named type that refers to the particular implementation rather than the general abstraction. So now the name 'Frontend' no longer exists in the code base at all, and everywhere one used to be used, it's completely clear whether it was operating in one of Frontend's three abstract roles (and if so, which), or whether it was specific to a particular implementation. Another type that's disappeared is 'Context', which used to be a typedef defined to something different on each platform, describing whatever short-lived resources were necessary to draw on the terminal window: the front end would provide a ready-made one when calling term_paint, and the terminal could request one with get_ctx/free_ctx if it wanted to do proactive window updates. Now that drawing context lives inside the TermWin itself, because there was never any need to have two of those contexts live at the same time. (Another minor API change is that the window-title functions - both reading and writing - have had a missing 'const' added to their char * parameters / return values.) I don't expect this change to enable any particularly interesting new functionality (in particular, I have no plans that need more than one implementation of TermWin in the same application). But it completes the tidying-up that began with the Seat and LogContext rework.
2018-10-25 17:44:04 +00:00
static void wintw_draw_text(TermWin *, int x, int y, wchar_t *text, int len,
unsigned long attrs, int lattrs, truecolour tc);
static void wintw_draw_cursor(TermWin *, int x, int y, wchar_t *text, int len,
unsigned long attrs, int lattrs, truecolour tc);
Add a TermWin method to draw a 'trust sigil'. This is not yet used by anything, but the idea is that it'll be a graphic in the terminal window that can't be replicated by a server sending escape sequences, and hence can be used as a reliable indication that the text on a particular terminal line is generated by PuTTY itself and not passed through from the server. This will make it possible to detect a malicious server trying to mimic local prompts to trick you out of information that shouldn't be sent over the wire (such as private-key passphrases). The trust sigil I've picked is a small copy of the PuTTY icon, which is thematically nice (it can be read as if the PuTTY icon is the name of the speaker in a dialogue) and also convenient because we had that graphic available already on all platforms. (Though the contortions I had to go through to make the GTK 1 code draw it were quite annoying.) The trust sigil has the same dimensions as a CJK double-width character, i.e. it's 2 character cells wide by 1 high.
2019-03-10 14:37:11 +00:00
static void wintw_draw_trust_sigil(TermWin *, int x, int y);
Remove the 'Frontend' type and replace it with a vtable. After the recent Seat and LogContext revamps, _nearly_ all the remaining uses of the type 'Frontend' were in terminal.c, which needs all sorts of interactions with the GUI window the terminal lives in, from the obvious (actually drawing text on the window, reading and writing the clipboard) to the obscure (minimising, maximising and moving the window in response to particular escape sequences). All of those functions are now provided by an abstraction called TermWin. The few remaining uses of Frontend after _that_ are internal to a particular platform directory, so as to spread the implementation of that particular kind of Frontend between multiple source files; so I've renamed all of those so that they take a more specifically named type that refers to the particular implementation rather than the general abstraction. So now the name 'Frontend' no longer exists in the code base at all, and everywhere one used to be used, it's completely clear whether it was operating in one of Frontend's three abstract roles (and if so, which), or whether it was specific to a particular implementation. Another type that's disappeared is 'Context', which used to be a typedef defined to something different on each platform, describing whatever short-lived resources were necessary to draw on the terminal window: the front end would provide a ready-made one when calling term_paint, and the terminal could request one with get_ctx/free_ctx if it wanted to do proactive window updates. Now that drawing context lives inside the TermWin itself, because there was never any need to have two of those contexts live at the same time. (Another minor API change is that the window-title functions - both reading and writing - have had a missing 'const' added to their char * parameters / return values.) I don't expect this change to enable any particularly interesting new functionality (in particular, I have no plans that need more than one implementation of TermWin in the same application). But it completes the tidying-up that began with the Seat and LogContext rework.
2018-10-25 17:44:04 +00:00
static int wintw_char_width(TermWin *, int uc);
static void wintw_free_draw_ctx(TermWin *);
static void wintw_set_cursor_pos(TermWin *, int x, int y);
Convert a lot of 'int' variables to 'bool'. My normal habit these days, in new code, is to treat int and bool as _almost_ completely separate types. I'm still willing to use C's implicit test for zero on an integer (e.g. 'if (!blob.len)' is fine, no need to spell it out as blob.len != 0), but generally, if a variable is going to be conceptually a boolean, I like to declare it bool and assign to it using 'true' or 'false' rather than 0 or 1. PuTTY is an exception, because it predates the C99 bool, and I've stuck to its existing coding style even when adding new code to it. But it's been annoying me more and more, so now that I've decided C99 bool is an acceptable thing to require from our toolchain in the first place, here's a quite thorough trawl through the source doing 'boolification'. Many variables and function parameters are now typed as bool rather than int; many assignments of 0 or 1 to those variables are now spelled 'true' or 'false'. I managed this thorough conversion with the help of a custom clang plugin that I wrote to trawl the AST and apply heuristics to point out where things might want changing. So I've even managed to do a decent job on parts of the code I haven't looked at in years! To make the plugin's work easier, I pushed platform front ends generally in the direction of using standard 'bool' in preference to platform-specific boolean types like Windows BOOL or GTK's gboolean; I've left the platform booleans in places they _have_ to be for the platform APIs to work right, but variables only used by my own code have been converted wherever I found them. In a few places there are int values that look very like booleans in _most_ of the places they're used, but have a rarely-used third value, or a distinction between different nonzero values that most users don't care about. In these cases, I've _removed_ uses of 'true' and 'false' for the return values, to emphasise that there's something more subtle going on than a simple boolean answer: - the 'multisel' field in dialog.h's list box structure, for which the GTK front end in particular recognises a difference between 1 and 2 but nearly everything else treats as boolean - the 'urgent' parameter to plug_receive, where 1 vs 2 tells you something about the specific location of the urgent pointer, but most clients only care about 0 vs 'something nonzero' - the return value of wc_match, where -1 indicates a syntax error in the wildcard. - the return values from SSH-1 RSA-key loading functions, which use -1 for 'wrong passphrase' and 0 for all other failures (so any caller which already knows it's not loading an _encrypted private_ key can treat them as boolean) - term->esc_query, and the 'query' parameter in toggle_mode in terminal.c, which _usually_ hold 0 for ESC[123h or 1 for ESC[?123h, but can also hold -1 for some other intervening character that we don't support. In a few places there's an integer that I haven't turned into a bool even though it really _can_ only take values 0 or 1 (and, as above, tried to make the call sites consistent in not calling those values true and false), on the grounds that I thought it would make it more confusing to imply that the 0 value was in some sense 'negative' or bad and the 1 positive or good: - the return value of plug_accepting uses the POSIXish convention of 0=success and nonzero=error; I think if I made it bool then I'd also want to reverse its sense, and that's a job for a separate piece of work. - the 'screen' parameter to lineptr() in terminal.c, where 0 and 1 represent the default and alternate screens. There's no obvious reason why one of those should be considered 'true' or 'positive' or 'success' - they're just indices - so I've left it as int. ssh_scp_recv had particularly confusing semantics for its previous int return value: its call sites used '<= 0' to check for error, but it never actually returned a negative number, just 0 or 1. Now the function and its call sites agree that it's a bool. In a couple of places I've renamed variables called 'ret', because I don't like that name any more - it's unclear whether it means the return value (in preparation) for the _containing_ function or the return value received from a subroutine call, and occasionally I've accidentally used the same variable for both and introduced a bug. So where one of those got in my way, I've renamed it to 'toret' or 'retd' (the latter short for 'returned') in line with my usual modern practice, but I haven't done a thorough job of finding all of them. Finally, one amusing side effect of doing this is that I've had to separate quite a few chained assignments. It used to be perfectly fine to write 'a = b = c = TRUE' when a,b,c were int and TRUE was just a the 'true' defined by stdbool.h, that idiom provokes a warning from gcc: 'suggest parentheses around assignment used as truth value'!
2018-11-02 19:23:19 +00:00
static void wintw_set_raw_mouse_mode(TermWin *, bool enable);
Decouple frontend's raw mouse mode from pointer shape. This paves the way for a followup commit that will make them happen at slightly different times.
2021-02-07 19:59:21 +00:00
static void wintw_set_raw_mouse_mode_pointer(TermWin *, bool enable);
Remove the 'Frontend' type and replace it with a vtable. After the recent Seat and LogContext revamps, _nearly_ all the remaining uses of the type 'Frontend' were in terminal.c, which needs all sorts of interactions with the GUI window the terminal lives in, from the obvious (actually drawing text on the window, reading and writing the clipboard) to the obscure (minimising, maximising and moving the window in response to particular escape sequences). All of those functions are now provided by an abstraction called TermWin. The few remaining uses of Frontend after _that_ are internal to a particular platform directory, so as to spread the implementation of that particular kind of Frontend between multiple source files; so I've renamed all of those so that they take a more specifically named type that refers to the particular implementation rather than the general abstraction. So now the name 'Frontend' no longer exists in the code base at all, and everywhere one used to be used, it's completely clear whether it was operating in one of Frontend's three abstract roles (and if so, which), or whether it was specific to a particular implementation. Another type that's disappeared is 'Context', which used to be a typedef defined to something different on each platform, describing whatever short-lived resources were necessary to draw on the terminal window: the front end would provide a ready-made one when calling term_paint, and the terminal could request one with get_ctx/free_ctx if it wanted to do proactive window updates. Now that drawing context lives inside the TermWin itself, because there was never any need to have two of those contexts live at the same time. (Another minor API change is that the window-title functions - both reading and writing - have had a missing 'const' added to their char * parameters / return values.) I don't expect this change to enable any particularly interesting new functionality (in particular, I have no plans that need more than one implementation of TermWin in the same application). But it completes the tidying-up that began with the Seat and LogContext rework.
2018-10-25 17:44:04 +00:00
static void wintw_set_scrollbar(TermWin *, int total, int start, int page);
static void wintw_bell(TermWin *, int mode);
static void wintw_clip_write(
TermWin *, int clipboard, wchar_t *text, int *attrs,
Convert a lot of 'int' variables to 'bool'. My normal habit these days, in new code, is to treat int and bool as _almost_ completely separate types. I'm still willing to use C's implicit test for zero on an integer (e.g. 'if (!blob.len)' is fine, no need to spell it out as blob.len != 0), but generally, if a variable is going to be conceptually a boolean, I like to declare it bool and assign to it using 'true' or 'false' rather than 0 or 1. PuTTY is an exception, because it predates the C99 bool, and I've stuck to its existing coding style even when adding new code to it. But it's been annoying me more and more, so now that I've decided C99 bool is an acceptable thing to require from our toolchain in the first place, here's a quite thorough trawl through the source doing 'boolification'. Many variables and function parameters are now typed as bool rather than int; many assignments of 0 or 1 to those variables are now spelled 'true' or 'false'. I managed this thorough conversion with the help of a custom clang plugin that I wrote to trawl the AST and apply heuristics to point out where things might want changing. So I've even managed to do a decent job on parts of the code I haven't looked at in years! To make the plugin's work easier, I pushed platform front ends generally in the direction of using standard 'bool' in preference to platform-specific boolean types like Windows BOOL or GTK's gboolean; I've left the platform booleans in places they _have_ to be for the platform APIs to work right, but variables only used by my own code have been converted wherever I found them. In a few places there are int values that look very like booleans in _most_ of the places they're used, but have a rarely-used third value, or a distinction between different nonzero values that most users don't care about. In these cases, I've _removed_ uses of 'true' and 'false' for the return values, to emphasise that there's something more subtle going on than a simple boolean answer: - the 'multisel' field in dialog.h's list box structure, for which the GTK front end in particular recognises a difference between 1 and 2 but nearly everything else treats as boolean - the 'urgent' parameter to plug_receive, where 1 vs 2 tells you something about the specific location of the urgent pointer, but most clients only care about 0 vs 'something nonzero' - the return value of wc_match, where -1 indicates a syntax error in the wildcard. - the return values from SSH-1 RSA-key loading functions, which use -1 for 'wrong passphrase' and 0 for all other failures (so any caller which already knows it's not loading an _encrypted private_ key can treat them as boolean) - term->esc_query, and the 'query' parameter in toggle_mode in terminal.c, which _usually_ hold 0 for ESC[123h or 1 for ESC[?123h, but can also hold -1 for some other intervening character that we don't support. In a few places there's an integer that I haven't turned into a bool even though it really _can_ only take values 0 or 1 (and, as above, tried to make the call sites consistent in not calling those values true and false), on the grounds that I thought it would make it more confusing to imply that the 0 value was in some sense 'negative' or bad and the 1 positive or good: - the return value of plug_accepting uses the POSIXish convention of 0=success and nonzero=error; I think if I made it bool then I'd also want to reverse its sense, and that's a job for a separate piece of work. - the 'screen' parameter to lineptr() in terminal.c, where 0 and 1 represent the default and alternate screens. There's no obvious reason why one of those should be considered 'true' or 'positive' or 'success' - they're just indices - so I've left it as int. ssh_scp_recv had particularly confusing semantics for its previous int return value: its call sites used '<= 0' to check for error, but it never actually returned a negative number, just 0 or 1. Now the function and its call sites agree that it's a bool. In a couple of places I've renamed variables called 'ret', because I don't like that name any more - it's unclear whether it means the return value (in preparation) for the _containing_ function or the return value received from a subroutine call, and occasionally I've accidentally used the same variable for both and introduced a bug. So where one of those got in my way, I've renamed it to 'toret' or 'retd' (the latter short for 'returned') in line with my usual modern practice, but I haven't done a thorough job of finding all of them. Finally, one amusing side effect of doing this is that I've had to separate quite a few chained assignments. It used to be perfectly fine to write 'a = b = c = TRUE' when a,b,c were int and TRUE was just a the 'true' defined by stdbool.h, that idiom provokes a warning from gcc: 'suggest parentheses around assignment used as truth value'!
2018-11-02 19:23:19 +00:00
truecolour *colours, int len, bool must_deselect);
Remove the 'Frontend' type and replace it with a vtable. After the recent Seat and LogContext revamps, _nearly_ all the remaining uses of the type 'Frontend' were in terminal.c, which needs all sorts of interactions with the GUI window the terminal lives in, from the obvious (actually drawing text on the window, reading and writing the clipboard) to the obscure (minimising, maximising and moving the window in response to particular escape sequences). All of those functions are now provided by an abstraction called TermWin. The few remaining uses of Frontend after _that_ are internal to a particular platform directory, so as to spread the implementation of that particular kind of Frontend between multiple source files; so I've renamed all of those so that they take a more specifically named type that refers to the particular implementation rather than the general abstraction. So now the name 'Frontend' no longer exists in the code base at all, and everywhere one used to be used, it's completely clear whether it was operating in one of Frontend's three abstract roles (and if so, which), or whether it was specific to a particular implementation. Another type that's disappeared is 'Context', which used to be a typedef defined to something different on each platform, describing whatever short-lived resources were necessary to draw on the terminal window: the front end would provide a ready-made one when calling term_paint, and the terminal could request one with get_ctx/free_ctx if it wanted to do proactive window updates. Now that drawing context lives inside the TermWin itself, because there was never any need to have two of those contexts live at the same time. (Another minor API change is that the window-title functions - both reading and writing - have had a missing 'const' added to their char * parameters / return values.) I don't expect this change to enable any particularly interesting new functionality (in particular, I have no plans that need more than one implementation of TermWin in the same application). But it completes the tidying-up that began with the Seat and LogContext rework.
2018-10-25 17:44:04 +00:00
static void wintw_clip_request_paste(TermWin *, int clipboard);
static void wintw_refresh(TermWin *);
static void wintw_request_resize(TermWin *, int w, int h);
win_set_[icon_]title: send a codepage along with the string. While fixing the previous commit I noticed that window titles don't actually _work_ properly if you change the terminal character set, because the text accumulated in the OSC string buffer is sent to the TermWin as raw bytes, with no indication of what character set it should interpret them as. You might get lucky if you happened to choose the right charset (in particular, UTF-8 is a common default), but if you change the charset half way through a run, then there's certainly no way the frontend will know to interpret two window titles sent before and after the change in two different charsets. So, now win_set_title() and win_set_icon_title() both include a codepage parameter along with the byte string, and it's up to them to translate the provided window title from that encoding to whatever the local window system expects to receive. On Windows, that's wide-string Unicode, so we can just use the existing dup_mb_to_wc utility function. But in GTK, it's UTF-8, so I had to write an extra utility function to encode a wide string as UTF-8.
2021-10-16 12:20:44 +00:00
static void wintw_set_title(TermWin *, const char *title, int codepage);
static void wintw_set_icon_title(TermWin *, const char *icontitle,
int codepage);
Convert a lot of 'int' variables to 'bool'. My normal habit these days, in new code, is to treat int and bool as _almost_ completely separate types. I'm still willing to use C's implicit test for zero on an integer (e.g. 'if (!blob.len)' is fine, no need to spell it out as blob.len != 0), but generally, if a variable is going to be conceptually a boolean, I like to declare it bool and assign to it using 'true' or 'false' rather than 0 or 1. PuTTY is an exception, because it predates the C99 bool, and I've stuck to its existing coding style even when adding new code to it. But it's been annoying me more and more, so now that I've decided C99 bool is an acceptable thing to require from our toolchain in the first place, here's a quite thorough trawl through the source doing 'boolification'. Many variables and function parameters are now typed as bool rather than int; many assignments of 0 or 1 to those variables are now spelled 'true' or 'false'. I managed this thorough conversion with the help of a custom clang plugin that I wrote to trawl the AST and apply heuristics to point out where things might want changing. So I've even managed to do a decent job on parts of the code I haven't looked at in years! To make the plugin's work easier, I pushed platform front ends generally in the direction of using standard 'bool' in preference to platform-specific boolean types like Windows BOOL or GTK's gboolean; I've left the platform booleans in places they _have_ to be for the platform APIs to work right, but variables only used by my own code have been converted wherever I found them. In a few places there are int values that look very like booleans in _most_ of the places they're used, but have a rarely-used third value, or a distinction between different nonzero values that most users don't care about. In these cases, I've _removed_ uses of 'true' and 'false' for the return values, to emphasise that there's something more subtle going on than a simple boolean answer: - the 'multisel' field in dialog.h's list box structure, for which the GTK front end in particular recognises a difference between 1 and 2 but nearly everything else treats as boolean - the 'urgent' parameter to plug_receive, where 1 vs 2 tells you something about the specific location of the urgent pointer, but most clients only care about 0 vs 'something nonzero' - the return value of wc_match, where -1 indicates a syntax error in the wildcard. - the return values from SSH-1 RSA-key loading functions, which use -1 for 'wrong passphrase' and 0 for all other failures (so any caller which already knows it's not loading an _encrypted private_ key can treat them as boolean) - term->esc_query, and the 'query' parameter in toggle_mode in terminal.c, which _usually_ hold 0 for ESC[123h or 1 for ESC[?123h, but can also hold -1 for some other intervening character that we don't support. In a few places there's an integer that I haven't turned into a bool even though it really _can_ only take values 0 or 1 (and, as above, tried to make the call sites consistent in not calling those values true and false), on the grounds that I thought it would make it more confusing to imply that the 0 value was in some sense 'negative' or bad and the 1 positive or good: - the return value of plug_accepting uses the POSIXish convention of 0=success and nonzero=error; I think if I made it bool then I'd also want to reverse its sense, and that's a job for a separate piece of work. - the 'screen' parameter to lineptr() in terminal.c, where 0 and 1 represent the default and alternate screens. There's no obvious reason why one of those should be considered 'true' or 'positive' or 'success' - they're just indices - so I've left it as int. ssh_scp_recv had particularly confusing semantics for its previous int return value: its call sites used '<= 0' to check for error, but it never actually returned a negative number, just 0 or 1. Now the function and its call sites agree that it's a bool. In a couple of places I've renamed variables called 'ret', because I don't like that name any more - it's unclear whether it means the return value (in preparation) for the _containing_ function or the return value received from a subroutine call, and occasionally I've accidentally used the same variable for both and introduced a bug. So where one of those got in my way, I've renamed it to 'toret' or 'retd' (the latter short for 'returned') in line with my usual modern practice, but I haven't done a thorough job of finding all of them. Finally, one amusing side effect of doing this is that I've had to separate quite a few chained assignments. It used to be perfectly fine to write 'a = b = c = TRUE' when a,b,c were int and TRUE was just a the 'true' defined by stdbool.h, that idiom provokes a warning from gcc: 'suggest parentheses around assignment used as truth value'!
2018-11-02 19:23:19 +00:00
static void wintw_set_minimised(TermWin *, bool minimised);
static void wintw_set_maximised(TermWin *, bool maximised);
Remove the 'Frontend' type and replace it with a vtable. After the recent Seat and LogContext revamps, _nearly_ all the remaining uses of the type 'Frontend' were in terminal.c, which needs all sorts of interactions with the GUI window the terminal lives in, from the obvious (actually drawing text on the window, reading and writing the clipboard) to the obscure (minimising, maximising and moving the window in response to particular escape sequences). All of those functions are now provided by an abstraction called TermWin. The few remaining uses of Frontend after _that_ are internal to a particular platform directory, so as to spread the implementation of that particular kind of Frontend between multiple source files; so I've renamed all of those so that they take a more specifically named type that refers to the particular implementation rather than the general abstraction. So now the name 'Frontend' no longer exists in the code base at all, and everywhere one used to be used, it's completely clear whether it was operating in one of Frontend's three abstract roles (and if so, which), or whether it was specific to a particular implementation. Another type that's disappeared is 'Context', which used to be a typedef defined to something different on each platform, describing whatever short-lived resources were necessary to draw on the terminal window: the front end would provide a ready-made one when calling term_paint, and the terminal could request one with get_ctx/free_ctx if it wanted to do proactive window updates. Now that drawing context lives inside the TermWin itself, because there was never any need to have two of those contexts live at the same time. (Another minor API change is that the window-title functions - both reading and writing - have had a missing 'const' added to their char * parameters / return values.) I don't expect this change to enable any particularly interesting new functionality (in particular, I have no plans that need more than one implementation of TermWin in the same application). But it completes the tidying-up that began with the Seat and LogContext rework.
2018-10-25 17:44:04 +00:00
static void wintw_move(TermWin *, int x, int y);
Convert a lot of 'int' variables to 'bool'. My normal habit these days, in new code, is to treat int and bool as _almost_ completely separate types. I'm still willing to use C's implicit test for zero on an integer (e.g. 'if (!blob.len)' is fine, no need to spell it out as blob.len != 0), but generally, if a variable is going to be conceptually a boolean, I like to declare it bool and assign to it using 'true' or 'false' rather than 0 or 1. PuTTY is an exception, because it predates the C99 bool, and I've stuck to its existing coding style even when adding new code to it. But it's been annoying me more and more, so now that I've decided C99 bool is an acceptable thing to require from our toolchain in the first place, here's a quite thorough trawl through the source doing 'boolification'. Many variables and function parameters are now typed as bool rather than int; many assignments of 0 or 1 to those variables are now spelled 'true' or 'false'. I managed this thorough conversion with the help of a custom clang plugin that I wrote to trawl the AST and apply heuristics to point out where things might want changing. So I've even managed to do a decent job on parts of the code I haven't looked at in years! To make the plugin's work easier, I pushed platform front ends generally in the direction of using standard 'bool' in preference to platform-specific boolean types like Windows BOOL or GTK's gboolean; I've left the platform booleans in places they _have_ to be for the platform APIs to work right, but variables only used by my own code have been converted wherever I found them. In a few places there are int values that look very like booleans in _most_ of the places they're used, but have a rarely-used third value, or a distinction between different nonzero values that most users don't care about. In these cases, I've _removed_ uses of 'true' and 'false' for the return values, to emphasise that there's something more subtle going on than a simple boolean answer: - the 'multisel' field in dialog.h's list box structure, for which the GTK front end in particular recognises a difference between 1 and 2 but nearly everything else treats as boolean - the 'urgent' parameter to plug_receive, where 1 vs 2 tells you something about the specific location of the urgent pointer, but most clients only care about 0 vs 'something nonzero' - the return value of wc_match, where -1 indicates a syntax error in the wildcard. - the return values from SSH-1 RSA-key loading functions, which use -1 for 'wrong passphrase' and 0 for all other failures (so any caller which already knows it's not loading an _encrypted private_ key can treat them as boolean) - term->esc_query, and the 'query' parameter in toggle_mode in terminal.c, which _usually_ hold 0 for ESC[123h or 1 for ESC[?123h, but can also hold -1 for some other intervening character that we don't support. In a few places there's an integer that I haven't turned into a bool even though it really _can_ only take values 0 or 1 (and, as above, tried to make the call sites consistent in not calling those values true and false), on the grounds that I thought it would make it more confusing to imply that the 0 value was in some sense 'negative' or bad and the 1 positive or good: - the return value of plug_accepting uses the POSIXish convention of 0=success and nonzero=error; I think if I made it bool then I'd also want to reverse its sense, and that's a job for a separate piece of work. - the 'screen' parameter to lineptr() in terminal.c, where 0 and 1 represent the default and alternate screens. There's no obvious reason why one of those should be considered 'true' or 'positive' or 'success' - they're just indices - so I've left it as int. ssh_scp_recv had particularly confusing semantics for its previous int return value: its call sites used '<= 0' to check for error, but it never actually returned a negative number, just 0 or 1. Now the function and its call sites agree that it's a bool. In a couple of places I've renamed variables called 'ret', because I don't like that name any more - it's unclear whether it means the return value (in preparation) for the _containing_ function or the return value received from a subroutine call, and occasionally I've accidentally used the same variable for both and introduced a bug. So where one of those got in my way, I've renamed it to 'toret' or 'retd' (the latter short for 'returned') in line with my usual modern practice, but I haven't done a thorough job of finding all of them. Finally, one amusing side effect of doing this is that I've had to separate quite a few chained assignments. It used to be perfectly fine to write 'a = b = c = TRUE' when a,b,c were int and TRUE was just a the 'true' defined by stdbool.h, that idiom provokes a warning from gcc: 'suggest parentheses around assignment used as truth value'!
2018-11-02 19:23:19 +00:00
static void wintw_set_zorder(TermWin *, bool top);
Centralise palette setup into terminal.c. Now terminal.c makes nearly all the decisions about what the colour palette should actually contain: it does the job of reading the GUI-configurable colours out of Conf, and also the job of making up the rest of the xterm-256 palette. The only exception is that TermWin can provide a method to override some of the default colours, which on Windows is used to implement the 'Use system colours' config option. This saves code overall, partly because the front ends don't have to be able to send palette data back to the Terminal any more (the Terminal keeps the master copy and can answer palette-query escape sequences from its own knowledge), and also because now there's only one copy of the xterm-256 palette setup code (previously gtkwin.c and window.c each had their own version of it). In this rewrite, I've also introduced a multi-layered storage system for the palette data in Terminal. One layer contains the palette information derived from Conf; the next contains platform overrides (currently just Windows's 'Use system colours'); the last one contains overrides set by escape sequences in the middle of the session. The topmost two layers can each _conditionally_ override the ones below. As a result, if a server-side application manually resets (say) the default fg and bg colours in mid-session to something that works well in a particular application, those changes won't be wiped out by a change in the Windows system colours or the Conf, which they would have been before. Instead, changes in Conf or the system colours alter the lower layers of the structure, but then when palette_rebuild is called, the upper layer continues to override them, until a palette reset (ESC]R) or terminal reset (e.g. ESC c) removes those upper-layer changes. This seems like a more consistent strategy, in that the same set of configuration settings will produce the same end result regardless of what order they were applied in. The palette-related methods in TermWin have had a total rework. palette_get and palette_reset are both gone; palette_set can now set a contiguous range of colours in one go; and the new palette_get_overrides replaces window.c's old systopalette().
2021-02-07 19:59:21 +00:00
static void wintw_palette_set(TermWin *, unsigned, unsigned, const rgb *);
Make TermWin's palette_get_overrides() take a Terminal *. Less than 12 hours after 0.75 went out of the door, a user pointed out that enabling the 'Use system colours' config option causes an immediate NULL-dereference crash. The reason is because a chain of calls from term_init() ends up calling back to the Windows implementation of the palette_get_overrides() method, which responds by trying to call functions on the static variable 'term' in window.c, which won't be initialised until term_init() has returned. Simple fix: palette_get_overrides() is now given a pointer to the Terminal that it should be updating, because it can't find it out any other way.
2021-05-08 17:13:06 +00:00
static void wintw_palette_get_overrides(TermWin *, Terminal *);
Proper buffer management between terminal and backend. The return value of term_data() is used as the return value from the GUI-terminal versions of the Seat output method, which means backends will take it to be the amount of standard-output data currently buffered, and exert back-pressure on the remote peer if it gets too big (e.g. by ceasing to extend the window in that particular SSH-2 channel). Historically, as a comment in term_data() explained, we always just returned 0 from that function, on the basis that we were processing all the terminal data through our terminal emulation code immediately, and never retained any of it in the buffer at all. If the terminal emulation code were to start running slowly, then it would slow down the _whole_ PuTTY system, due to single-threadedness, and back-pressure of a sort would be exerted on the remote by it simply failing to get round to reading from the network socket. But by the time we got back to the top level of term_data(), we'd have finished reading all the data we had, so it was still appropriate to return 0. That comment is still correct if you're thinking about the limiting factor on terminal data processing being the CPU usage in term_out(). But now that's no longer the whole story, because sometimes we leave data in term->inbuf without having processed it: during drag-selects in the terminal window, and (just introduced) while waiting for the response to a pending window resize request. For both those reasons, we _don't_ always have a buffer size of zero when we return from term_data(). So now that hole in our buffer size management is filled in: term_data() returns the true size of the remaining unprocessed terminal output, so that back-pressure will be exerted if the terminal is currently not consuming it. And when processing resumes and we start to clear our backlog, we call backend_unthrottle to let the backend know it can relax the back-pressure if necessary.
2021-12-12 10:57:23 +00:00
static void wintw_unthrottle(TermWin *win, size_t bufsize);
Remove the 'Frontend' type and replace it with a vtable. After the recent Seat and LogContext revamps, _nearly_ all the remaining uses of the type 'Frontend' were in terminal.c, which needs all sorts of interactions with the GUI window the terminal lives in, from the obvious (actually drawing text on the window, reading and writing the clipboard) to the obscure (minimising, maximising and moving the window in response to particular escape sequences). All of those functions are now provided by an abstraction called TermWin. The few remaining uses of Frontend after _that_ are internal to a particular platform directory, so as to spread the implementation of that particular kind of Frontend between multiple source files; so I've renamed all of those so that they take a more specifically named type that refers to the particular implementation rather than the general abstraction. So now the name 'Frontend' no longer exists in the code base at all, and everywhere one used to be used, it's completely clear whether it was operating in one of Frontend's three abstract roles (and if so, which), or whether it was specific to a particular implementation. Another type that's disappeared is 'Context', which used to be a typedef defined to something different on each platform, describing whatever short-lived resources were necessary to draw on the terminal window: the front end would provide a ready-made one when calling term_paint, and the terminal could request one with get_ctx/free_ctx if it wanted to do proactive window updates. Now that drawing context lives inside the TermWin itself, because there was never any need to have two of those contexts live at the same time. (Another minor API change is that the window-title functions - both reading and writing - have had a missing 'const' added to their char * parameters / return values.) I don't expect this change to enable any particularly interesting new functionality (in particular, I have no plans that need more than one implementation of TermWin in the same application). But it completes the tidying-up that began with the Seat and LogContext rework.
2018-10-25 17:44:04 +00:00
static const TermWinVtable windows_termwin_vt = {
Change vtable defs to use C99 designated initialisers. This is a sweeping change applied across the whole code base by a spot of Emacs Lisp. Now, everywhere I declare a vtable filled with function pointers (and the occasional const data member), all the members of the vtable structure are initialised by name using the '.fieldname = value' syntax introduced in C99. We were already using this syntax for a handful of things in the new key-generation progress report system, so it's not new to the code base as a whole. The advantage is that now, when a vtable only declares a subset of the available fields, I can initialise the rest to NULL or zero just by leaving them out. This is most dramatic in a couple of the outlying vtables in things like psocks (which has a ConnectionLayerVtable containing only one non-NULL method), but less dramatically, it means that the new 'flags' field in BackendVtable can be completely left out of every backend definition except for the SUPDUP one which defines it to a nonzero value. Similarly, the test_for_upstream method only used by SSH doesn't have to be mentioned in the rest of the backends; network Plugs for listening sockets don't have to explicitly null out 'receive' and 'sent', and vice versa for 'accepting', and so on. While I'm at it, I've normalised the declarations so they don't use the unnecessarily verbose 'struct' keyword. Also a handful of them weren't const; now they are.
2020-03-10 21:06:29 +00:00
.setup_draw_ctx = wintw_setup_draw_ctx,
.draw_text = wintw_draw_text,
.draw_cursor = wintw_draw_cursor,
.draw_trust_sigil = wintw_draw_trust_sigil,
.char_width = wintw_char_width,
.free_draw_ctx = wintw_free_draw_ctx,
.set_cursor_pos = wintw_set_cursor_pos,
.set_raw_mouse_mode = wintw_set_raw_mouse_mode,
Decouple frontend's raw mouse mode from pointer shape. This paves the way for a followup commit that will make them happen at slightly different times.
2021-02-07 19:59:21 +00:00
.set_raw_mouse_mode_pointer = wintw_set_raw_mouse_mode_pointer,
Change vtable defs to use C99 designated initialisers. This is a sweeping change applied across the whole code base by a spot of Emacs Lisp. Now, everywhere I declare a vtable filled with function pointers (and the occasional const data member), all the members of the vtable structure are initialised by name using the '.fieldname = value' syntax introduced in C99. We were already using this syntax for a handful of things in the new key-generation progress report system, so it's not new to the code base as a whole. The advantage is that now, when a vtable only declares a subset of the available fields, I can initialise the rest to NULL or zero just by leaving them out. This is most dramatic in a couple of the outlying vtables in things like psocks (which has a ConnectionLayerVtable containing only one non-NULL method), but less dramatically, it means that the new 'flags' field in BackendVtable can be completely left out of every backend definition except for the SUPDUP one which defines it to a nonzero value. Similarly, the test_for_upstream method only used by SSH doesn't have to be mentioned in the rest of the backends; network Plugs for listening sockets don't have to explicitly null out 'receive' and 'sent', and vice versa for 'accepting', and so on. While I'm at it, I've normalised the declarations so they don't use the unnecessarily verbose 'struct' keyword. Also a handful of them weren't const; now they are.
2020-03-10 21:06:29 +00:00
.set_scrollbar = wintw_set_scrollbar,
.bell = wintw_bell,
.clip_write = wintw_clip_write,
.clip_request_paste = wintw_clip_request_paste,
.refresh = wintw_refresh,
.request_resize = wintw_request_resize,
.set_title = wintw_set_title,
.set_icon_title = wintw_set_icon_title,
.set_minimised = wintw_set_minimised,
.set_maximised = wintw_set_maximised,
.move = wintw_move,
.set_zorder = wintw_set_zorder,
.palette_set = wintw_palette_set,
Centralise palette setup into terminal.c. Now terminal.c makes nearly all the decisions about what the colour palette should actually contain: it does the job of reading the GUI-configurable colours out of Conf, and also the job of making up the rest of the xterm-256 palette. The only exception is that TermWin can provide a method to override some of the default colours, which on Windows is used to implement the 'Use system colours' config option. This saves code overall, partly because the front ends don't have to be able to send palette data back to the Terminal any more (the Terminal keeps the master copy and can answer palette-query escape sequences from its own knowledge), and also because now there's only one copy of the xterm-256 palette setup code (previously gtkwin.c and window.c each had their own version of it). In this rewrite, I've also introduced a multi-layered storage system for the palette data in Terminal. One layer contains the palette information derived from Conf; the next contains platform overrides (currently just Windows's 'Use system colours'); the last one contains overrides set by escape sequences in the middle of the session. The topmost two layers can each _conditionally_ override the ones below. As a result, if a server-side application manually resets (say) the default fg and bg colours in mid-session to something that works well in a particular application, those changes won't be wiped out by a change in the Windows system colours or the Conf, which they would have been before. Instead, changes in Conf or the system colours alter the lower layers of the structure, but then when palette_rebuild is called, the upper layer continues to override them, until a palette reset (ESC]R) or terminal reset (e.g. ESC c) removes those upper-layer changes. This seems like a more consistent strategy, in that the same set of configuration settings will produce the same end result regardless of what order they were applied in. The palette-related methods in TermWin have had a total rework. palette_get and palette_reset are both gone; palette_set can now set a contiguous range of colours in one go; and the new palette_get_overrides replaces window.c's old systopalette().
2021-02-07 19:59:21 +00:00
.palette_get_overrides = wintw_palette_get_overrides,
Proper buffer management between terminal and backend. The return value of term_data() is used as the return value from the GUI-terminal versions of the Seat output method, which means backends will take it to be the amount of standard-output data currently buffered, and exert back-pressure on the remote peer if it gets too big (e.g. by ceasing to extend the window in that particular SSH-2 channel). Historically, as a comment in term_data() explained, we always just returned 0 from that function, on the basis that we were processing all the terminal data through our terminal emulation code immediately, and never retained any of it in the buffer at all. If the terminal emulation code were to start running slowly, then it would slow down the _whole_ PuTTY system, due to single-threadedness, and back-pressure of a sort would be exerted on the remote by it simply failing to get round to reading from the network socket. But by the time we got back to the top level of term_data(), we'd have finished reading all the data we had, so it was still appropriate to return 0. That comment is still correct if you're thinking about the limiting factor on terminal data processing being the CPU usage in term_out(). But now that's no longer the whole story, because sometimes we leave data in term->inbuf without having processed it: during drag-selects in the terminal window, and (just introduced) while waiting for the response to a pending window resize request. For both those reasons, we _don't_ always have a buffer size of zero when we return from term_data(). So now that hole in our buffer size management is filled in: term_data() returns the true size of the remaining unprocessed terminal output, so that back-pressure will be exerted if the terminal is currently not consuming it. And when processing resumes and we start to clear our backlog, we call backend_unthrottle to let the backend know it can relax the back-pressure if necessary.
2021-12-12 10:57:23 +00:00
.unthrottle = wintw_unthrottle,
Remove the 'Frontend' type and replace it with a vtable. After the recent Seat and LogContext revamps, _nearly_ all the remaining uses of the type 'Frontend' were in terminal.c, which needs all sorts of interactions with the GUI window the terminal lives in, from the obvious (actually drawing text on the window, reading and writing the clipboard) to the obscure (minimising, maximising and moving the window in response to particular escape sequences). All of those functions are now provided by an abstraction called TermWin. The few remaining uses of Frontend after _that_ are internal to a particular platform directory, so as to spread the implementation of that particular kind of Frontend between multiple source files; so I've renamed all of those so that they take a more specifically named type that refers to the particular implementation rather than the general abstraction. So now the name 'Frontend' no longer exists in the code base at all, and everywhere one used to be used, it's completely clear whether it was operating in one of Frontend's three abstract roles (and if so, which), or whether it was specific to a particular implementation. Another type that's disappeared is 'Context', which used to be a typedef defined to something different on each platform, describing whatever short-lived resources were necessary to draw on the terminal window: the front end would provide a ready-made one when calling term_paint, and the terminal could request one with get_ctx/free_ctx if it wanted to do proactive window updates. Now that drawing context lives inside the TermWin itself, because there was never any need to have two of those contexts live at the same time. (Another minor API change is that the window-title functions - both reading and writing - have had a missing 'const' added to their char * parameters / return values.) I don't expect this change to enable any particularly interesting new functionality (in particular, I have no plans that need more than one implementation of TermWin in the same application). But it completes the tidying-up that began with the Seat and LogContext rework.
2018-10-25 17:44:04 +00:00
};
Slightly nicer trust sigil on Windows. Re-consider the icon in light of the font size, so that we pick the icon whose size mostly closely matches the terminal font, rather than always scaling the default icon.
2019-03-30 15:44:01 +00:00
static HICON trust_icon = INVALID_HANDLE_VALUE;
Add a TermWin method to draw a 'trust sigil'. This is not yet used by anything, but the idea is that it'll be a graphic in the terminal window that can't be replicated by a server sending escape sequences, and hence can be used as a reliable indication that the text on a particular terminal line is generated by PuTTY itself and not passed through from the server. This will make it possible to detect a malicious server trying to mimic local prompts to trick you out of information that shouldn't be sent over the wire (such as private-key passphrases). The trust sigil I've picked is a small copy of the PuTTY icon, which is thematically nice (it can be read as if the PuTTY icon is the name of the speaker in a dialogue) and also convenient because we had that graphic available already on all platforms. (Though the contortions I had to go through to make the GTK 1 code draw it were quite annoying.) The trust sigil has the same dimensions as a CJK double-width character, i.e. it's 2 character cells wide by 1 high.
2019-03-10 14:37:11 +00:00
Convert a lot of 'int' variables to 'bool'. My normal habit these days, in new code, is to treat int and bool as _almost_ completely separate types. I'm still willing to use C's implicit test for zero on an integer (e.g. 'if (!blob.len)' is fine, no need to spell it out as blob.len != 0), but generally, if a variable is going to be conceptually a boolean, I like to declare it bool and assign to it using 'true' or 'false' rather than 0 or 1. PuTTY is an exception, because it predates the C99 bool, and I've stuck to its existing coding style even when adding new code to it. But it's been annoying me more and more, so now that I've decided C99 bool is an acceptable thing to require from our toolchain in the first place, here's a quite thorough trawl through the source doing 'boolification'. Many variables and function parameters are now typed as bool rather than int; many assignments of 0 or 1 to those variables are now spelled 'true' or 'false'. I managed this thorough conversion with the help of a custom clang plugin that I wrote to trawl the AST and apply heuristics to point out where things might want changing. So I've even managed to do a decent job on parts of the code I haven't looked at in years! To make the plugin's work easier, I pushed platform front ends generally in the direction of using standard 'bool' in preference to platform-specific boolean types like Windows BOOL or GTK's gboolean; I've left the platform booleans in places they _have_ to be for the platform APIs to work right, but variables only used by my own code have been converted wherever I found them. In a few places there are int values that look very like booleans in _most_ of the places they're used, but have a rarely-used third value, or a distinction between different nonzero values that most users don't care about. In these cases, I've _removed_ uses of 'true' and 'false' for the return values, to emphasise that there's something more subtle going on than a simple boolean answer: - the 'multisel' field in dialog.h's list box structure, for which the GTK front end in particular recognises a difference between 1 and 2 but nearly everything else treats as boolean - the 'urgent' parameter to plug_receive, where 1 vs 2 tells you something about the specific location of the urgent pointer, but most clients only care about 0 vs 'something nonzero' - the return value of wc_match, where -1 indicates a syntax error in the wildcard. - the return values from SSH-1 RSA-key loading functions, which use -1 for 'wrong passphrase' and 0 for all other failures (so any caller which already knows it's not loading an _encrypted private_ key can treat them as boolean) - term->esc_query, and the 'query' parameter in toggle_mode in terminal.c, which _usually_ hold 0 for ESC[123h or 1 for ESC[?123h, but can also hold -1 for some other intervening character that we don't support. In a few places there's an integer that I haven't turned into a bool even though it really _can_ only take values 0 or 1 (and, as above, tried to make the call sites consistent in not calling those values true and false), on the grounds that I thought it would make it more confusing to imply that the 0 value was in some sense 'negative' or bad and the 1 positive or good: - the return value of plug_accepting uses the POSIXish convention of 0=success and nonzero=error; I think if I made it bool then I'd also want to reverse its sense, and that's a job for a separate piece of work. - the 'screen' parameter to lineptr() in terminal.c, where 0 and 1 represent the default and alternate screens. There's no obvious reason why one of those should be considered 'true' or 'positive' or 'success' - they're just indices - so I've left it as int. ssh_scp_recv had particularly confusing semantics for its previous int return value: its call sites used '<= 0' to check for error, but it never actually returned a negative number, just 0 or 1. Now the function and its call sites agree that it's a bool. In a couple of places I've renamed variables called 'ret', because I don't like that name any more - it's unclear whether it means the return value (in preparation) for the _containing_ function or the return value received from a subroutine call, and occasionally I've accidentally used the same variable for both and introduced a bug. So where one of those got in my way, I've renamed it to 'toret' or 'retd' (the latter short for 'returned') in line with my usual modern practice, but I haven't done a thorough job of finding all of them. Finally, one amusing side effect of doing this is that I've had to separate quite a few chained assignments. It used to be perfectly fine to write 'a = b = c = TRUE' when a,b,c were int and TRUE was just a the 'true' defined by stdbool.h, that idiom provokes a warning from gcc: 'suggest parentheses around assignment used as truth value'!
2018-11-02 19:23:19 +00:00
const bool share_can_be_downstream = true;
const bool share_can_be_upstream = true;
Implement connection sharing between instances of PuTTY. The basic strategy is described at the top of the new source file sshshare.c. In very brief: an 'upstream' PuTTY opens a Unix-domain socket or Windows named pipe, and listens for connections from other PuTTYs wanting to run sessions on the same server. The protocol spoken down that socket/pipe is essentially the bare ssh-connection protocol, using a trivial binary packet protocol with no encryption, and the upstream has to do some fiddly transformations that I've been referring to as 'channel-number NAT' to avoid resource clashes between the sessions it's managing. This is quite different from OpenSSH's approach of using the Unix- domain socket as a means of passing file descriptors around; the main reason for that is that fd-passing is Unix-specific but this system has to work on Windows too. However, there are additional advantages, such as making it easy for each downstream PuTTY to run its own independent set of port and X11 forwardings (though the method for making the latter work is quite painful). Sharing is off by default, but configuration is intended to be very easy in the normal case - just tick one box in the SSH config panel and everything else happens automatically. [originally from svn r10083]
2013-11-17 14:05:41 +00:00
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
static bool is_utf8(WinGuiSeat *wgs)
Run entire source base through GNU indent to tidy up the varying coding styles of the various contributors! Woohoo! [originally from svn r1098]
2001-05-06 14:35:20 +00:00
{
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
return wgs->ucsdata.line_codepage == CP_UTF8;
Run entire source base through GNU indent to tidy up the varying coding styles of the various contributors! Woohoo! [originally from svn r1098]
2001-05-06 14:35:20 +00:00
}
Bug fix: line discipline selection is not enabled until after ssh authentication phase to stop user/password prompts behaving oddly [originally from svn r614]
2000-09-22 13:10:19 +00:00
Convert a lot of 'int' variables to 'bool'. My normal habit these days, in new code, is to treat int and bool as _almost_ completely separate types. I'm still willing to use C's implicit test for zero on an integer (e.g. 'if (!blob.len)' is fine, no need to spell it out as blob.len != 0), but generally, if a variable is going to be conceptually a boolean, I like to declare it bool and assign to it using 'true' or 'false' rather than 0 or 1. PuTTY is an exception, because it predates the C99 bool, and I've stuck to its existing coding style even when adding new code to it. But it's been annoying me more and more, so now that I've decided C99 bool is an acceptable thing to require from our toolchain in the first place, here's a quite thorough trawl through the source doing 'boolification'. Many variables and function parameters are now typed as bool rather than int; many assignments of 0 or 1 to those variables are now spelled 'true' or 'false'. I managed this thorough conversion with the help of a custom clang plugin that I wrote to trawl the AST and apply heuristics to point out where things might want changing. So I've even managed to do a decent job on parts of the code I haven't looked at in years! To make the plugin's work easier, I pushed platform front ends generally in the direction of using standard 'bool' in preference to platform-specific boolean types like Windows BOOL or GTK's gboolean; I've left the platform booleans in places they _have_ to be for the platform APIs to work right, but variables only used by my own code have been converted wherever I found them. In a few places there are int values that look very like booleans in _most_ of the places they're used, but have a rarely-used third value, or a distinction between different nonzero values that most users don't care about. In these cases, I've _removed_ uses of 'true' and 'false' for the return values, to emphasise that there's something more subtle going on than a simple boolean answer: - the 'multisel' field in dialog.h's list box structure, for which the GTK front end in particular recognises a difference between 1 and 2 but nearly everything else treats as boolean - the 'urgent' parameter to plug_receive, where 1 vs 2 tells you something about the specific location of the urgent pointer, but most clients only care about 0 vs 'something nonzero' - the return value of wc_match, where -1 indicates a syntax error in the wildcard. - the return values from SSH-1 RSA-key loading functions, which use -1 for 'wrong passphrase' and 0 for all other failures (so any caller which already knows it's not loading an _encrypted private_ key can treat them as boolean) - term->esc_query, and the 'query' parameter in toggle_mode in terminal.c, which _usually_ hold 0 for ESC[123h or 1 for ESC[?123h, but can also hold -1 for some other intervening character that we don't support. In a few places there's an integer that I haven't turned into a bool even though it really _can_ only take values 0 or 1 (and, as above, tried to make the call sites consistent in not calling those values true and false), on the grounds that I thought it would make it more confusing to imply that the 0 value was in some sense 'negative' or bad and the 1 positive or good: - the return value of plug_accepting uses the POSIXish convention of 0=success and nonzero=error; I think if I made it bool then I'd also want to reverse its sense, and that's a job for a separate piece of work. - the 'screen' parameter to lineptr() in terminal.c, where 0 and 1 represent the default and alternate screens. There's no obvious reason why one of those should be considered 'true' or 'positive' or 'success' - they're just indices - so I've left it as int. ssh_scp_recv had particularly confusing semantics for its previous int return value: its call sites used '<= 0' to check for error, but it never actually returned a negative number, just 0 or 1. Now the function and its call sites agree that it's a bool. In a couple of places I've renamed variables called 'ret', because I don't like that name any more - it's unclear whether it means the return value (in preparation) for the _containing_ function or the return value received from a subroutine call, and occasionally I've accidentally used the same variable for both and introduced a bug. So where one of those got in my way, I've renamed it to 'toret' or 'retd' (the latter short for 'returned') in line with my usual modern practice, but I haven't done a thorough job of finding all of them. Finally, one amusing side effect of doing this is that I've had to separate quite a few chained assignments. It used to be perfectly fine to write 'a = b = c = TRUE' when a,b,c were int and TRUE was just a the 'true' defined by stdbool.h, that idiom provokes a warning from gcc: 'suggest parentheses around assignment used as truth value'!
2018-11-02 19:23:19 +00:00
static bool win_seat_is_utf8(Seat *seat)
Support frontend_is_utf8() in all front ends. Previously only Unix front ends bothered to include it, on the basis that only the pty backend needed it (to set IUTF8 in the pty). We're about to need it everywhere else too.
2016-05-03 07:43:09 +00:00
{
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
WinGuiSeat *wgs = container_of(seat, WinGuiSeat, seat);
return is_utf8(wgs);
Support frontend_is_utf8() in all front ends. Previously only Unix front ends bothered to include it, on the basis that only the pty backend needed it (to set IUTF8 in the pty). We're about to need it everywhere else too.
2016-05-03 07:43:09 +00:00
}
Add a few missing 'static'.
2021-02-02 18:54:39 +00:00
static char *win_seat_get_ttymode(Seat *seat, const char *mode)
First crack at `terminal-modes' in SSH. PuTTY now sends ERASE by default, Unix Plink sends everything sensible it can find, and it's fully configurable from the GUI. I'm not entirely sure about the precise set of modes that Unix Plink should look at; informed tweaks are welcome. Also the Mac bits are guesses (but trivial). [originally from svn r5653] [this svn revision also touched putty-wishlist]
2005-04-21 13:57:08 +00:00
{
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
WinGuiSeat *wgs = container_of(seat, WinGuiSeat, seat);
return term_get_ttymode(wgs->term, mode);
First crack at `terminal-modes' in SSH. PuTTY now sends ERASE by default, Unix Plink sends everything sensible it can find, and it's fully configurable from the GUI. I'm not entirely sure about the precise set of modes that Unix Plink should look at; informed tweaks are welcome. Also the Mac bits are guesses (but trivial). [originally from svn r5653] [this svn revision also touched putty-wishlist]
2005-04-21 13:57:08 +00:00
}
Add a few missing 'static'.
2021-02-02 18:54:39 +00:00
static StripCtrlChars *win_seat_stripctrl_new(
Revise the API for seat_stripctrl_new. Now instead of taking raw arguments to configure the output StripCtrlChars with, it takes an enumerated value giving the context of what's being sanitised, and allows the seat to decide what the output parameters for that context should be. The only context currently used is SIC_BANNER (SSH login banners). I've also added a not-yet-used one for keyboard-interactive prompts.
2019-03-07 08:19:38 +00:00
Seat *seat, BinarySink *bs_out, SeatInteractionContext sic)
Add a Seat vtable method to get a stripctrl. If centralised code like the SSH implementation wants to sanitise escape sequences out of a piece of server-provided text, it will need to do it by making a locale-based StripCtrlChars if it's running in a console context, or a Terminal-based one if it's in a GUI terminal- window application. All the other changes of behaviour needed between those two contexts are handled by providing reconfigurable methods in the Seat vtable; this one is no different. So now there's a new method in the Seat vtable that will construct a StripCtrlChars appropriate to that kind of seat. Terminal-window seats (gtkwin.c, window.c) implement it by calling the new stripctrl_new_term(), and console ones use the locale- based stripctrl_new().
2019-03-05 21:13:00 +00:00
{
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
WinGuiSeat *wgs = container_of(seat, WinGuiSeat, seat);
return stripctrl_new_term(bs_out, false, 0, wgs->term);
Add a Seat vtable method to get a stripctrl. If centralised code like the SSH implementation wants to sanitise escape sequences out of a piece of server-provided text, it will need to do it by making a locale-based StripCtrlChars if it's running in a console context, or a Terminal-based one if it's in a GUI terminal- window application. All the other changes of behaviour needed between those two contexts are handled by providing reconfigurable methods in the Seat vtable; this one is no different. So now there's a new method in the Seat vtable that will construct a StripCtrlChars appropriate to that kind of seat. Terminal-window seats (gtkwin.c, window.c) implement it by calling the new stripctrl_new_term(), and console ones use the locale- based stripctrl_new().
2019-03-05 21:13:00 +00:00
}
Make lots of 'int' length fields into size_t. This is a general cleanup which has been overdue for some time: lots of length fields are now the machine word type rather than the (in practice) fixed 'int'.
2019-02-06 20:42:44 +00:00
static size_t win_seat_output(
seat_output: add an output type for SSH banners. (NFC) The jump host system ought really to be treating SSH authentication banners as a distinct thing from the standard-error session output, so that the former can be presented to the user in the same way as the auth banner for the main session. This change converts the 'bool is_stderr' parameter of seat_output() into an enumerated type with three values. For the moment, stderr and banners are treated the same, but the plan is for that to change.
2021-09-16 13:46:49 +00:00
Seat *seat, SeatOutputType type, const void *, size_t);
Convert a lot of 'int' variables to 'bool'. My normal habit these days, in new code, is to treat int and bool as _almost_ completely separate types. I'm still willing to use C's implicit test for zero on an integer (e.g. 'if (!blob.len)' is fine, no need to spell it out as blob.len != 0), but generally, if a variable is going to be conceptually a boolean, I like to declare it bool and assign to it using 'true' or 'false' rather than 0 or 1. PuTTY is an exception, because it predates the C99 bool, and I've stuck to its existing coding style even when adding new code to it. But it's been annoying me more and more, so now that I've decided C99 bool is an acceptable thing to require from our toolchain in the first place, here's a quite thorough trawl through the source doing 'boolification'. Many variables and function parameters are now typed as bool rather than int; many assignments of 0 or 1 to those variables are now spelled 'true' or 'false'. I managed this thorough conversion with the help of a custom clang plugin that I wrote to trawl the AST and apply heuristics to point out where things might want changing. So I've even managed to do a decent job on parts of the code I haven't looked at in years! To make the plugin's work easier, I pushed platform front ends generally in the direction of using standard 'bool' in preference to platform-specific boolean types like Windows BOOL or GTK's gboolean; I've left the platform booleans in places they _have_ to be for the platform APIs to work right, but variables only used by my own code have been converted wherever I found them. In a few places there are int values that look very like booleans in _most_ of the places they're used, but have a rarely-used third value, or a distinction between different nonzero values that most users don't care about. In these cases, I've _removed_ uses of 'true' and 'false' for the return values, to emphasise that there's something more subtle going on than a simple boolean answer: - the 'multisel' field in dialog.h's list box structure, for which the GTK front end in particular recognises a difference between 1 and 2 but nearly everything else treats as boolean - the 'urgent' parameter to plug_receive, where 1 vs 2 tells you something about the specific location of the urgent pointer, but most clients only care about 0 vs 'something nonzero' - the return value of wc_match, where -1 indicates a syntax error in the wildcard. - the return values from SSH-1 RSA-key loading functions, which use -1 for 'wrong passphrase' and 0 for all other failures (so any caller which already knows it's not loading an _encrypted private_ key can treat them as boolean) - term->esc_query, and the 'query' parameter in toggle_mode in terminal.c, which _usually_ hold 0 for ESC[123h or 1 for ESC[?123h, but can also hold -1 for some other intervening character that we don't support. In a few places there's an integer that I haven't turned into a bool even though it really _can_ only take values 0 or 1 (and, as above, tried to make the call sites consistent in not calling those values true and false), on the grounds that I thought it would make it more confusing to imply that the 0 value was in some sense 'negative' or bad and the 1 positive or good: - the return value of plug_accepting uses the POSIXish convention of 0=success and nonzero=error; I think if I made it bool then I'd also want to reverse its sense, and that's a job for a separate piece of work. - the 'screen' parameter to lineptr() in terminal.c, where 0 and 1 represent the default and alternate screens. There's no obvious reason why one of those should be considered 'true' or 'positive' or 'success' - they're just indices - so I've left it as int. ssh_scp_recv had particularly confusing semantics for its previous int return value: its call sites used '<= 0' to check for error, but it never actually returned a negative number, just 0 or 1. Now the function and its call sites agree that it's a bool. In a couple of places I've renamed variables called 'ret', because I don't like that name any more - it's unclear whether it means the return value (in preparation) for the _containing_ function or the return value received from a subroutine call, and occasionally I've accidentally used the same variable for both and introduced a bug. So where one of those got in my way, I've renamed it to 'toret' or 'retd' (the latter short for 'returned') in line with my usual modern practice, but I haven't done a thorough job of finding all of them. Finally, one amusing side effect of doing this is that I've had to separate quite a few chained assignments. It used to be perfectly fine to write 'a = b = c = TRUE' when a,b,c were int and TRUE was just a the 'true' defined by stdbool.h, that idiom provokes a warning from gcc: 'suggest parentheses around assignment used as truth value'!
2018-11-02 19:23:19 +00:00
static bool win_seat_eof(Seat *seat);
Richer data type for interactive prompt results. All the seat functions that request an interactive prompt of some kind to the user - both the main seat_get_userpass_input and the various confirmation dialogs for things like host keys - were using a simple int return value, with the general semantics of 0 = "fail", 1 = "proceed" (and in the case of seat_get_userpass_input, answers to the prompts were provided), and -1 = "request in progress, wait for a callback". In this commit I change all those functions' return types to a new struct called SeatPromptResult, whose primary field is an enum replacing those simple integer values. The main purpose is that the enum has not three but _four_ values: the "fail" result has been split into 'user abort' and 'software abort'. The distinction is that a user abort occurs as a result of an interactive UI action, such as the user clicking 'cancel' in a dialog box or hitting ^D or ^C at a terminal password prompt - and therefore, there's no need to display an error message telling the user that the interactive operation has failed, because the user already knows, because they _did_ it. 'Software abort' is from any other cause, where PuTTY is the first to know there was a problem, and has to tell the user. We already had this 'user abort' vs 'software abort' distinction in other parts of the code - the SSH backend has separate termination functions which protocol layers can call. But we assumed that any failure from an interactive prompt request fell into the 'user abort' category, which is not true. A couple of examples: if you configure a host key fingerprint in your saved session via the SSH > Host keys pane, and the server presents a host key that doesn't match it, then verify_ssh_host_key would report that the user had aborted the connection, and feel no need to tell the user what had gone wrong! Similarly, if a password provided on the command line was not accepted, then (after I fixed the semantics of that in the previous commit) the same wrong handling would occur. So now, those Seat prompt functions too can communicate whether the user or the software originated a connection abort. And in the latter case, we also provide an error message to present to the user. Result: in those two example cases (and others), error messages should no longer go missing. Implementation note: to avoid the hassle of having the error message in a SeatPromptResult being a dynamically allocated string (and hence, every recipient of one must always check whether it's non-NULL and free it on every exit path, plus being careful about copying the struct around), I've instead arranged that the structure contains a function pointer and a couple of parameters, so that the string form of the message can be constructed on demand. That way, the only users who need to free it are the ones who actually _asked_ for it in the first place, which is a much smaller set. (This is one of the rare occasions that I regret not having C++'s extra features available in this code base - a unique_ptr or shared_ptr to a string would have been just the thing here, and the compiler would have done all the hard work for me of remembering where to insert the frees!)
2021-12-28 17:52:00 +00:00
static SeatPromptResult win_seat_get_userpass_input(Seat *seat, prompts_t *p);
New abstraction 'Seat', to pass to backends. This is a new vtable-based abstraction which is passed to a backend in place of Frontend, and it implements only the subset of the Frontend functions needed by a backend. (Many other Frontend functions still exist, notably the wide range of things called by terminal.c providing platform-independent operations on the GUI terminal window.) The purpose of making it a vtable is that this opens up the possibility of creating a backend as an internal implementation detail of some other activity, by providing just that one backend with a custom Seat that implements the methods differently. For example, this refactoring should make it feasible to directly implement an SSH proxy type, aka the 'jump host' feature supported by OpenSSH, aka 'open a secondary SSH session in MAINCHAN_DIRECT_TCP mode, and then expose the main channel of that as the Socket for the primary connection'. (Which of course you can already do by spawning 'plink -nc' as a separate proxy process, but this would permit it in the _same_ process without anything getting confused.) I've centralised a full set of stub methods in misc.c for the new abstraction, which allows me to get rid of several annoying stubs in the previous code. Also, while I'm here, I've moved a lot of duplicated modalfatalbox() type functions from application main program files into wincons.c / uxcons.c, which I think saves duplication overall. (A minor visible effect is that the prefixes on those console-based fatal error messages will now be more consistent between applications.)
2018-10-11 18:58:42 +00:00
static void win_seat_notify_remote_exit(Seat *seat);
static void win_seat_connection_fatal(Seat *seat, const char *msg);
New Seat method, seat_nonfatal(). This is like the seat-independent nonfatal(), but specifies a Seat, which allows the GUI dialog box to have the right terminal window as its parent (if there are multiple ones). Changed over all the nonfatal() calls in the code base that could be localised to a Seat, which means all the ones that come up if something goes horribly wrong in host key storage. To make that possible, I've added a 'seat' parameter to store_host_key(); it turns out that all its call sites had one available already.
2022-09-13 07:49:38 +00:00
static void win_seat_nonfatal(Seat *seat, const char *msg);
New abstraction 'Seat', to pass to backends. This is a new vtable-based abstraction which is passed to a backend in place of Frontend, and it implements only the subset of the Frontend functions needed by a backend. (Many other Frontend functions still exist, notably the wide range of things called by terminal.c providing platform-independent operations on the GUI terminal window.) The purpose of making it a vtable is that this opens up the possibility of creating a backend as an internal implementation detail of some other activity, by providing just that one backend with a custom Seat that implements the methods differently. For example, this refactoring should make it feasible to directly implement an SSH proxy type, aka the 'jump host' feature supported by OpenSSH, aka 'open a secondary SSH session in MAINCHAN_DIRECT_TCP mode, and then expose the main channel of that as the Socket for the primary connection'. (Which of course you can already do by spawning 'plink -nc' as a separate proxy process, but this would permit it in the _same_ process without anything getting confused.) I've centralised a full set of stub methods in misc.c for the new abstraction, which allows me to get rid of several annoying stubs in the previous code. Also, while I'm here, I've moved a lot of duplicated modalfatalbox() type functions from application main program files into wincons.c / uxcons.c, which I think saves duplication overall. (A minor visible effect is that the prefixes on those console-based fatal error messages will now be more consistent between applications.)
2018-10-11 18:58:42 +00:00
static void win_seat_update_specials_menu(Seat *seat);
static void win_seat_set_busy_status(Seat *seat, BusyStatus status);
Divide seat_set_trust_status into query and update. This complicates the API in one sense (more separate functions), but in another sense, simplifies it (each function does something simpler). When I start putting one Seat in front of another during SSH proxying, the latter will be more important - in particular, it means you can find out _whether_ a seat can support changing trust status without having to actually attempt a destructive modification.
2021-09-12 08:52:46 +00:00
static void win_seat_set_trust_status(Seat *seat, bool trusted);
static bool win_seat_can_set_trust_status(Seat *seat);
Add a new seat method to return the cursor position. The motivation is for the SUPDUP protocol. The server may send a signal for the terminal to reset any input buffers. After this, the server will not know the state of the terminal, so it is required to send its cursor position back.
2019-04-04 19:17:24 +00:00
static bool win_seat_get_cursor_position(Seat *seat, int *x, int *y);
Flip direction of window pos/size queries. Similarly to other recent changes, the frontend now proactively keeps Terminal up to date with the current position and size of the terminal window, so that escape-sequence queries can be answered immediately from the Terminal's own internal data structures without needing a call back to the frontend. Mostly this has let me remove explicit window-system API calls that retrieve the window position and size, in favour of having the front ends listen for WM_MOVE / WM_SIZE / ConfigureNotify events and track the position and size that way. One exception is that the window pixel size is still requested by Seat via a callback, to put in the wire-encoded termios settings. That won't be happening very much, so I'm leaving it this way round for the moment.
2021-02-07 19:59:21 +00:00
static bool win_seat_get_window_pixel_size(Seat *seat, int *x, int *y);
New abstraction 'Seat', to pass to backends. This is a new vtable-based abstraction which is passed to a backend in place of Frontend, and it implements only the subset of the Frontend functions needed by a backend. (Many other Frontend functions still exist, notably the wide range of things called by terminal.c providing platform-independent operations on the GUI terminal window.) The purpose of making it a vtable is that this opens up the possibility of creating a backend as an internal implementation detail of some other activity, by providing just that one backend with a custom Seat that implements the methods differently. For example, this refactoring should make it feasible to directly implement an SSH proxy type, aka the 'jump host' feature supported by OpenSSH, aka 'open a secondary SSH session in MAINCHAN_DIRECT_TCP mode, and then expose the main channel of that as the Socket for the primary connection'. (Which of course you can already do by spawning 'plink -nc' as a separate proxy process, but this would permit it in the _same_ process without anything getting confused.) I've centralised a full set of stub methods in misc.c for the new abstraction, which allows me to get rid of several annoying stubs in the previous code. Also, while I'm here, I've moved a lot of duplicated modalfatalbox() type functions from application main program files into wincons.c / uxcons.c, which I think saves duplication overall. (A minor visible effect is that the prefixes on those console-based fatal error messages will now be more consistent between applications.)
2018-10-11 18:58:42 +00:00
static const SeatVtable win_seat_vt = {
Change vtable defs to use C99 designated initialisers. This is a sweeping change applied across the whole code base by a spot of Emacs Lisp. Now, everywhere I declare a vtable filled with function pointers (and the occasional const data member), all the members of the vtable structure are initialised by name using the '.fieldname = value' syntax introduced in C99. We were already using this syntax for a handful of things in the new key-generation progress report system, so it's not new to the code base as a whole. The advantage is that now, when a vtable only declares a subset of the available fields, I can initialise the rest to NULL or zero just by leaving them out. This is most dramatic in a couple of the outlying vtables in things like psocks (which has a ConnectionLayerVtable containing only one non-NULL method), but less dramatically, it means that the new 'flags' field in BackendVtable can be completely left out of every backend definition except for the SUPDUP one which defines it to a nonzero value. Similarly, the test_for_upstream method only used by SSH doesn't have to be mentioned in the rest of the backends; network Plugs for listening sockets don't have to explicitly null out 'receive' and 'sent', and vice versa for 'accepting', and so on. While I'm at it, I've normalised the declarations so they don't use the unnecessarily verbose 'struct' keyword. Also a handful of them weren't const; now they are.
2020-03-10 21:06:29 +00:00
.output = win_seat_output,
.eof = win_seat_eof,
New Seat callback, seat_sent(). This is used to notify the Seat that some data has been cleared from the backend's outgoing data buffer. In other words, it notifies the Seat that it might be worth calling backend_sendbuffer() again. We've never needed this before, because until now, Seats have always been the 'main program' part of the application, meaning they were also in control of the event loop. So they've been able to call backend_sendbuffer() proactively, every time they go round the event loop, instead of having to wait for a callback. But now, the SSH proxy is the first example of a Seat without privileged access to the event loop, so it has no way to find out that the backend's sendbuffer has got smaller. And without that, it can't pass that notification on to plug_sent, to unblock in turn whatever the proxied connection might have been waiting to send. In fact, before this commit, sshproxy.c never called plug_sent at all. As a result, large data uploads over an SSH jump host would hang forever as soon as the outgoing buffer filled up for the first time: the main backend (to which sshproxy.c was acting as a Socket) would carefully stop filling up the buffer, and then never receive the call to plug_sent that would cause it to start again. The new callback is ignored everywhere except in sshproxy.c. It might be a good idea to remove backend_sendbuffer() entirely and convert all previous uses of it into non-empty implementations of this callback, so that we've only got one system; but for the moment, I haven't done that.
2021-06-27 12:52:48 +00:00
.sent = nullseat_sent,
Split seat_banner from seat_output. Previously, SSH authentication banners were displayed by calling the ordinary seat_output function, and passing it a special value in the SeatOutputType enumeration indicating an auth banner. The awkwardness of this was already showing a little in SshProxy's implementation of seat_output, where it had to check for that special value and do totally different things for SEAT_OUTPUT_AUTH_BANNER and everything else. Further work in that area is going to make it more and more awkward if I keep the two output systems unified. So let's split them up. Now, Seat has separate output() and banner() methods, which each implementation can override differently if it wants to. All the 'end user' Seat implementations use the centralised implementation function nullseat_banner_to_stderr(), which turns banner text straight back into SEAT_OUTPUT_STDERR and passes it on to seat_output. So I didn't have to tediously implement a boring version of this function in GTK, Windows GUI, consoles, file transfer etc.
2021-10-30 16:06:00 +00:00
.banner = nullseat_banner_to_stderr,
Change vtable defs to use C99 designated initialisers. This is a sweeping change applied across the whole code base by a spot of Emacs Lisp. Now, everywhere I declare a vtable filled with function pointers (and the occasional const data member), all the members of the vtable structure are initialised by name using the '.fieldname = value' syntax introduced in C99. We were already using this syntax for a handful of things in the new key-generation progress report system, so it's not new to the code base as a whole. The advantage is that now, when a vtable only declares a subset of the available fields, I can initialise the rest to NULL or zero just by leaving them out. This is most dramatic in a couple of the outlying vtables in things like psocks (which has a ConnectionLayerVtable containing only one non-NULL method), but less dramatically, it means that the new 'flags' field in BackendVtable can be completely left out of every backend definition except for the SUPDUP one which defines it to a nonzero value. Similarly, the test_for_upstream method only used by SSH doesn't have to be mentioned in the rest of the backends; network Plugs for listening sockets don't have to explicitly null out 'receive' and 'sent', and vice versa for 'accepting', and so on. While I'm at it, I've normalised the declarations so they don't use the unnecessarily verbose 'struct' keyword. Also a handful of them weren't const; now they are.
2020-03-10 21:06:29 +00:00
.get_userpass_input = win_seat_get_userpass_input,
New Seat method, notify_session_started(). This is called by the backend to notify the Seat that the connection has progressed to the point where the main session channel (i.e. the thing that would typically correspond to the client's stdin/stdout) has been successfully set up. The only Seat that implements this method nontrivially is the one in SshProxy, which uses it as an indication that the proxied connection to the remote host has succeeded, and sends the PLUGLOG_CONNECT_SUCCESS notification to its own Plug. Hence, the only backends that need to implement it at the moment are the two SSH-shaped backends (SSH proper and bare-connection / psusan). For other backends, it's not always obvious what 'main session channel' would even mean, or whether it means anything very useful; so I've also introduced a backend flag indicating whether the backend is expecting to call that method at all, so as not to have to spend pointless effort on defining an arbitrary meaning for it in other contexts. So a lot of this patch is just introducing the new method and putting its trivial do-nothing implementation into all the existing Seat methods. The interesting parts happen in ssh/mainchan.c (which actually calls it), and sshproxy.c (which does something useful in response).
2021-09-12 10:48:42 +00:00
.notify_session_started = nullseat_notify_session_started,
Change vtable defs to use C99 designated initialisers. This is a sweeping change applied across the whole code base by a spot of Emacs Lisp. Now, everywhere I declare a vtable filled with function pointers (and the occasional const data member), all the members of the vtable structure are initialised by name using the '.fieldname = value' syntax introduced in C99. We were already using this syntax for a handful of things in the new key-generation progress report system, so it's not new to the code base as a whole. The advantage is that now, when a vtable only declares a subset of the available fields, I can initialise the rest to NULL or zero just by leaving them out. This is most dramatic in a couple of the outlying vtables in things like psocks (which has a ConnectionLayerVtable containing only one non-NULL method), but less dramatically, it means that the new 'flags' field in BackendVtable can be completely left out of every backend definition except for the SUPDUP one which defines it to a nonzero value. Similarly, the test_for_upstream method only used by SSH doesn't have to be mentioned in the rest of the backends; network Plugs for listening sockets don't have to explicitly null out 'receive' and 'sent', and vice versa for 'accepting', and so on. While I'm at it, I've normalised the declarations so they don't use the unnecessarily verbose 'struct' keyword. Also a handful of them weren't const; now they are.
2020-03-10 21:06:29 +00:00
.notify_remote_exit = win_seat_notify_remote_exit,
New Seat method, notify_remote_disconnect. This notifies the Seat that the entire backend session has finished and closed its network connection - or rather, that it _might_ have done, and that the frontend should check backend_connected() if it wasn't planning to do so already. The existing Seat implementations haven't needed this: the GUI ones don't actually need to do anything specific when the network connection goes away, and the CLI ones deal with it by being in charge of their own event loop so that they can easily check backend_connected() at every possible opportunity in any case. But I'm about to introduce a new Seat implementation that does need to know this, and doesn't have any other way to get notified of it.
2021-05-22 11:47:51 +00:00
.notify_remote_disconnect = nullseat_notify_remote_disconnect,
Change vtable defs to use C99 designated initialisers. This is a sweeping change applied across the whole code base by a spot of Emacs Lisp. Now, everywhere I declare a vtable filled with function pointers (and the occasional const data member), all the members of the vtable structure are initialised by name using the '.fieldname = value' syntax introduced in C99. We were already using this syntax for a handful of things in the new key-generation progress report system, so it's not new to the code base as a whole. The advantage is that now, when a vtable only declares a subset of the available fields, I can initialise the rest to NULL or zero just by leaving them out. This is most dramatic in a couple of the outlying vtables in things like psocks (which has a ConnectionLayerVtable containing only one non-NULL method), but less dramatically, it means that the new 'flags' field in BackendVtable can be completely left out of every backend definition except for the SUPDUP one which defines it to a nonzero value. Similarly, the test_for_upstream method only used by SSH doesn't have to be mentioned in the rest of the backends; network Plugs for listening sockets don't have to explicitly null out 'receive' and 'sent', and vice versa for 'accepting', and so on. While I'm at it, I've normalised the declarations so they don't use the unnecessarily verbose 'struct' keyword. Also a handful of them weren't const; now they are.
2020-03-10 21:06:29 +00:00
.connection_fatal = win_seat_connection_fatal,
New Seat method, seat_nonfatal(). This is like the seat-independent nonfatal(), but specifies a Seat, which allows the GUI dialog box to have the right terminal window as its parent (if there are multiple ones). Changed over all the nonfatal() calls in the code base that could be localised to a Seat, which means all the ones that come up if something goes horribly wrong in host key storage. To make that possible, I've added a 'seat' parameter to store_host_key(); it turns out that all its call sites had one available already.
2022-09-13 07:49:38 +00:00
.nonfatal = win_seat_nonfatal,
Change vtable defs to use C99 designated initialisers. This is a sweeping change applied across the whole code base by a spot of Emacs Lisp. Now, everywhere I declare a vtable filled with function pointers (and the occasional const data member), all the members of the vtable structure are initialised by name using the '.fieldname = value' syntax introduced in C99. We were already using this syntax for a handful of things in the new key-generation progress report system, so it's not new to the code base as a whole. The advantage is that now, when a vtable only declares a subset of the available fields, I can initialise the rest to NULL or zero just by leaving them out. This is most dramatic in a couple of the outlying vtables in things like psocks (which has a ConnectionLayerVtable containing only one non-NULL method), but less dramatically, it means that the new 'flags' field in BackendVtable can be completely left out of every backend definition except for the SUPDUP one which defines it to a nonzero value. Similarly, the test_for_upstream method only used by SSH doesn't have to be mentioned in the rest of the backends; network Plugs for listening sockets don't have to explicitly null out 'receive' and 'sent', and vice versa for 'accepting', and so on. While I'm at it, I've normalised the declarations so they don't use the unnecessarily verbose 'struct' keyword. Also a handful of them weren't const; now they are.
2020-03-10 21:06:29 +00:00
.update_specials_menu = win_seat_update_specials_menu,
.get_ttymode = win_seat_get_ttymode,
.set_busy_status = win_seat_set_busy_status,
Reorganise host key checking and confirmation. Previously, checking the host key against the persistent cache managed by the storage.h API was done as part of the seat_verify_ssh_host_key method, i.e. separately by each Seat. Now that check is done by verify_ssh_host_key(), which is a new function in ssh/common.c that centralises all the parts of host key checking that don't need an interactive prompt. It subsumes the previous verify_ssh_manual_host_key() that checked against the Conf, and it does the check against the storage API that each Seat was previously doing separately. If it can't confirm or definitively reject the host key by itself, _then_ it calls out to the Seat, once an interactive prompt is definitely needed. The main point of doing this is so that when SshProxy forwards a Seat call from the proxy SSH connection to the primary Seat, it won't print an announcement of which connection is involved unless it's actually going to do something interactive. (Not that we're printing those announcements _yet_ anyway, but this is a piece of groundwork that works towards doing so.) But while I'm at it, I've also taken the opportunity to clean things up a bit by renaming functions sensibly. Previously we had three very similarly named functions verify_ssh_manual_host_key(), SeatVtable's 'verify_ssh_host_key' method, and verify_host_key() in storage.h. Now the Seat method is called 'confirm' rather than 'verify' (since its job is now always to print an interactive prompt, so it looks more like the other confirm_foo methods), and the storage.h function is called check_stored_host_key(), which goes better with store_host_key and avoids having too many functions with similar names. And the 'manual' function is subsumed into the new centralised code, so there's now just *one* host key function with 'verify' in the name. Several functions are reindented in this commit. Best viewed with whitespace changes ignored.
2021-10-25 17:12:17 +00:00
.confirm_ssh_host_key = win_seat_confirm_ssh_host_key,
Change vtable defs to use C99 designated initialisers. This is a sweeping change applied across the whole code base by a spot of Emacs Lisp. Now, everywhere I declare a vtable filled with function pointers (and the occasional const data member), all the members of the vtable structure are initialised by name using the '.fieldname = value' syntax introduced in C99. We were already using this syntax for a handful of things in the new key-generation progress report system, so it's not new to the code base as a whole. The advantage is that now, when a vtable only declares a subset of the available fields, I can initialise the rest to NULL or zero just by leaving them out. This is most dramatic in a couple of the outlying vtables in things like psocks (which has a ConnectionLayerVtable containing only one non-NULL method), but less dramatically, it means that the new 'flags' field in BackendVtable can be completely left out of every backend definition except for the SUPDUP one which defines it to a nonzero value. Similarly, the test_for_upstream method only used by SSH doesn't have to be mentioned in the rest of the backends; network Plugs for listening sockets don't have to explicitly null out 'receive' and 'sent', and vice versa for 'accepting', and so on. While I'm at it, I've normalised the declarations so they don't use the unnecessarily verbose 'struct' keyword. Also a handful of them weren't const; now they are.
2020-03-10 21:06:29 +00:00
.confirm_weak_crypto_primitive = win_seat_confirm_weak_crypto_primitive,
.confirm_weak_cached_hostkey = win_seat_confirm_weak_cached_hostkey,
Centralise most details of host-key prompting. The text of the host key warnings was replicated in three places: the Windows rc file, the GTK dialog setup function, and the console.c shared between both platforms' CLI tools. Now it lives in just one place, namely ssh/common.c where the rest of the centralised host-key checking is done, so it'll be easier to adjust the wording in future. This comes with some extra automation. Paragraph wrapping is no longer done by hand in any version of these prompts. (Previously we let GTK do the wrapping on GTK, but on Windows the resource file contained a bunch of pre-wrapped LTEXT lines, and console.c had pre-wrapped terminal messages.) And the dialog heights in Windows are determined automatically based on the amount of stuff in the window. The main idea of all this is that it'll be easier to set up more elaborate kinds of host key prompt that deal with certificates (if, e.g., a server sends us a certified host key which we don't trust the CA for). But there are side benefits of this refactoring too: each tool now reliably inserts its own appname in the prompts, and also, on Windows the entire prompt text is copy-pastable. Details of implementation: there's a new type SeatDialogText which holds a set of (type, string) pairs describing the contents of a prompt. Type codes distinguish ordinary text paragraphs, paragraphs to be displayed prominently (like key fingerprints), the extra-bold scary title at the top of the 'host key changed' version of the dialog, and the various information that lives in the subsidiary 'more info' box. ssh/common.c constructs this, and passes it to the Seat to present the actual prompt. In order to deal with the different UI for answering the prompt, I've added an extra Seat method 'prompt_descriptions' which returns some snippets of text to interpolate into the messages. ssh/common.c calls that while it's still constructing the text, and incorporates the resulting snippets into the SeatDialogText. For the moment, this refactoring only affects the host key prompts. The warnings about outmoded crypto are still done the old-fashioned way; they probably ought to be similarly refactored to use this new SeatDialogText system, but it's not immediately critical for the purpose I have right now.
2022-07-07 16:25:15 +00:00
.prompt_descriptions = win_seat_prompt_descriptions,
Change vtable defs to use C99 designated initialisers. This is a sweeping change applied across the whole code base by a spot of Emacs Lisp. Now, everywhere I declare a vtable filled with function pointers (and the occasional const data member), all the members of the vtable structure are initialised by name using the '.fieldname = value' syntax introduced in C99. We were already using this syntax for a handful of things in the new key-generation progress report system, so it's not new to the code base as a whole. The advantage is that now, when a vtable only declares a subset of the available fields, I can initialise the rest to NULL or zero just by leaving them out. This is most dramatic in a couple of the outlying vtables in things like psocks (which has a ConnectionLayerVtable containing only one non-NULL method), but less dramatically, it means that the new 'flags' field in BackendVtable can be completely left out of every backend definition except for the SUPDUP one which defines it to a nonzero value. Similarly, the test_for_upstream method only used by SSH doesn't have to be mentioned in the rest of the backends; network Plugs for listening sockets don't have to explicitly null out 'receive' and 'sent', and vice versa for 'accepting', and so on. While I'm at it, I've normalised the declarations so they don't use the unnecessarily verbose 'struct' keyword. Also a handful of them weren't const; now they are.
2020-03-10 21:06:29 +00:00
.is_utf8 = win_seat_is_utf8,
.echoedit_update = nullseat_echoedit_update,
.get_x_display = nullseat_get_x_display,
.get_windowid = nullseat_get_windowid,
.get_window_pixel_size = win_seat_get_window_pixel_size,
.stripctrl_new = win_seat_stripctrl_new,
.set_trust_status = win_seat_set_trust_status,
Divide seat_set_trust_status into query and update. This complicates the API in one sense (more separate functions), but in another sense, simplifies it (each function does something simpler). When I start putting one Seat in front of another during SSH proxying, the latter will be more important - in particular, it means you can find out _whether_ a seat can support changing trust status without having to actually attempt a destructive modification.
2021-09-12 08:52:46 +00:00
.can_set_trust_status = win_seat_can_set_trust_status,
New Seat query, has_mixed_input_stream(). (TL;DR: to suppress redundant 'Press Return to begin session' prompts in between hops of a jump-host configuration, in Plink.) This new query method directly asks the Seat the question: is the same stream of input used to provide responses to interactive login prompts, and the session input provided after login concludes? It's used to suppress the last-ditch anti-spoofing defence in Plink of interactively asking 'Access granted. Press Return to begin session', on the basis that any such spoofing attack works by confusing the user about what's a legit login prompt before the session begins and what's sent by the server after the main session begins - so if those two things take input from different places, the user can't be confused. This doesn't change the existing behaviour of Plink, which was already suppressing the antispoof prompt in cases where its standard input was redirected from something other than a terminal. But previously it was doing it within the can_set_trust_status() seat query, and I've now moved it out into a separate query function. The reason why these need to be separate is for SshProxy, which needs to give an unusual combination of answers when run inside Plink. For can_set_trust_status(), it needs to return whatever the parent Seat returns, so that all the login prompts for a string of proxy connections in session will be antispoofed the same way. But you only want that final 'Access granted' prompt to happen _once_, after all the proxy connection setup phases are done, because up until then you're still in the safe hands of PuTTY itself presenting an unbroken sequence of legit login prompts (even if they come from a succession of different servers). Hence, SshProxy unconditionally returns 'no' to the query of whether it has a single mixed input stream, because indeed, it never does - for purposes of session input it behaves like an always-redirected Plink, no matter what kind of real Seat it ends up sending its pre-session login prompts to.
2021-11-06 14:33:03 +00:00
.has_mixed_input_stream = nullseat_has_mixed_input_stream_yes,
Change vtable defs to use C99 designated initialisers. This is a sweeping change applied across the whole code base by a spot of Emacs Lisp. Now, everywhere I declare a vtable filled with function pointers (and the occasional const data member), all the members of the vtable structure are initialised by name using the '.fieldname = value' syntax introduced in C99. We were already using this syntax for a handful of things in the new key-generation progress report system, so it's not new to the code base as a whole. The advantage is that now, when a vtable only declares a subset of the available fields, I can initialise the rest to NULL or zero just by leaving them out. This is most dramatic in a couple of the outlying vtables in things like psocks (which has a ConnectionLayerVtable containing only one non-NULL method), but less dramatically, it means that the new 'flags' field in BackendVtable can be completely left out of every backend definition except for the SUPDUP one which defines it to a nonzero value. Similarly, the test_for_upstream method only used by SSH doesn't have to be mentioned in the rest of the backends; network Plugs for listening sockets don't have to explicitly null out 'receive' and 'sent', and vice versa for 'accepting', and so on. While I'm at it, I've normalised the declarations so they don't use the unnecessarily verbose 'struct' keyword. Also a handful of them weren't const; now they are.
2020-03-10 21:06:29 +00:00
.verbose = nullseat_verbose_yes,
.interactive = nullseat_interactive_yes,
.get_cursor_position = win_seat_get_cursor_position,
New abstraction 'Seat', to pass to backends. This is a new vtable-based abstraction which is passed to a backend in place of Frontend, and it implements only the subset of the Frontend functions needed by a backend. (Many other Frontend functions still exist, notably the wide range of things called by terminal.c providing platform-independent operations on the GUI terminal window.) The purpose of making it a vtable is that this opens up the possibility of creating a backend as an internal implementation detail of some other activity, by providing just that one backend with a custom Seat that implements the methods differently. For example, this refactoring should make it feasible to directly implement an SSH proxy type, aka the 'jump host' feature supported by OpenSSH, aka 'open a secondary SSH session in MAINCHAN_DIRECT_TCP mode, and then expose the main channel of that as the Socket for the primary connection'. (Which of course you can already do by spawning 'plink -nc' as a separate proxy process, but this would permit it in the _same_ process without anything getting confused.) I've centralised a full set of stub methods in misc.c for the new abstraction, which allows me to get rid of several annoying stubs in the previous code. Also, while I'm here, I've moved a lot of duplicated modalfatalbox() type functions from application main program files into wincons.c / uxcons.c, which I think saves duplication overall. (A minor visible effect is that the prefixes on those console-based fatal error messages will now be more consistent between applications.)
2018-10-11 18:58:42 +00:00
};
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
static void start_backend(WinGuiSeat *wgs)
Implement `Restart Session', in both Unix and Windows PuTTY. Largely because Owen questioned whether it was really easy enough to be labelled `fun' in the bug database :-) [originally from svn r4453]
2004-08-14 13:04:18 +00:00
{
Name vtable structure types more consistently. Now they're all called FooVtable, instead of a mixture of that and Foo_vtable.
2018-10-05 06:03:46 +00:00
const struct BackendVtable *vt;
Make the backend_init error message dynamic. (NFC) Now, instead of a 'const char *' in the static data segment, error messages returned from backend setup are dynamically allocated and freed by the caller. This will allow me to make the messages much more specific (including errno values and the like). However, this commit is pure refactoring: I've _just_ changed the allocation policy, and left all the messages alone.
2020-04-18 12:28:33 +00:00
char *error, *realhost;
Implement `Restart Session', in both Unix and Windows PuTTY. Largely because Owen questioned whether it was really easy enough to be labelled `fun' in the bug database :-) [originally from svn r4453]
2004-08-14 13:04:18 +00:00
int i;
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
wgs->cmdline_get_passwd_state = cmdline_get_passwd_input_state_new;
Fix command-line password handling in Restart Session. When the user provides a password on the PuTTY command line, via -pw or -pwfile, the flag 'tried_once' inside cmdline_get_passwd_input() is intended to arrange that we only try sending that password once, and after we've sent it, we don't try again. But this plays badly with the 'Restart Session' operation. If the connection is lost and then restarted at user request, we _do_ want to send that password again! So this commit moves that static variable out into a small state structure held by the client of cmdline_get_passwd_input. Each client can decide how to manage that state itself. Clients that support 'Restart Session' - i.e. just GUI PuTTY itself - will initialise the state at the same time as instantiating the backend, so that every time the session is restarted, we return to (correctly) believing that we _haven't_ yet tried the password provided on the command line. But clients that don't support 'Restart Session' - i.e. Plink and file transfer tools - can do the same thing that cmdline.c was doing before: just keep the state in a static variable. This also means that the GUI login tools will now retain the command-line password in memory, whereas previously they'd have wiped it out once it was used. But the other tools will still wipe and free the password, because I've also added a 'bool restartable' flag to cmdline_get_passwd_input to let it know when it _is_ allowed to do that. In the GUI tools, I don't see any way to get round that, because if the session is restarted you _have_ to still have the password to use again. (And you can't infer that that will never happen from the CONF_close_on_exit setting, because that too could be changed in mid-session.) On the other hand, I think it's not all that worrying, because the use of either -pw or -pwfile means that a persistent copy of your password is *already* stored somewhere, so another one isn't too big a stretch. (Due to the change of -pw policy in 0.77, the effect of this bug was that an attempt to reconnect in a session set up this way would lead to "Configured password was not accepted". In 0.76, the failure mode was different: PuTTY would interactively prompt for the password, having wiped it out of memory after it was used the first time round.)
2022-05-18 12:04:56 +00:00
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
vt = backend_vt_from_conf(wgs->conf);
Implement `Restart Session', in both Unix and Windows PuTTY. Largely because Owen questioned whether it was really easy enough to be labelled `fun' in the bug database :-) [originally from svn r4453]
2004-08-14 13:04:18 +00:00
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
seat_set_trust_status(&wgs->seat, true);
error = backend_init(vt, &wgs->seat, &wgs->backend, wgs->logctx, wgs->conf,
conf_get_str(wgs->conf, CONF_host),
conf_get_int(wgs->conf, CONF_port),
Turn Backend into a sensible classoid. Nearly every part of the code that ever handles a full backend structure has historically done it using a pair of pointer variables, one pointing at a constant struct full of function pointers, and the other pointing to a 'void *' state object that's passed to each of those. While I'm modernising the rest of the code, this seems like a good time to turn that into the same more or less type-safe and less cumbersome system as I'm using for other parts of the code, such as Socket, Plug, BinaryPacketProtocol and so forth: the Backend structure contains a vtable pointer, and a system of macro wrappers handles dispatching through that vtable.
2018-09-11 15:23:38 +00:00
&realhost,
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
conf_get_bool(wgs->conf, CONF_tcp_nodelay),
conf_get_bool(wgs->conf, CONF_tcp_keepalives));
Implement `Restart Session', in both Unix and Windows PuTTY. Largely because Owen questioned whether it was really easy enough to be labelled `fun' in the bug database :-) [originally from svn r4453]
2004-08-14 13:04:18 +00:00
if (error) {
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
char *str = dupprintf("%s Error", appname);
Special backend init error handling for pterm. Fixes a cosmetic issue where the new ConPTY error added in 4ae8b742ab had an ugly "Unable to open connection to". (Arguably this ought to test a backend property rather than cmdline_tooltype.)
2022-05-24 12:32:55 +00:00
char *msg;
if (cmdline_tooltype & TOOLTYPE_NONNETWORK) {
/* Special case for pterm. */
msg = dupprintf("Unable to open terminal:\n%s", error);
} else {
msg = dupprintf("Unable to open connection to\n%s\n%s",
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
conf_dest(wgs->conf), error);
Special backend init error handling for pterm. Fixes a cosmetic issue where the new ConPTY error added in 4ae8b742ab had an ugly "Unable to open connection to". (Arguably this ought to test a backend property rather than cmdline_tooltype.)
2022-05-24 12:32:55 +00:00
}
Make the backend_init error message dynamic. (NFC) Now, instead of a 'const char *' in the static data segment, error messages returned from backend setup are dynamically allocated and freed by the caller. This will allow me to make the messages much more specific (including errno values and the like). However, this commit is pure refactoring: I've _just_ changed the allocation policy, and left all the messages alone.
2020-04-18 12:28:33 +00:00
sfree(error);
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
MessageBox(NULL, msg, str, MB_ICONERROR | MB_OK);
sfree(str);
sfree(msg);
exit(0);
Implement `Restart Session', in both Unix and Windows PuTTY. Largely because Owen questioned whether it was really easy enough to be labelled `fun' in the bug database :-) [originally from svn r4453]
2004-08-14 13:04:18 +00:00
}
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
term_setup_window_titles(wgs->term, realhost);
Implement `Restart Session', in both Unix and Windows PuTTY. Largely because Owen questioned whether it was really easy enough to be labelled `fun' in the bug database :-) [originally from svn r4453]
2004-08-14 13:04:18 +00:00
sfree(realhost);
/*
* Connect the terminal to the backend for resize purposes.
*/
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
term_provide_backend(wgs->term, wgs->backend);
Implement `Restart Session', in both Unix and Windows PuTTY. Largely because Owen questioned whether it was really easy enough to be labelled `fun' in the bug database :-) [originally from svn r4453]
2004-08-14 13:04:18 +00:00
/*
* Set up a line discipline.
*/
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
wgs->ldisc = ldisc_create(wgs->conf, wgs->term, wgs->backend, &wgs->seat);
Implement `Restart Session', in both Unix and Windows PuTTY. Largely because Owen questioned whether it was really easy enough to be labelled `fun' in the bug database :-) [originally from svn r4453]
2004-08-14 13:04:18 +00:00
/*
* Destroy the Restart Session menu item. (This will return
* failure if it's already absent, as it will be the very first
* time we call this function. We ignore that, because as long
* as the menu item ends up not being there, we don't care
* whether it was us who removed it or not!)
*/
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
for (i = 0; i < lenof(wgs->popup_menus); i++) {
DeleteMenu(wgs->popup_menus[i].menu, IDM_RESTART, MF_BYCOMMAND);
Implement `Restart Session', in both Unix and Windows PuTTY. Largely because Owen questioned whether it was really easy enough to be labelled `fun' in the bug database :-) [originally from svn r4453]
2004-08-14 13:04:18 +00:00
}
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
wgs->session_closed = false;
Implement `Restart Session', in both Unix and Windows PuTTY. Largely because Owen questioned whether it was really easy enough to be labelled `fun' in the bug database :-) [originally from svn r4453]
2004-08-14 13:04:18 +00:00
}
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
static void close_session(void *vctx)
Implement `Restart Session', in both Unix and Windows PuTTY. Largely because Owen questioned whether it was really easy enough to be labelled `fun' in the bug database :-) [originally from svn r4453]
2004-08-14 13:04:18 +00:00
{
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
WinGuiSeat *wgs = (WinGuiSeat *)vctx;
Remove a load of obsolete printf string limits. In the previous commit I happened to notice a %.150s in a ppl_logevent call, which was probably an important safety precaution a couple of decades ago when that format string was being used for an sprintf into a fixed-size buffer, but now it's just pointless cruft. This commit removes all printf string formatting directives with a compile-time fixed size, with the one exception of a %.3s used to cut out a 3-letter month name in scpserver.c. In cases where the format string in question was already going to an arbitrary-length function like dupprintf or ppl_logevent, that's all I've done; in cases where there was still a fixed-size buffer, I've replaced it with a dynamic buffer and dupprintf.
2018-12-08 21:03:51 +00:00
char *newtitle;
Implement `Restart Session', in both Unix and Windows PuTTY. Largely because Owen questioned whether it was really easy enough to be labelled `fun' in the bug database :-) [originally from svn r4453]
2004-08-14 13:04:18 +00:00
int i;
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
wgs->session_closed = true;
Remove a load of obsolete printf string limits. In the previous commit I happened to notice a %.150s in a ppl_logevent call, which was probably an important safety precaution a couple of decades ago when that format string was being used for an sprintf into a fixed-size buffer, but now it's just pointless cruft. This commit removes all printf string formatting directives with a compile-time fixed size, with the one exception of a %.3s used to cut out a 3-letter month name in scpserver.c. In cases where the format string in question was already going to an arbitrary-length function like dupprintf or ppl_logevent, that's all I've done; in cases where there was still a fixed-size buffer, I've replaced it with a dynamic buffer and dupprintf.
2018-12-08 21:03:51 +00:00
newtitle = dupprintf("%s (inactive)", appname);
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
win_set_icon_title(&wgs->termwin, newtitle, DEFAULT_CODEPAGE);
win_set_title(&wgs->termwin, newtitle, DEFAULT_CODEPAGE);
Remove a load of obsolete printf string limits. In the previous commit I happened to notice a %.150s in a ppl_logevent call, which was probably an important safety precaution a couple of decades ago when that format string was being used for an sprintf into a fixed-size buffer, but now it's just pointless cruft. This commit removes all printf string formatting directives with a compile-time fixed size, with the one exception of a %.3s used to cut out a 3-letter month name in scpserver.c. In cases where the format string in question was already going to an arbitrary-length function like dupprintf or ppl_logevent, that's all I've done; in cases where there was still a fixed-size buffer, I've replaced it with a dynamic buffer and dupprintf.
2018-12-08 21:03:51 +00:00
sfree(newtitle);
Implement `Restart Session', in both Unix and Windows PuTTY. Largely because Owen questioned whether it was really easy enough to be labelled `fun' in the bug database :-) [originally from svn r4453]
2004-08-14 13:04:18 +00:00
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
if (wgs->ldisc) {
ldisc_free(wgs->ldisc);
wgs->ldisc = NULL;
Implement `Restart Session', in both Unix and Windows PuTTY. Largely because Owen questioned whether it was really easy enough to be labelled `fun' in the bug database :-) [originally from svn r4453]
2004-08-14 13:04:18 +00:00
}
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
if (wgs->backend) {
backend_free(wgs->backend);
wgs->backend = NULL;
term_provide_backend(wgs->term, NULL);
seat_update_specials_menu(&wgs->seat);
Implement `Restart Session', in both Unix and Windows PuTTY. Largely because Owen questioned whether it was really easy enough to be labelled `fun' in the bug database :-) [originally from svn r4453]
2004-08-14 13:04:18 +00:00
}
/*
* Show the Restart Session menu item. Do a precautionary
* delete first to ensure we never end up with more than one.
*/
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
for (i = 0; i < lenof(wgs->popup_menus); i++) {
DeleteMenu(wgs->popup_menus[i].menu, IDM_RESTART, MF_BYCOMMAND);
InsertMenu(wgs->popup_menus[i].menu, IDM_DUPSESS,
MF_BYCOMMAND | MF_ENABLED, IDM_RESTART, "&Restart Session");
Implement `Restart Session', in both Unix and Windows PuTTY. Largely because Owen questioned whether it was really easy enough to be labelled `fun' in the bug database :-) [originally from svn r4453]
2004-08-14 13:04:18 +00:00
}
}
Windows: runtime switch between Unicode and ANSI windows. Turns out that PuTTY hasn't run successfully on legacy Windows since 0.66, in spite of an ongoing intention to keep it working. Among the reasons for this is that CreateWindowExW simply fails with ERROR_CALL_NOT_IMPLEMENTED: apparently Win95 and its ilk just didn't have fully-Unicode windows as an option. Fixed by resurrecting the previous code from the git history (in particular, code removed by commit 67e5ceb9a8e6bc2 was useful), and including it as a runtime alternative. One subtlety was that I found I had to name the A and W window classes differently (by appending ".ansi" to the A one): apparently they occupy the same namespace even though the names are in different character sets, so if you somehow manage to register both classes, they'll collide with each other without that tweak.
2022-03-12 06:43:59 +00:00
/*
* Some machinery to deal with switching the window type between ANSI
* and Unicode. We prefer Unicode, but some PuTTY builds still try to
* run on machines so old that they don't support that mode. So we're
* prepared to fall back to an ANSI window if we have to. For this
* purpose, we swap out a few Windows API functions, and wrap
* SetWindowText so that if we're not in Unicode mode we first convert
* the wide string we're given.
*/
static bool unicode_window;
static BOOL (WINAPI *sw_PeekMessage)(LPMSG, HWND, UINT, UINT, UINT);
static LRESULT (WINAPI *sw_DispatchMessage)(const MSG *);
static LRESULT (WINAPI *sw_DefWindowProc)(HWND, UINT, WPARAM, LPARAM);
static void sw_SetWindowText(HWND hwnd, wchar_t *text)
{
if (unicode_window) {
SetWindowTextW(hwnd, text);
} else {
dup_mb_to_wc, dup_wc_to_mb: remove the 'flags' parameter. This parameter was undocumented, and Windows-specific: its semantics date from before PuTTY was cross-platform, and are "Pass this flags parameter straight through to the Win32 API's conversion functions". So in Windows platform code you can pass flags like MB_USEGLYPHCHARS, but in cross-platform code, you dare not pass anything nonzero at all because the Unix frontend won't recognise it (or, likely, even compile). I've kept the flag for now in the underlying mb_to_wc / wc_to_mb functions. Partly that's because there's one place in the Windows code where the parameter _is_ used; mostly, it's because I'm about to replace those functions anyway, so there's no point in editing all the call sites twice.
2024-09-24 07:46:39 +00:00
char *mb = dup_wc_to_mb(DEFAULT_CODEPAGE, text, "?");
Windows: runtime switch between Unicode and ANSI windows. Turns out that PuTTY hasn't run successfully on legacy Windows since 0.66, in spite of an ongoing intention to keep it working. Among the reasons for this is that CreateWindowExW simply fails with ERROR_CALL_NOT_IMPLEMENTED: apparently Win95 and its ilk just didn't have fully-Unicode windows as an option. Fixed by resurrecting the previous code from the git history (in particular, code removed by commit 67e5ceb9a8e6bc2 was useful), and including it as a runtime alternative. One subtlety was that I found I had to name the A and W window classes differently (by appending ".ansi" to the A one): apparently they occupy the same namespace even though the names are in different character sets, so if you somehow manage to register both classes, they'll collide with each other without that tweak.
2022-03-12 06:43:59 +00:00
SetWindowTextA(hwnd, mb);
sfree(mb);
}
}
static HINSTANCE hprev;
/*
* Also, registering window classes has to be done in a fiddly way.
*/
#define SETUP_WNDCLASS(wndclass, classname) do { \
wndclass.style = 0; \
wndclass.lpfnWndProc = WndProc; \
wndclass.cbClsExtra = 0; \
wndclass.cbWndExtra = 0; \
wndclass.hInstance = hinst; \
wndclass.hIcon = LoadIcon(hinst, MAKEINTRESOURCE(IDI_MAINICON)); \
wndclass.hCursor = LoadCursor(NULL, IDC_IBEAM); \
wndclass.hbrBackground = NULL; \
wndclass.lpszMenuName = NULL; \
wndclass.lpszClassName = classname; \
} while (0)
wchar_t *terminal_window_class_w(void)
{
static wchar_t *classname = NULL;
if (!classname)
dup_mb_to_wc, dup_wc_to_mb: remove the 'flags' parameter. This parameter was undocumented, and Windows-specific: its semantics date from before PuTTY was cross-platform, and are "Pass this flags parameter straight through to the Win32 API's conversion functions". So in Windows platform code you can pass flags like MB_USEGLYPHCHARS, but in cross-platform code, you dare not pass anything nonzero at all because the Unix frontend won't recognise it (or, likely, even compile). I've kept the flag for now in the underlying mb_to_wc / wc_to_mb functions. Partly that's because there's one place in the Windows code where the parameter _is_ used; mostly, it's because I'm about to replace those functions anyway, so there's no point in editing all the call sites twice.
2024-09-24 07:46:39 +00:00
classname = dup_mb_to_wc(DEFAULT_CODEPAGE, appname);
Windows: runtime switch between Unicode and ANSI windows. Turns out that PuTTY hasn't run successfully on legacy Windows since 0.66, in spite of an ongoing intention to keep it working. Among the reasons for this is that CreateWindowExW simply fails with ERROR_CALL_NOT_IMPLEMENTED: apparently Win95 and its ilk just didn't have fully-Unicode windows as an option. Fixed by resurrecting the previous code from the git history (in particular, code removed by commit 67e5ceb9a8e6bc2 was useful), and including it as a runtime alternative. One subtlety was that I found I had to name the A and W window classes differently (by appending ".ansi" to the A one): apparently they occupy the same namespace even though the names are in different character sets, so if you somehow manage to register both classes, they'll collide with each other without that tweak.
2022-03-12 06:43:59 +00:00
if (!hprev) {
WNDCLASSW wndclassw;
SETUP_WNDCLASS(wndclassw, classname);
RegisterClassW(&wndclassw);
}
return classname;
}
char *terminal_window_class_a(void)
{
static char *classname = NULL;
if (!classname)
classname = dupcat(appname, ".ansi");
if (!hprev) {
WNDCLASSA wndclassa;
SETUP_WNDCLASS(wndclassa, classname);
RegisterClassA(&wndclassa);
}
return classname;
}
Remove remaining uses of the GLOBAL macro. We now have no remaining things in header files that switch from being a declaration to a definition depending on an awkward #define at the point of including that header. There are still a few mutable variables with external linkage, but at least now each one is defined in a specific source file file appropriate to its purpose and context. The remaining globals as of this commit were: - 'logctx' and 'term', which never needed to be globals in the first place, because they were never actually shared between source files. Now 'term' is just a static in window.c, and 'logctx' is a static in each of that and winplink.c. - 'hinst', which still has external linkage, but is now defined separately in each source file that sets it up (i.e. those with a WinMain) - osMajorVersion, osMinorVersion and osPlatformId, whose definitions now live in winmisc.c alongside the code which sets them up. (Actually they were defined there all along, it turns out, but every toolchain I've built with has commoned them together with the version defined by the GLOBAL in the header.) - 'hwnd', which nothing was actually _using_ any more after previous commits, so all this commit had to do was delete it.
2020-02-02 10:00:43 +00:00
HINSTANCE hinst;
Run entire source base through GNU indent to tidy up the varying coding styles of the various contributors! Woohoo! [originally from svn r1098]
2001-05-06 14:35:20 +00:00
int WINAPI WinMain(HINSTANCE inst, HINSTANCE prev, LPSTR cmdline, int show)
{
Initial checkin: beta 0.43 [originally from svn r11]
1999-01-08 13:02:13 +00:00
MSG msg;
Support for Windows 7 jump lists (right-click on a program's taskbar icon, even if the program isn't running at the time, to be presented with an application-defined collection of helpful links). The current jump list is updated every time a saved session is loaded, and shows the last few launchable saved sessions (i.e. not those like Default Settings) that were loaded. Also, if Pageant or PuTTYgen or both is in the same directory as the PuTTY binary, the jump list will present links to launch those too. Based on a patch sent last year by Daniel B. Roy, though it's barely recognisable any more... [originally from svn r9046]
2010-12-23 17:32:28 +00:00
HRESULT hr;
Initial checkin: beta 0.43 [originally from svn r11]
1999-01-08 13:02:13 +00:00
int guess_width, guess_height;
Lock down the search path for Windows DLL loading. At least on systems providing SetDefaultDllDirectories, this should stop PuTTY from being willing to load DLLs from its containing directory - which makes no difference when it's been properly installed (in which case the application dir contains no DLLs anyway), but does if it's being run from somewhere uncontrolled like a browser downloads directory. Preliminary testing suggests that this shouldn't break any existing deliberate use of DLLs, including GSSAPI providers.
2016-07-18 19:02:32 +00:00
dll_hijacking_protection();
Arm: turn on PSTATE.DIT if available and needed. DIT, for 'Data-Independent Timing', is a bit you can set in the processor state on sufficiently new Arm CPUs, which promises that a long list of instructions will deliberately avoid varying their timing based on the input register values. Just what you want for keeping your constant-time crypto primitives constant-time. As far as I'm aware, no CPU has _yet_ implemented any data-dependent optimisations, so DIT is a safety precaution against them doing so in future. It would be embarrassing to be caught without it if a future CPU does do that, so we now turn on DIT in the PuTTY process state. I've put a call to the new enable_dit() function at the start of every main() and WinMain() belonging to a program that might do cryptography (even testcrypt, in case someone uses it for something!), and in case I missed one there, also added a second call at the first moment that any cryptography-using part of the code looks as if it might become active: when an instance of the SSH protocol object is configured, when the system PRNG is initialised, and when selecting any cryptographic authentication protocol in an HTTP or SOCKS proxy connection. With any luck those precautions between them should ensure it's on whenever we need it. Arm's own recommendation is that you should carefully choose the granularity at which you enable and disable DIT: there's a potential time cost to turning it on and off (I'm not sure what, but plausibly something of the order of a pipeline flush), so it's a performance hit to do it _inside_ each individual crypto function, but if CPUs start supporting significant data-dependent optimisation in future, then it will also become a noticeable performance hit to just leave it on across the whole process. So you'd like to do it somewhere in the middle: for example, you might turn on DIT once around the whole process of verifying and decrypting an SSH packet, instead of once for decryption and once for MAC. With all respect to that recommendation as a strategy for maximum performance, I'm not following it here. I turn on DIT at the start of the PuTTY process, and then leave it on. Rationale: 1. PuTTY is not otherwise a performance-critical application: it's not likely to max out your CPU for any purpose _other_ than cryptography. The most CPU-intensive non-cryptographic thing I can imagine a PuTTY process doing is the complicated computation of font rendering in the terminal, and that will normally be cached (you don't recompute each glyph from its outline and hints for every time you display it). 2. I think a bigger risk lies in accidental side channels from having DIT turned off when it should have been on. I can imagine lots of causes for that. Missing a crypto operation in some unswept corner of the code; confusing control flow (like my coroutine macros) jumping with DIT clear into the middle of a region of code that expected DIT to have been set at the beginning; having a reference counter of DIT requests and getting it out of sync. In a more sophisticated programming language, it might be possible to avoid the risk in #2 by cleverness with the type system. For example, in Rust, you could have a zero-sized type that acts as a proof token for DIT being enabled (it would be constructed by a function that also sets DIT, have a Drop implementation that clears DIT, and be !Send so you couldn't use it in a thread other than the one where DIT was set), and then you could require all the actual crypto functions to take a DitToken as an extra parameter, at zero runtime cost. Then "oops I forgot to set DIT around this piece of crypto" would become a compile error. Even so, you'd have to take some care with coroutine-structured code (what happens if a Rust async function yields while holding a DIT token?) and with nesting (if you have two DIT tokens, you don't want dropping the inner one to clear DIT while the outer one is still there to wrongly convince callees that it's set). Maybe in Rust you could get this all to work reliably. But not in C! DIT is an optional feature of the Arm architecture, so we must first test to see if it's supported. This is done the same way as we already do for the various Arm crypto accelerators: on ELF-based systems, check the appropriate bit in the 'hwcap' words in the ELF aux vector; on Mac, look for an appropriate sysctl flag. On Windows I don't know of a way to query the DIT feature, _or_ of a way to write the necessary enabling instruction in an MSVC-compatible way. I've _heard_ that it might not be necessary, because Windows might just turn on DIT unconditionally and leave it on, in an even more extreme version of my own strategy. I don't have a source for that - I heard it by word of mouth - but I _hope_ it's true, because that would suit me very well! Certainly I can't write code to enable DIT without knowing (a) how to do it, (b) how to know if it's safe. Nonetheless, I've put the enable_dit() call in all the right places in the Windows main programs as well as the Unix and cross-platform code, so that if I later find out that I _can_ put in an explicit enable of DIT in some way, I'll only have to arrange to set HAVE_ARM_DIT and compile the enable_dit() function appropriately.
2024-12-19 08:47:08 +00:00
enable_dit();
Lock down the search path for Windows DLL loading. At least on systems providing SetDefaultDllDirectories, this should stop PuTTY from being willing to load DLLs from its containing directory - which makes no difference when it's been properly installed (in which case the application dir contains no DLLs anyway), but does if it's being run from somewhere uncontrolled like a browser downloads directory. Preliminary testing suggests that this shouldn't break any existing deliberate use of DLLs, including GSSAPI providers.
2016-07-18 19:02:32 +00:00
Miscellaneous cleanups and reorgs in preparation for building PuTTYgen. In particular, moved self-managing controls stuff out of windlg.c into the new and reusable winctrls.c. [originally from svn r714]
2000-10-18 15:36:32 +00:00
hinst = inst;
Windows: runtime switch between Unicode and ANSI windows. Turns out that PuTTY hasn't run successfully on legacy Windows since 0.66, in spite of an ongoing intention to keep it working. Among the reasons for this is that CreateWindowExW simply fails with ERROR_CALL_NOT_IMPLEMENTED: apparently Win95 and its ilk just didn't have fully-Unicode windows as an option. Fixed by resurrecting the previous code from the git history (in particular, code removed by commit 67e5ceb9a8e6bc2 was useful), and including it as a runtime alternative. One subtlety was that I found I had to name the A and W window classes differently (by appending ".ansi" to the A one): apparently they occupy the same namespace even though the names are in different character sets, so if you somehow manage to register both classes, they'll collide with each other without that tweak.
2022-03-12 06:43:59 +00:00
hprev = prev;
John Sullivan's sizetip patch - experimental [originally from svn r269]
1999-11-03 14:08:26 +00:00
Created a shiny new abstraction for the socket handling. Has many advantages: - protocol modules can call sk_write() without having to worry about writes blocking, because blocking writes are handled in the abstraction layer and retried later. - `Lost connection while sending' is a thing of the past. - <winsock.h> is no longer needed in most modules, because "putty.h" doesn't have to declare `SOCKET' variables any more, only the abstracted `Socket' type. - select()-equivalent between multiple sockets will now be handled sensibly, which opens the way for things like SSH port forwarding. [originally from svn r744]
2000-10-23 10:32:37 +00:00
sk_init();
Initial checkin: beta 0.43 [originally from svn r11]
1999-01-08 13:02:13 +00:00
Load comctl32.dll (for drag lists) at run time. This too is not in the list of known DLLs on Windows 10. I don't know of any actual viable hijacking attack based on it, which according to my reading of MSDN (specifically, a rather vague hint in https://msdn.microsoft.com/library/ff919712) _may_ be because we mention the common controls assembly in our application manifest; but better safe than sorry. Now the entire list of remaining DLLs that PuTTY links against at load time is a subset of the Win10 known DLLs list, so that _should_ mean that everything we load before we've deployed our own defence (SetDefaultDllDirectories) is defended against for us by Windows itself.
2017-03-13 21:42:44 +00:00
init_common_controls();
Initial checkin: beta 0.43 [originally from svn r11]
1999-01-08 13:02:13 +00:00
SetCurrentProcessExplicitAppUserModelID to fix jumplist/removable media bug The algorithm Windows uses to generate AppUserModelIDs "hangs on" to removable media (CDs/DVDs) if PuTTY is launched with a CD/DVD in a drive. Set the AppUserModelID explicitly to avoid using this algorithm.
2016-08-29 15:55:42 +00:00
/* Set Explicit App User Model Id so that jump lists don't cause
PuTTY to hang on to removable media. */
set_explicit_app_user_model_id();
Implement a much more visually appealing, but much more internally grotty, hack to get around Explorer maximising the config box. [originally from svn r707]
2000-10-12 12:56:33 +00:00
/* Ensure a Maximize setting in Explorer doesn't maximise the
* config box. */
defuse_showwindow();
Fix Windows warning about GetVersionEx deprecation. Rather than squelching the warning, I'm actually paying attention to the deprecation, in that I'm allowing for the possibility that the function might stop existing or stop returning success.
2018-06-03 14:05:44 +00:00
init_winver();
Glenn Maynard's IME patch [originally from svn r1172]
2001-08-04 15:15:07 +00:00
A contributor tells me that WM_MOUSEWHEEL is not supported in Win95, and offers a patch that uses RegisterMessage() to acquire the correct dynamic message number to use instead. [originally from svn r1499]
2001-12-15 14:30:58 +00:00
/*
* If we're running a version of Windows that doesn't support
* WM_MOUSEWHEEL, find out what message number we should be
* using instead.
*/
Fix Windows warning about GetVersionEx deprecation. Rather than squelching the warning, I'm actually paying attention to the deprecation, in that I'm allowing for the possibility that the function might stop existing or stop returning success.
2018-06-03 14:05:44 +00:00
if (osMajorVersion < 4 ||
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
(osMajorVersion == 4 && osPlatformId != VER_PLATFORM_WIN32_NT))
wm_mousewheel = RegisterWindowMessage("MSWHEEL_ROLLMSG");
A contributor tells me that WM_MOUSEWHEEL is not supported in Win95, and offers a patch that uses RegisterMessage() to acquire the correct dynamic message number to use instead. [originally from svn r1499]
2001-12-15 14:30:58 +00:00
Initial support for HTML Help. All the ad-hoc help-file finding code and various calls to WinHelp() have been centralised into a new file winhelp.c, which in turn has been modified to detect a .CHM file as well as .HLP and select between them as appropriate. It explicitly tries to load HHCTRL.OCX and use GetProcAddress, meaning that it _should_ still work correctly on pre-HTML-Help platforms, falling gracefully back to WinHelp, but although I tested this by temporarily renaming my own HHCTRL.OCX I haven't yet been able to test it on a real HTML-Help-free platform. Also in this checkin: a new .but file and docs makefile changes to make it convenient to build the sources for a .CHM. As yet, owing to limitations of Halibut's CHM support, I'm not able to write a .CHM directly, more's the pity. [originally from svn r7000]
2006-12-17 11:16:07 +00:00
init_help();
Integrate PuTTY and its help file. Now that's what I call a good lunchtime's work :-) [originally from svn r1458]
2001-12-06 13:28:02 +00:00
Find ToUnicodeEx() at run time, not load time. This restores PuTTY's backward compatibility to versions of Windows too old to have ToUnicodeEx in their system libraries, which was accidentally broken in 0.63. [originally from svn r10061]
2013-11-17 14:03:20 +00:00
init_winfuncs();
At least, I have the technology to fix `beepind-win2k'. Tested on Win98, Win2K, and WinXP. [originally from svn r7119] [this svn revision also touched putty-wishlist]
2007-01-16 20:54:58 +00:00
Windows: move GUI timer handling into a utils module. Previously, the timing.c subsystem worked in Windows PuTTY by means of scheduling WM_TIMER messages to be sent to the terminal window. Now it uses a separate hidden window instead, and all the machinery for handling that window lives on its own in windows/utils/gui-timing.c. Most immediately, this removes a use of wgs.term_hwnd that will become awkward when I move that structure in a following commit. But also, it will make it easier to add the same timing subsystem to unrelated GUI programs, such as Windows Pageant: if we ever decide to implement automatic deletion or re-encryption of unused keys after a timeout, this will help make that easier.
2022-09-12 10:57:15 +00:00
setup_gui_timing();
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
WinGuiSeat *wgs = snew(WinGuiSeat);
memset(wgs, 0, sizeof(*wgs));
wgs_link(wgs);
wgs->seat.vt = &win_seat_vt;
wgs->logpolicy.vt = &win_gui_logpolicy_vt;
wgs->termwin.vt = &windows_termwin_vt;
wgs->caret_x = wgs->caret_y = -1;
wgs->busy_status = BUSY_NOT;
wgs->conf = conf_new();
Post-release destabilisation! Completely remove the struct type 'Config' in putty.h, which stores all PuTTY's settings and includes an arbitrary length limit on every single one of those settings which is stored in string form. In place of it is 'Conf', an opaque data type everywhere outside the new file conf.c, which stores a list of (key, value) pairs in which every key contains an integer identifying a configuration setting, and for some of those integers the key also contains extra parts (so that, for instance, CONF_environmt is a string-to-string mapping). Everywhere that a Config was previously used, a Conf is now; everywhere there was a Config structure copy, conf_copy() is called; every lookup, adjustment, load and save operation on a Config has been rewritten; and there's a mechanism for serialising a Conf into a binary blob and back for use with Duplicate Session. User-visible effects of this change _should_ be minimal, though I don't doubt I've introduced one or two bugs here and there which will eventually be found. The _intended_ visible effects of this change are that all arbitrary limits on configuration strings and lists (e.g. limit on number of port forwardings) should now disappear; that list boxes in the configuration will now be displayed in a sorted order rather than the arbitrary order in which they were added to the list (since the underlying data structure is now a sorted tree234 rather than an ad-hoc comma-separated string); and one more specific change, which is that local and dynamic port forwardings on the same port number are now mutually exclusive in the configuration (putting 'D' in the key rather than the value was a mistake in the first place). One other reorganisation as a result of this is that I've moved all the dialog.c standard handlers (dlg_stdeditbox_handler and friends) out into config.c, because I can't really justify calling them generic any more. When they took a pointer to an arbitrary structure type and the offset of a field within that structure, they were independent of whether that structure was a Config or something completely different, but now they really do expect to talk to a Conf, which can _only_ be used for PuTTY configuration, so I've renamed them all things like conf_editbox_handler and moved them out of the nominally independent dialog-box management module into the PuTTY-specific config.c. [originally from svn r9214]
2011-07-14 18:52:21 +00:00
Support for Windows 7 jump lists (right-click on a program's taskbar icon, even if the program isn't running at the time, to be presented with an application-defined collection of helpful links). The current jump list is updated every time a saved session is loaded, and shows the last few launchable saved sessions (i.e. not those like Default Settings) that were loaded. Also, if Pageant or PuTTYgen or both is in the same directory as the PuTTY binary, the jump list will present links to launch those too. Based on a patch sent last year by Daniel B. Roy, though it's barely recognisable any more... [originally from svn r9046]
2010-12-23 17:32:28 +00:00
/*
* Initialize COM.
*/
hr = CoInitialize(NULL);
if (hr != S_OK && hr != S_FALSE) {
char *str = dupprintf("%s Fatal Error", appname);
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
MessageBox(NULL, "Failed to initialize COM subsystem",
str, MB_OK | MB_ICONEXCLAMATION);
sfree(str);
return 1;
Support for Windows 7 jump lists (right-click on a program's taskbar icon, even if the program isn't running at the time, to be presented with an application-defined collection of helpful links). The current jump list is updated every time a saved session is loaded, and shows the last few launchable saved sessions (i.e. not those like Default Settings) that were loaded. Also, if Pageant or PuTTYgen or both is in the same directory as the PuTTY binary, the jump list will present links to launch those too. Based on a patch sent last year by Daniel B. Roy, though it's barely recognisable any more... [originally from svn r9046]
2010-12-23 17:32:28 +00:00
}
Initial checkin: beta 0.43 [originally from svn r11]
1999-01-08 13:02:13 +00:00
/*
* Process the command line.
PuTTY WinMain: comment when config box pops up. It's not entirely obvious, these days.
2022-11-06 02:04:39 +00:00
* (If the command line doesn't provide enough info to start a
* session, this will detour via the config box.)
Initial checkin: beta 0.43 [originally from svn r11]
1999-01-08 13:02:13 +00:00
*/
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
gui_term_process_cmdline(wgs->conf, cmdline);
Initial checkin: beta 0.43 [originally from svn r11]
1999-01-08 13:02:13 +00:00
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
memset(&wgs->ucsdata, 0, sizeof(wgs->ucsdata));
Deglobalise the Unicode module. Despite all my grand plans, I've just done this the very simple way - bundle all the globals into a data structure and pass pointers around. One particularly ugly wart is that wc_to_mb now takes a pointer to this structure as an argument (optional, may be NULL, and unused in any Unicode layer that's even marginally less of a mess than the Windows one). I do need to do this properly at some point, but for now this should just about be adequate. As usual, the Mac port has not been updated. [originally from svn r2592]
2003-01-14 18:28:23 +00:00
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
conf_cache_data(wgs);
Post-release destabilisation! Completely remove the struct type 'Config' in putty.h, which stores all PuTTY's settings and includes an arbitrary length limit on every single one of those settings which is stored in string form. In place of it is 'Conf', an opaque data type everywhere outside the new file conf.c, which stores a list of (key, value) pairs in which every key contains an integer identifying a configuration setting, and for some of those integers the key also contains extra parts (so that, for instance, CONF_environmt is a string-to-string mapping). Everywhere that a Config was previously used, a Conf is now; everywhere there was a Config structure copy, conf_copy() is called; every lookup, adjustment, load and save operation on a Config has been rewritten; and there's a mechanism for serialising a Conf into a binary blob and back for use with Duplicate Session. User-visible effects of this change _should_ be minimal, though I don't doubt I've introduced one or two bugs here and there which will eventually be found. The _intended_ visible effects of this change are that all arbitrary limits on configuration strings and lists (e.g. limit on number of port forwardings) should now disappear; that list boxes in the configuration will now be displayed in a sorted order rather than the arbitrary order in which they were added to the list (since the underlying data structure is now a sorted tree234 rather than an ad-hoc comma-separated string); and one more specific change, which is that local and dynamic port forwardings on the same port number are now mutually exclusive in the configuration (putting 'D' in the key rather than the value was a mistake in the first place). One other reorganisation as a result of this is that I've moved all the dialog.c standard handlers (dlg_stdeditbox_handler and friends) out into config.c, because I can't really justify calling them generic any more. When they took a pointer to an arbitrary structure type and the offset of a field within that structure, they were independent of whether that structure was a Config or something completely different, but now they really do expect to talk to a Conf, which can _only_ be used for PuTTY configuration, so I've renamed them all things like conf_editbox_handler and moved them out of the nominally independent dialog-box management module into the PuTTY-specific config.c. [originally from svn r9214]
2011-07-14 18:52:21 +00:00
Initial checkin: beta 0.43 [originally from svn r11]
1999-01-08 13:02:13 +00:00
/*
* Guess some defaults for the window size. This all gets
* updated later, so we don't really care too much. However, we
* do want the font width/height guesses to correspond to a
* large font rather than a small one...
*/
Run entire source base through GNU indent to tidy up the varying coding styles of the various contributors! Woohoo! [originally from svn r1098]
2001-05-06 14:35:20 +00:00
windows/window.c: move more variables into WinGuiSeat. In commit f9e572595bb8cb6 I claimed that I'd removed very nearly all the global and static variables from windows/window.c. It turns out that this was wildly overoptimistic - I missed quite a few of them! I'm not quite sure how I managed that; my best guess is that I used an underpowered 'nm' command that failed to find some classes of variable. Some of the remaining function-scope statics were removed completely by commit afb3dab1e97a09f just now. In this commit, I've swept up some more and turn them into fields of WinGuiSeat, where they should have been moved last September. The (hopefully complete this time) list of remaining variables, generated by running this rune in the Windows build directory: nm windows/CMakeFiles/putty.dir/window.c.obj | grep -E '^([^ ]+)? *[bBcCdDgGsS] [^\.]' consists of the following variables which are legitimately global across the whole process and not related to a particular window: - 'hinst' and 'hprev', instance handles for Windows loadable modules - 'classname' in the terminal_window_class_a() and terminal_window_class_w() functions, which allocate a window class reusably - some pointers to Windows API functions retrieved via the DECL_WINDOWS_FUNCTION / GET_WINDOWS_FUNCTION system, such as p_AdjustWindowRectExForDpi and p_FlashWindowEx - some pointers to Windows API functions set up by assigning them at startup to the right one of the ANSI or Unicode version depending on the Windows version, e.g. sw_DefWindowProc and sw_DispatchMessage - 'unicode_window', a boolean flag set at the same time as those sw_Foo function pointers - 'sesslist', storing the last-retrieved version of the saved sessions menu - 'cursor_visible' in show_mouseptr() and 'forced_visible' in update_mouse_pointer(), each of which tracks the cumulative number of times that function has shown or hidden the mouse pointer, so as to manage its effect on the global state updated by ShowCursor - 'trust_icon', loaded from the executable's resources - 'wgslisthead', the list of all active WinGuiSeats - 'wm_mousewheel', the window-message id we use for mouse wheel events and the following which are nothing to do with our code: - '_OptionsStorage' in __local_stdio_printf_options() and __local_stdio_scanf_options(), which I'd never noticed before, but apparently are internal to a standard library header.
2023-05-27 13:59:20 +00:00
wgs->font_width = 10;
wgs->font_height = 20;
wgs->extra_width = 25;
wgs->extra_height = 28;
guess_width = wgs->extra_width + wgs->font_width * conf_get_int(
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
wgs->conf, CONF_width);
windows/window.c: move more variables into WinGuiSeat. In commit f9e572595bb8cb6 I claimed that I'd removed very nearly all the global and static variables from windows/window.c. It turns out that this was wildly overoptimistic - I missed quite a few of them! I'm not quite sure how I managed that; my best guess is that I used an underpowered 'nm' command that failed to find some classes of variable. Some of the remaining function-scope statics were removed completely by commit afb3dab1e97a09f just now. In this commit, I've swept up some more and turn them into fields of WinGuiSeat, where they should have been moved last September. The (hopefully complete this time) list of remaining variables, generated by running this rune in the Windows build directory: nm windows/CMakeFiles/putty.dir/window.c.obj | grep -E '^([^ ]+)? *[bBcCdDgGsS] [^\.]' consists of the following variables which are legitimately global across the whole process and not related to a particular window: - 'hinst' and 'hprev', instance handles for Windows loadable modules - 'classname' in the terminal_window_class_a() and terminal_window_class_w() functions, which allocate a window class reusably - some pointers to Windows API functions retrieved via the DECL_WINDOWS_FUNCTION / GET_WINDOWS_FUNCTION system, such as p_AdjustWindowRectExForDpi and p_FlashWindowEx - some pointers to Windows API functions set up by assigning them at startup to the right one of the ANSI or Unicode version depending on the Windows version, e.g. sw_DefWindowProc and sw_DispatchMessage - 'unicode_window', a boolean flag set at the same time as those sw_Foo function pointers - 'sesslist', storing the last-retrieved version of the saved sessions menu - 'cursor_visible' in show_mouseptr() and 'forced_visible' in update_mouse_pointer(), each of which tracks the cumulative number of times that function has shown or hidden the mouse pointer, so as to manage its effect on the global state updated by ShowCursor - 'trust_icon', loaded from the executable's resources - 'wgslisthead', the list of all active WinGuiSeats - 'wm_mousewheel', the window-message id we use for mouse wheel events and the following which are nothing to do with our code: - '_OptionsStorage' in __local_stdio_printf_options() and __local_stdio_scanf_options(), which I'd never noticed before, but apparently are internal to a standard library header.
2023-05-27 13:59:20 +00:00
guess_height = wgs->extra_height + wgs->font_height * conf_get_int(
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
wgs->conf, CONF_height);
Initial checkin: beta 0.43 [originally from svn r11]
1999-01-08 13:02:13 +00:00
{
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
RECT r;
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
get_fullscreen_rect(wgs, &r);
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
if (guess_width > r.right - r.left)
guess_width = r.right - r.left;
if (guess_height > r.bottom - r.top)
guess_height = r.bottom - r.top;
Initial checkin: beta 0.43 [originally from svn r11]
1999-01-08 13:02:13 +00:00
}
Robert de Bath's Big Patch, part 1 [originally from svn r516]
2000-07-26 12:13:51 +00:00
{
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
int winmode = WS_OVERLAPPEDWINDOW | WS_VSCROLL;
int exwinmode = 0;
New backend function to disable resizing. Some protocols such as SUPDUP does not support resizing the terminal.
2020-02-14 12:49:56 +00:00
const struct BackendVtable *vt =
backend_vt_from_proto(be_default_protocol);
bool resize_forbidden = false;
if (vt && vt->flags & BACKEND_RESIZE_FORBIDDEN)
resize_forbidden = true;
dup_mb_to_wc, dup_wc_to_mb: remove the 'flags' parameter. This parameter was undocumented, and Windows-specific: its semantics date from before PuTTY was cross-platform, and are "Pass this flags parameter straight through to the Win32 API's conversion functions". So in Windows platform code you can pass flags like MB_USEGLYPHCHARS, but in cross-platform code, you dare not pass anything nonzero at all because the Unix frontend won't recognise it (or, likely, even compile). I've kept the flag for now in the underlying mb_to_wc / wc_to_mb functions. Partly that's because there's one place in the Windows code where the parameter _is_ used; mostly, it's because I'm about to replace those functions anyway, so there's no point in editing all the call sites twice.
2024-09-24 07:46:39 +00:00
wchar_t *uappname = dup_mb_to_wc(DEFAULT_CODEPAGE, appname);
wgs->window_name = dup_mb_to_wc(DEFAULT_CODEPAGE, appname);
wgs->icon_name = dup_mb_to_wc(DEFAULT_CODEPAGE, appname);
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
if (!conf_get_bool(wgs->conf, CONF_scrollbar))
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
winmode &= ~(WS_VSCROLL);
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
if (conf_get_int(wgs->conf, CONF_resize_action) == RESIZE_DISABLED ||
New backend function to disable resizing. Some protocols such as SUPDUP does not support resizing the terminal.
2020-02-14 12:49:56 +00:00
resize_forbidden)
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
winmode &= ~(WS_THICKFRAME | WS_MAXIMIZEBOX);
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
if (conf_get_bool(wgs->conf, CONF_alwaysontop))
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
exwinmode |= WS_EX_TOPMOST;
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
if (conf_get_bool(wgs->conf, CONF_sunken_edge))
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
exwinmode |= WS_EX_CLIENTEDGE;
Windows: runtime switch between Unicode and ANSI windows. Turns out that PuTTY hasn't run successfully on legacy Windows since 0.66, in spite of an ongoing intention to keep it working. Among the reasons for this is that CreateWindowExW simply fails with ERROR_CALL_NOT_IMPLEMENTED: apparently Win95 and its ilk just didn't have fully-Unicode windows as an option. Fixed by resurrecting the previous code from the git history (in particular, code removed by commit 67e5ceb9a8e6bc2 was useful), and including it as a runtime alternative. One subtlety was that I found I had to name the A and W window classes differently (by appending ".ansi" to the A one): apparently they occupy the same namespace even though the names are in different character sets, so if you somehow manage to register both classes, they'll collide with each other without that tweak.
2022-03-12 06:43:59 +00:00
#ifdef TEST_ANSI_WINDOW
/* For developer testing of ANSI window support, pretend
* CreateWindowExW failed */
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
wgs->term_hwnd = NULL;
Windows: runtime switch between Unicode and ANSI windows. Turns out that PuTTY hasn't run successfully on legacy Windows since 0.66, in spite of an ongoing intention to keep it working. Among the reasons for this is that CreateWindowExW simply fails with ERROR_CALL_NOT_IMPLEMENTED: apparently Win95 and its ilk just didn't have fully-Unicode windows as an option. Fixed by resurrecting the previous code from the git history (in particular, code removed by commit 67e5ceb9a8e6bc2 was useful), and including it as a runtime alternative. One subtlety was that I found I had to name the A and W window classes differently (by appending ".ansi" to the A one): apparently they occupy the same namespace even though the names are in different character sets, so if you somehow manage to register both classes, they'll collide with each other without that tweak.
2022-03-12 06:43:59 +00:00
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
#else
unicode_window = true;
sw_PeekMessage = PeekMessageW;
sw_DispatchMessage = DispatchMessageW;
sw_DefWindowProc = DefWindowProcW;
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
wgs->term_hwnd = CreateWindowExW(
Windows: runtime switch between Unicode and ANSI windows. Turns out that PuTTY hasn't run successfully on legacy Windows since 0.66, in spite of an ongoing intention to keep it working. Among the reasons for this is that CreateWindowExW simply fails with ERROR_CALL_NOT_IMPLEMENTED: apparently Win95 and its ilk just didn't have fully-Unicode windows as an option. Fixed by resurrecting the previous code from the git history (in particular, code removed by commit 67e5ceb9a8e6bc2 was useful), and including it as a runtime alternative. One subtlety was that I found I had to name the A and W window classes differently (by appending ".ansi" to the A one): apparently they occupy the same namespace even though the names are in different character sets, so if you somehow manage to register both classes, they'll collide with each other without that tweak.
2022-03-12 06:43:59 +00:00
exwinmode, terminal_window_class_w(), uappname,
winmode, CW_USEDEFAULT, CW_USEDEFAULT,
guess_width, guess_height, NULL, NULL, inst, NULL);
#endif
#if defined LEGACY_WINDOWS || defined TEST_ANSI_WINDOW
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
if (!wgs->term_hwnd && GetLastError() == ERROR_CALL_NOT_IMPLEMENTED) {
Windows: runtime switch between Unicode and ANSI windows. Turns out that PuTTY hasn't run successfully on legacy Windows since 0.66, in spite of an ongoing intention to keep it working. Among the reasons for this is that CreateWindowExW simply fails with ERROR_CALL_NOT_IMPLEMENTED: apparently Win95 and its ilk just didn't have fully-Unicode windows as an option. Fixed by resurrecting the previous code from the git history (in particular, code removed by commit 67e5ceb9a8e6bc2 was useful), and including it as a runtime alternative. One subtlety was that I found I had to name the A and W window classes differently (by appending ".ansi" to the A one): apparently they occupy the same namespace even though the names are in different character sets, so if you somehow manage to register both classes, they'll collide with each other without that tweak.
2022-03-12 06:43:59 +00:00
/* Fall back to an ANSI window, swapping in all the ANSI
* window message handling functions */
unicode_window = false;
sw_PeekMessage = PeekMessageA;
sw_DispatchMessage = DispatchMessageA;
sw_DefWindowProc = DefWindowProcA;
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
wgs->term_hwnd = CreateWindowExA(
Windows: runtime switch between Unicode and ANSI windows. Turns out that PuTTY hasn't run successfully on legacy Windows since 0.66, in spite of an ongoing intention to keep it working. Among the reasons for this is that CreateWindowExW simply fails with ERROR_CALL_NOT_IMPLEMENTED: apparently Win95 and its ilk just didn't have fully-Unicode windows as an option. Fixed by resurrecting the previous code from the git history (in particular, code removed by commit 67e5ceb9a8e6bc2 was useful), and including it as a runtime alternative. One subtlety was that I found I had to name the A and W window classes differently (by appending ".ansi" to the A one): apparently they occupy the same namespace even though the names are in different character sets, so if you somehow manage to register both classes, they'll collide with each other without that tweak.
2022-03-12 06:43:59 +00:00
exwinmode, terminal_window_class_a(), appname,
winmode, CW_USEDEFAULT, CW_USEDEFAULT,
guess_width, guess_height, NULL, NULL, inst, NULL);
}
#endif
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
if (!wgs->term_hwnd) {
Windows: diagnose failure to create the terminal window. It only fails in very unusual circumstances, but that's all the more reason to give a useful report when it does!
2022-03-11 19:11:35 +00:00
modalfatalbox("Unable to create terminal window: %s",
win_strerror(GetLastError()));
}
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
memset(&wgs->dpi_info, 0, sizeof(struct _dpi_info));
init_dpi_info(wgs);
Turn the Windows PuTTY main window into a Unicode window. This causes WM_CHAR messages sent to us to have a wParam containing a 16-bit value encoded in UTF-16, rather than an 8-bit value encoded in the system code page. As far as I can tell, there aren't many other knock-on effects - e.g. you can still interact with the window using ordinary char-based API functions such as SetWindowText, and the Windows API will do the necessary conversions behind the scenes. However, even so, I'm half expecting some sort of unforeseen bug to show up as a result of this.
2015-07-27 19:06:02 +00:00
sfree(uappname);
Run entire source base through GNU indent to tidy up the varying coding styles of the various contributors! Woohoo! [originally from svn r1098]
2001-05-06 14:35:20 +00:00
}
Initial checkin: beta 0.43 [originally from svn r11]
1999-01-08 13:02:13 +00:00
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
SetWindowLongPtr(wgs->term_hwnd, GWLP_USERDATA, (LONG_PTR)wgs);
Fix from Robert de Bath which reorders the Windows initialisation sequence: since init_fonts sets up ucsdata based on the available Windows fonts, we should call it before passing ucsdata to term_init. [originally from svn r9527]
2012-05-13 15:59:24 +00:00
/*
* Initialise the fonts, simultaneously correcting the guesses
* for font_{width,height}.
*/
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
init_fonts(wgs, 0, 0);
Fix from Robert de Bath which reorders the Windows initialisation sequence: since init_fonts sets up ucsdata based on the available Windows fonts, we should call it before passing ucsdata to term_init. [originally from svn r9527]
2012-05-13 15:59:24 +00:00
Centralise palette setup into terminal.c. Now terminal.c makes nearly all the decisions about what the colour palette should actually contain: it does the job of reading the GUI-configurable colours out of Conf, and also the job of making up the rest of the xterm-256 palette. The only exception is that TermWin can provide a method to override some of the default colours, which on Windows is used to implement the 'Use system colours' config option. This saves code overall, partly because the front ends don't have to be able to send palette data back to the Terminal any more (the Terminal keeps the master copy and can answer palette-query escape sequences from its own knowledge), and also because now there's only one copy of the xterm-256 palette setup code (previously gtkwin.c and window.c each had their own version of it). In this rewrite, I've also introduced a multi-layered storage system for the palette data in Terminal. One layer contains the palette information derived from Conf; the next contains platform overrides (currently just Windows's 'Use system colours'); the last one contains overrides set by escape sequences in the middle of the session. The topmost two layers can each _conditionally_ override the ones below. As a result, if a server-side application manually resets (say) the default fg and bg colours in mid-session to something that works well in a particular application, those changes won't be wiped out by a change in the Windows system colours or the Conf, which they would have been before. Instead, changes in Conf or the system colours alter the lower layers of the structure, but then when palette_rebuild is called, the upper layer continues to override them, until a palette reset (ESC]R) or terminal reset (e.g. ESC c) removes those upper-layer changes. This seems like a more consistent strategy, in that the same set of configuration settings will produce the same end result regardless of what order they were applied in. The palette-related methods in TermWin have had a total rework. palette_get and palette_reset are both gone; palette_set can now set a contiguous range of colours in one go; and the new palette_get_overrides replaces window.c's old systopalette().
2021-02-07 19:59:21 +00:00
/*
* Prepare a logical palette.
*/
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
init_palette(wgs);
Centralise palette setup into terminal.c. Now terminal.c makes nearly all the decisions about what the colour palette should actually contain: it does the job of reading the GUI-configurable colours out of Conf, and also the job of making up the rest of the xterm-256 palette. The only exception is that TermWin can provide a method to override some of the default colours, which on Windows is used to implement the 'Use system colours' config option. This saves code overall, partly because the front ends don't have to be able to send palette data back to the Terminal any more (the Terminal keeps the master copy and can answer palette-query escape sequences from its own knowledge), and also because now there's only one copy of the xterm-256 palette setup code (previously gtkwin.c and window.c each had their own version of it). In this rewrite, I've also introduced a multi-layered storage system for the palette data in Terminal. One layer contains the palette information derived from Conf; the next contains platform overrides (currently just Windows's 'Use system colours'); the last one contains overrides set by escape sequences in the middle of the session. The topmost two layers can each _conditionally_ override the ones below. As a result, if a server-side application manually resets (say) the default fg and bg colours in mid-session to something that works well in a particular application, those changes won't be wiped out by a change in the Windows system colours or the Conf, which they would have been before. Instead, changes in Conf or the system colours alter the lower layers of the structure, but then when palette_rebuild is called, the upper layer continues to override them, until a palette reset (ESC]R) or terminal reset (e.g. ESC c) removes those upper-layer changes. This seems like a more consistent strategy, in that the same set of configuration settings will produce the same end result regardless of what order they were applied in. The palette-related methods in TermWin have had a total rework. palette_get and palette_reset are both gone; palette_set can now set a contiguous range of colours in one go; and the new palette_get_overrides replaces window.c's old systopalette().
2021-02-07 19:59:21 +00:00
Changes in startup order to ensure any subsystem which might attempt to schedule timers is not started until after hwnd is initialised. [originally from svn r4912]
2004-11-27 19:41:24 +00:00
/*
* Initialise the terminal. (We have to do this _after_
* creating the window, since the terminal is the first thing
* which will call schedule_timer(), which will in turn call
Nitpick, close bracket. [originally from svn r4926]
2004-11-29 16:58:02 +00:00
* timer_change_notify() which will expect hwnd to exist.)
Changes in startup order to ensure any subsystem which might attempt to schedule timers is not started until after hwnd is initialised. [originally from svn r4912]
2004-11-27 19:41:24 +00:00
*/
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
wgs->term = term_init(wgs->conf, &wgs->ucsdata, &wgs->termwin);
setup_clipboards(wgs->term, wgs->conf);
wgs->logctx = log_init(&wgs->logpolicy, wgs->conf);
term_provide_logctx(wgs->term, wgs->logctx);
term_size(wgs->term, conf_get_int(wgs->conf, CONF_height),
conf_get_int(wgs->conf, CONF_width),
conf_get_int(wgs->conf, CONF_savelines));
Changes in startup order to ensure any subsystem which might attempt to schedule timers is not started until after hwnd is initialised. [originally from svn r4912]
2004-11-27 19:41:24 +00:00
Initial checkin: beta 0.43 [originally from svn r11]
1999-01-08 13:02:13 +00:00
/*
* Correct the guesses for extra_{width,height}.
*/
{
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
RECT cr, wr;
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
GetWindowRect(wgs->term_hwnd, &wr);
GetClientRect(wgs->term_hwnd, &cr);
windows/window.c: move more variables into WinGuiSeat. In commit f9e572595bb8cb6 I claimed that I'd removed very nearly all the global and static variables from windows/window.c. It turns out that this was wildly overoptimistic - I missed quite a few of them! I'm not quite sure how I managed that; my best guess is that I used an underpowered 'nm' command that failed to find some classes of variable. Some of the remaining function-scope statics were removed completely by commit afb3dab1e97a09f just now. In this commit, I've swept up some more and turn them into fields of WinGuiSeat, where they should have been moved last September. The (hopefully complete this time) list of remaining variables, generated by running this rune in the Windows build directory: nm windows/CMakeFiles/putty.dir/window.c.obj | grep -E '^([^ ]+)? *[bBcCdDgGsS] [^\.]' consists of the following variables which are legitimately global across the whole process and not related to a particular window: - 'hinst' and 'hprev', instance handles for Windows loadable modules - 'classname' in the terminal_window_class_a() and terminal_window_class_w() functions, which allocate a window class reusably - some pointers to Windows API functions retrieved via the DECL_WINDOWS_FUNCTION / GET_WINDOWS_FUNCTION system, such as p_AdjustWindowRectExForDpi and p_FlashWindowEx - some pointers to Windows API functions set up by assigning them at startup to the right one of the ANSI or Unicode version depending on the Windows version, e.g. sw_DefWindowProc and sw_DispatchMessage - 'unicode_window', a boolean flag set at the same time as those sw_Foo function pointers - 'sesslist', storing the last-retrieved version of the saved sessions menu - 'cursor_visible' in show_mouseptr() and 'forced_visible' in update_mouse_pointer(), each of which tracks the cumulative number of times that function has shown or hidden the mouse pointer, so as to manage its effect on the global state updated by ShowCursor - 'trust_icon', loaded from the executable's resources - 'wgslisthead', the list of all active WinGuiSeats - 'wm_mousewheel', the window-message id we use for mouse wheel events and the following which are nothing to do with our code: - '_OptionsStorage' in __local_stdio_printf_options() and __local_stdio_scanf_options(), which I'd never noticed before, but apparently are internal to a standard library header.
2023-05-27 13:59:20 +00:00
wgs->offset_width = wgs->offset_height =
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
conf_get_int(wgs->conf, CONF_window_border);
windows/window.c: move more variables into WinGuiSeat. In commit f9e572595bb8cb6 I claimed that I'd removed very nearly all the global and static variables from windows/window.c. It turns out that this was wildly overoptimistic - I missed quite a few of them! I'm not quite sure how I managed that; my best guess is that I used an underpowered 'nm' command that failed to find some classes of variable. Some of the remaining function-scope statics were removed completely by commit afb3dab1e97a09f just now. In this commit, I've swept up some more and turn them into fields of WinGuiSeat, where they should have been moved last September. The (hopefully complete this time) list of remaining variables, generated by running this rune in the Windows build directory: nm windows/CMakeFiles/putty.dir/window.c.obj | grep -E '^([^ ]+)? *[bBcCdDgGsS] [^\.]' consists of the following variables which are legitimately global across the whole process and not related to a particular window: - 'hinst' and 'hprev', instance handles for Windows loadable modules - 'classname' in the terminal_window_class_a() and terminal_window_class_w() functions, which allocate a window class reusably - some pointers to Windows API functions retrieved via the DECL_WINDOWS_FUNCTION / GET_WINDOWS_FUNCTION system, such as p_AdjustWindowRectExForDpi and p_FlashWindowEx - some pointers to Windows API functions set up by assigning them at startup to the right one of the ANSI or Unicode version depending on the Windows version, e.g. sw_DefWindowProc and sw_DispatchMessage - 'unicode_window', a boolean flag set at the same time as those sw_Foo function pointers - 'sesslist', storing the last-retrieved version of the saved sessions menu - 'cursor_visible' in show_mouseptr() and 'forced_visible' in update_mouse_pointer(), each of which tracks the cumulative number of times that function has shown or hidden the mouse pointer, so as to manage its effect on the global state updated by ShowCursor - 'trust_icon', loaded from the executable's resources - 'wgslisthead', the list of all active WinGuiSeats - 'wm_mousewheel', the window-message id we use for mouse wheel events and the following which are nothing to do with our code: - '_OptionsStorage' in __local_stdio_printf_options() and __local_stdio_scanf_options(), which I'd never noticed before, but apparently are internal to a standard library header.
2023-05-27 13:59:20 +00:00
wgs->extra_width =
wr.right - wr.left - cr.right + cr.left + wgs->offset_width*2;
wgs->extra_height =
wr.bottom - wr.top - cr.bottom + cr.top +wgs->offset_height*2;
Initial checkin: beta 0.43 [originally from svn r11]
1999-01-08 13:02:13 +00:00
}
/*
Ensure the whole window is visible at startup During startup, calculate the top/left position of the window so that the whole window is visible. Without this change, sometimes the window is clipped vertically and you can't see the bottom. Thanks to Bruno Kraychete da Costa for the original version of this patch; I've tweaked it slightly, but the basic strategy of adjusting the output of GetWindowRect against the monitor's working area is all his.
2024-10-16 07:00:32 +00:00
* Compute what size we _really_ want the window to be.
Initial checkin: beta 0.43 [originally from svn r11]
1999-01-08 13:02:13 +00:00
*/
windows/window.c: move more variables into WinGuiSeat. In commit f9e572595bb8cb6 I claimed that I'd removed very nearly all the global and static variables from windows/window.c. It turns out that this was wildly overoptimistic - I missed quite a few of them! I'm not quite sure how I managed that; my best guess is that I used an underpowered 'nm' command that failed to find some classes of variable. Some of the remaining function-scope statics were removed completely by commit afb3dab1e97a09f just now. In this commit, I've swept up some more and turn them into fields of WinGuiSeat, where they should have been moved last September. The (hopefully complete this time) list of remaining variables, generated by running this rune in the Windows build directory: nm windows/CMakeFiles/putty.dir/window.c.obj | grep -E '^([^ ]+)? *[bBcCdDgGsS] [^\.]' consists of the following variables which are legitimately global across the whole process and not related to a particular window: - 'hinst' and 'hprev', instance handles for Windows loadable modules - 'classname' in the terminal_window_class_a() and terminal_window_class_w() functions, which allocate a window class reusably - some pointers to Windows API functions retrieved via the DECL_WINDOWS_FUNCTION / GET_WINDOWS_FUNCTION system, such as p_AdjustWindowRectExForDpi and p_FlashWindowEx - some pointers to Windows API functions set up by assigning them at startup to the right one of the ANSI or Unicode version depending on the Windows version, e.g. sw_DefWindowProc and sw_DispatchMessage - 'unicode_window', a boolean flag set at the same time as those sw_Foo function pointers - 'sesslist', storing the last-retrieved version of the saved sessions menu - 'cursor_visible' in show_mouseptr() and 'forced_visible' in update_mouse_pointer(), each of which tracks the cumulative number of times that function has shown or hidden the mouse pointer, so as to manage its effect on the global state updated by ShowCursor - 'trust_icon', loaded from the executable's resources - 'wgslisthead', the list of all active WinGuiSeats - 'wm_mousewheel', the window-message id we use for mouse wheel events and the following which are nothing to do with our code: - '_OptionsStorage' in __local_stdio_printf_options() and __local_stdio_scanf_options(), which I'd never noticed before, but apparently are internal to a standard library header.
2023-05-27 13:59:20 +00:00
guess_width = wgs->extra_width + wgs->font_width * wgs->term->cols;
guess_height = wgs->extra_height + wgs->font_height * wgs->term->rows;
Ensure the whole window is visible at startup During startup, calculate the top/left position of the window so that the whole window is visible. Without this change, sometimes the window is clipped vertically and you can't see the bottom. Thanks to Bruno Kraychete da Costa for the original version of this patch; I've tweaked it slightly, but the basic strategy of adjusting the output of GetWindowRect against the monitor's working area is all his.
2024-10-16 07:00:32 +00:00
/*
* Resize the window to that size, also repositioning it if it's extended
* off the edge of a monitor.
*/
{
/* Find the previous coordinates of the window */
RECT winr;
GetWindowRect(wgs->term_hwnd, &winr);
int x = winr.left;
int y = winr.top;
/* Adjust them if necessary */
RECT war;
if (get_workingarea_rect(wgs, &war)) {
/*
* Try to ensure the window is entirely within the monitor's
* working area, by adjusting its position if not.
*
* We first move it left, if it overlaps off the right side. Then
* we move it right if it overlaps off the left side. This means
* that if it's wider than the working area (so that some overlap
* is unavoidable), we prefer to get its left edge in bounds than
* its right edge. Similarly, we do the y checks in the same
* order, privileging the top edge over the bottom.
*/
if (x + guess_width > war.right)
x = war.right - guess_width;
if (x < war.left)
x = war.left;
if (y + guess_height > war.bottom)
y = war.bottom - guess_height;
if (y < war.top)
y = war.top;
}
/* And set the window to the final size and position we've chosen */
SetWindowPos(wgs->term_hwnd, NULL, x, y, guess_width, guess_height,
SWP_NOREDRAW | SWP_NOZORDER);
}
Initial checkin: beta 0.43 [originally from svn r11]
1999-01-08 13:02:13 +00:00
Try to improve the caret usage [originally from svn r651]
2000-09-29 10:32:07 +00:00
/*
* Set up a caret bitmap, with no content.
*/
{
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
char *bits;
windows/window.c: move more variables into WinGuiSeat. In commit f9e572595bb8cb6 I claimed that I'd removed very nearly all the global and static variables from windows/window.c. It turns out that this was wildly overoptimistic - I missed quite a few of them! I'm not quite sure how I managed that; my best guess is that I used an underpowered 'nm' command that failed to find some classes of variable. Some of the remaining function-scope statics were removed completely by commit afb3dab1e97a09f just now. In this commit, I've swept up some more and turn them into fields of WinGuiSeat, where they should have been moved last September. The (hopefully complete this time) list of remaining variables, generated by running this rune in the Windows build directory: nm windows/CMakeFiles/putty.dir/window.c.obj | grep -E '^([^ ]+)? *[bBcCdDgGsS] [^\.]' consists of the following variables which are legitimately global across the whole process and not related to a particular window: - 'hinst' and 'hprev', instance handles for Windows loadable modules - 'classname' in the terminal_window_class_a() and terminal_window_class_w() functions, which allocate a window class reusably - some pointers to Windows API functions retrieved via the DECL_WINDOWS_FUNCTION / GET_WINDOWS_FUNCTION system, such as p_AdjustWindowRectExForDpi and p_FlashWindowEx - some pointers to Windows API functions set up by assigning them at startup to the right one of the ANSI or Unicode version depending on the Windows version, e.g. sw_DefWindowProc and sw_DispatchMessage - 'unicode_window', a boolean flag set at the same time as those sw_Foo function pointers - 'sesslist', storing the last-retrieved version of the saved sessions menu - 'cursor_visible' in show_mouseptr() and 'forced_visible' in update_mouse_pointer(), each of which tracks the cumulative number of times that function has shown or hidden the mouse pointer, so as to manage its effect on the global state updated by ShowCursor - 'trust_icon', loaded from the executable's resources - 'wgslisthead', the list of all active WinGuiSeats - 'wm_mousewheel', the window-message id we use for mouse wheel events and the following which are nothing to do with our code: - '_OptionsStorage' in __local_stdio_printf_options() and __local_stdio_scanf_options(), which I'd never noticed before, but apparently are internal to a standard library header.
2023-05-27 13:59:20 +00:00
int size = (wgs->font_width + 15) / 16 * 2 * wgs->font_height;
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
bits = snewn(size, char);
memset(bits, 0, size);
windows/window.c: move more variables into WinGuiSeat. In commit f9e572595bb8cb6 I claimed that I'd removed very nearly all the global and static variables from windows/window.c. It turns out that this was wildly overoptimistic - I missed quite a few of them! I'm not quite sure how I managed that; my best guess is that I used an underpowered 'nm' command that failed to find some classes of variable. Some of the remaining function-scope statics were removed completely by commit afb3dab1e97a09f just now. In this commit, I've swept up some more and turn them into fields of WinGuiSeat, where they should have been moved last September. The (hopefully complete this time) list of remaining variables, generated by running this rune in the Windows build directory: nm windows/CMakeFiles/putty.dir/window.c.obj | grep -E '^([^ ]+)? *[bBcCdDgGsS] [^\.]' consists of the following variables which are legitimately global across the whole process and not related to a particular window: - 'hinst' and 'hprev', instance handles for Windows loadable modules - 'classname' in the terminal_window_class_a() and terminal_window_class_w() functions, which allocate a window class reusably - some pointers to Windows API functions retrieved via the DECL_WINDOWS_FUNCTION / GET_WINDOWS_FUNCTION system, such as p_AdjustWindowRectExForDpi and p_FlashWindowEx - some pointers to Windows API functions set up by assigning them at startup to the right one of the ANSI or Unicode version depending on the Windows version, e.g. sw_DefWindowProc and sw_DispatchMessage - 'unicode_window', a boolean flag set at the same time as those sw_Foo function pointers - 'sesslist', storing the last-retrieved version of the saved sessions menu - 'cursor_visible' in show_mouseptr() and 'forced_visible' in update_mouse_pointer(), each of which tracks the cumulative number of times that function has shown or hidden the mouse pointer, so as to manage its effect on the global state updated by ShowCursor - 'trust_icon', loaded from the executable's resources - 'wgslisthead', the list of all active WinGuiSeats - 'wm_mousewheel', the window-message id we use for mouse wheel events and the following which are nothing to do with our code: - '_OptionsStorage' in __local_stdio_printf_options() and __local_stdio_scanf_options(), which I'd never noticed before, but apparently are internal to a standard library header.
2023-05-27 13:59:20 +00:00
wgs->caretbm = CreateBitmap(wgs->font_width, wgs->font_height,
1, 1, bits);
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
sfree(bits);
Try to improve the caret usage [originally from svn r651]
2000-09-29 10:32:07 +00:00
}
windows/window.c: move more variables into WinGuiSeat. In commit f9e572595bb8cb6 I claimed that I'd removed very nearly all the global and static variables from windows/window.c. It turns out that this was wildly overoptimistic - I missed quite a few of them! I'm not quite sure how I managed that; my best guess is that I used an underpowered 'nm' command that failed to find some classes of variable. Some of the remaining function-scope statics were removed completely by commit afb3dab1e97a09f just now. In this commit, I've swept up some more and turn them into fields of WinGuiSeat, where they should have been moved last September. The (hopefully complete this time) list of remaining variables, generated by running this rune in the Windows build directory: nm windows/CMakeFiles/putty.dir/window.c.obj | grep -E '^([^ ]+)? *[bBcCdDgGsS] [^\.]' consists of the following variables which are legitimately global across the whole process and not related to a particular window: - 'hinst' and 'hprev', instance handles for Windows loadable modules - 'classname' in the terminal_window_class_a() and terminal_window_class_w() functions, which allocate a window class reusably - some pointers to Windows API functions retrieved via the DECL_WINDOWS_FUNCTION / GET_WINDOWS_FUNCTION system, such as p_AdjustWindowRectExForDpi and p_FlashWindowEx - some pointers to Windows API functions set up by assigning them at startup to the right one of the ANSI or Unicode version depending on the Windows version, e.g. sw_DefWindowProc and sw_DispatchMessage - 'unicode_window', a boolean flag set at the same time as those sw_Foo function pointers - 'sesslist', storing the last-retrieved version of the saved sessions menu - 'cursor_visible' in show_mouseptr() and 'forced_visible' in update_mouse_pointer(), each of which tracks the cumulative number of times that function has shown or hidden the mouse pointer, so as to manage its effect on the global state updated by ShowCursor - 'trust_icon', loaded from the executable's resources - 'wgslisthead', the list of all active WinGuiSeats - 'wm_mousewheel', the window-message id we use for mouse wheel events and the following which are nothing to do with our code: - '_OptionsStorage' in __local_stdio_printf_options() and __local_stdio_scanf_options(), which I'd never noticed before, but apparently are internal to a standard library header.
2023-05-27 13:59:20 +00:00
CreateCaret(wgs->term_hwnd, wgs->caretbm,
wgs->font_width, wgs->font_height);
Try to improve the caret usage [originally from svn r651]
2000-09-29 10:32:07 +00:00
Initial checkin: beta 0.43 [originally from svn r11]
1999-01-08 13:02:13 +00:00
/*
* Initialise the scroll bar.
*/
{
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
SCROLLINFO si;
si.cbSize = sizeof(si);
si.fMask = SIF_ALL | SIF_DISABLENOSCROLL;
si.nMin = 0;
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
si.nMax = wgs->term->rows - 1;
si.nPage = wgs->term->rows;
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
si.nPos = 0;
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
SetScrollInfo(wgs->term_hwnd, SB_VERT, &si, false);
Initial checkin: beta 0.43 [originally from svn r11]
1999-01-08 13:02:13 +00:00
}
/*
* Prepare the mouse handler.
*/
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
wgs->lastact = MA_NOTHING;
wgs->lastbtn = MBT_NOTHING;
wgs->dbltime = GetDoubleClickTime();
Initial checkin: beta 0.43 [originally from svn r11]
1999-01-08 13:02:13 +00:00
/*
* Set up the session-control options on the system menu.
*/
{
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
HMENU m;
int j;
char *str;
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
wgs->popup_menus[SYSMENU].menu = GetSystemMenu(wgs->term_hwnd, false);
wgs->popup_menus[CTXMENU].menu = CreatePopupMenu();
Windows: add 'Copy' and 'Paste' to the window's system menu. These actions were already available in the Ctrl + right-click context menu (or just right-click, if you shifted the mouse-button actions into Windows mode). But a user might not know about Ctrl + right-click, and only know to look in the system menu. So it makes them easier to find if they're in that menu too. Also, I don't really see any reason why the two menus _should_ be different.
2024-08-17 08:41:51 +00:00
for (j = 0; j < lenof(wgs->popup_menus); j++) {
m = wgs->popup_menus[j].menu;
AppendMenu(m, MF_ENABLED, IDM_COPY, "&Copy");
AppendMenu(m, MF_ENABLED, IDM_PASTE, "&Paste");
}
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
wgs->savedsess_menu = CreateMenu();
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
get_sesslist(&sesslist, true);
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
update_savedsess_menu(wgs);
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
for (j = 0; j < lenof(wgs->popup_menus); j++) {
m = wgs->popup_menus[j].menu;
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
AppendMenu(m, MF_SEPARATOR, 0, 0);
AppendMenu(m, MF_ENABLED, IDM_SHOWLOG, "&Event Log");
AppendMenu(m, MF_SEPARATOR, 0, 0);
AppendMenu(m, MF_ENABLED, IDM_NEWSESS, "Ne&w Session...");
AppendMenu(m, MF_ENABLED, IDM_DUPSESS, "&Duplicate Session");
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
AppendMenu(m, MF_POPUP | MF_ENABLED, (UINT_PTR)wgs->savedsess_menu,
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
"Sa&ved Sessions");
AppendMenu(m, MF_ENABLED, IDM_RECONF, "Chan&ge Settings...");
AppendMenu(m, MF_SEPARATOR, 0, 0);
AppendMenu(m, MF_ENABLED, IDM_COPYALL, "C&opy All to Clipboard");
AppendMenu(m, MF_ENABLED, IDM_CLRSB, "C&lear Scrollback");
AppendMenu(m, MF_ENABLED, IDM_RESET, "Rese&t Terminal");
AppendMenu(m, MF_SEPARATOR, 0, 0);
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
AppendMenu(m, (conf_get_int(wgs->conf, CONF_resize_action)
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
== RESIZE_DISABLED) ? MF_GRAYED : MF_ENABLED,
IDM_FULLSCREEN, "&Full Screen");
AppendMenu(m, MF_SEPARATOR, 0, 0);
if (has_help())
AppendMenu(m, MF_ENABLED, IDM_HELP, "&Help");
str = dupprintf("&About %s", appname);
AppendMenu(m, MF_ENABLED, IDM_ABOUT, str);
sfree(str);
}
Initial checkin: beta 0.43 [originally from svn r11]
1999-01-08 13:02:13 +00:00
}
Move the restricted_acl flag into winsecur.c. It's silly to set it at each call site of restrict_process_acl() if that function returns success! More sensible to have it be a flag in the same source file as restrict_process_acl(), set as an automatic _side effect_ of success. I've renamed the variable itself, and the global name 'restricted_acl' is now a query function that asks winsecur.c whether that operation has been (successfully) performed.
2020-02-02 10:00:42 +00:00
if (restricted_acl()) {
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
lp_eventlog(&wgs->logpolicy, "Running with restricted process ACL");
Log when -restrict-acl is in use. Partly to reassure the user that they got what they asked for, and partly so that's a clue for us in the logs when we get bug reports. This involved repurposing platform_psftp_post_option_setup() (no longer used since e22120fe) as platform_psftp_pre_conn_setup(), and moving it to after logging is set up.
2017-02-11 00:44:00 +00:00
}
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
winselgui_set_hwnd(wgs->term_hwnd);
start_backend(wgs);
Turned the old `Telnet Command' System-submenu into a more general `Special Command' menu, in which any backend can place its own list of magical things the user might want to ask the backend to do. In particular I've implemented the recently proposed "break" extension in SSH2 using this mechanism. NB this checkin slightly breaks the Mac build, since it needs to provide at least a stub form of update_specials_menu(). [originally from svn r3054]
2003-04-04 20:21:05 +00:00
Set up kbd_codepage at the start of the program, as well as when the input locale changes. With any luck this should sort out the Polish Unicode problems. [originally from svn r1427]
2001-11-29 21:30:59 +00:00
/*
* Set up the initial input locale.
*/
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
set_input_locale(wgs, GetKeyboardLayout(0));
Set up kbd_codepage at the start of the program, as well as when the input locale changes. With any luck this should sort out the Polish Unicode problems. [originally from svn r1427]
2001-11-29 21:30:59 +00:00
Improved session logging courtesy of Roman Pompejus [originally from svn r846]
2001-01-07 18:24:59 +00:00
/*
Retired the #ifdef DUMP_PACKETS stuff in ssh.c because I'm utterly sick of recompiling to enable packet dumps. SSH packet dumping is now provided as a logging option, and dumps to putty.log like all the other logging options. While I'm at it I cleaned up the format so that packet types are translated into strings for easy browsing. POSSIBLE SIDE EFFECT: in the course of this work I had to re-enable the SSH1 packet length checks which it turns out hadn't actually been active for some time, so it's possible things might break as a result. If need be I can always disable those checks for the 0.52 release and think about it more carefully later. [originally from svn r1493]
2001-12-14 14:57:50 +00:00
* Finally show the window!
Improved session logging courtesy of Roman Pompejus [originally from svn r846]
2001-01-07 18:24:59 +00:00
*/
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
ShowWindow(wgs->term_hwnd, show);
SetForegroundWindow(wgs->term_hwnd);
Improved session logging courtesy of Roman Pompejus [originally from svn r846]
2001-01-07 18:24:59 +00:00
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
term_set_focus(wgs->term, GetForegroundWindow() == wgs->term_hwnd);
UpdateWindow(wgs->term_hwnd);
Initial checkin: beta 0.43 [originally from svn r11]
1999-01-08 13:02:13 +00:00
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
gui_terminal_ready(wgs->term_hwnd, &wgs->seat, wgs->backend);
Windows tools: assorted '-demo' options. Using a new screenshot-taking module I just added in windows/utils, these new options allow me to start up one of the tools with demonstration window contents and automatically save a .BMP screenshot to disk. This will allow me to keep essentially the same set of demo images and update them easily to keep pace with the current appearance of the real tools as PuTTY - and Windows itself - both evolve.
2022-04-02 15:18:08 +00:00
New piece of Windows infrastructure: winhandl.c takes Plink's thread-based approach to stdin and stdout, wraps it in a halfway sensible API, and makes it a globally available service across all network tools. There is no direct functionality enhancement from this checkin: winplink.c now talks to the new API instead of doing it all internally, but does nothing different as a result. However, this should lay the groundwork for several diverse pieces of work in future: pipe-based ProxyCommand on Windows, a serial port back end, and (hopefully) a pipe-based means of communicating with Pageant, which should have sensible blocking behaviour and hence permit asynchronous agent requests and decrypt-on-demand. [originally from svn r6797]
2006-08-25 22:10:16 +00:00
while (1) {
Reorganise Windows HANDLE management. Before commit 6e69223dc262755, Pageant would stop working after a certain number of PuTTYs were active at the same time. (At most about 60, but maybe fewer - see below.) This was because of two separate bugs. The easy one, fixed in 6e69223dc262755 itself, was that PuTTY left each named-pipe connection to Pageant open for the rest of its lifetime. So the real problem was that Pageant had too many active connections at once. (And since a given PuTTY might make multiple connections during userauth - one to list keys, and maybe another to actually make a signature - that was why the number of _PuTTYs_ might vary.) It was clearly a bug that PuTTY was leaving connections to Pageant needlessly open. But it was _also_ a bug that Pageant couldn't handle more than about 60 at once. In this commit, I fix that secondary bug. The cause of the bug is that the WaitForMultipleObjects function family in the Windows API have a limit on the number of HANDLE objects they can select between. The limit is MAXIMUM_WAIT_OBJECTS, defined to be 64. And handle-io.c was using a separate event object for each I/O subthread to communicate back to the main thread, so as soon as all those event objects (plus a handful of other HANDLEs) added up to more than 64, we'd start passing an overlarge handle array to WaitForMultipleObjects, and it would start not doing what we wanted. To fix this, I've reorganised handle-io.c so that all its subthreads share just _one_ event object to signal readiness back to the main thread. There's now a linked list of 'struct handle' objects that are ready to be processed, protected by a CRITICAL_SECTION. Each subthread signals readiness by adding itself to the linked list, and setting the event object to indicate that the list is now non-empty. When the main thread receives the event, it iterates over the whole list processing all the ready handles. (Each 'struct handle' still has a separate event object for the main thread to use to communicate _to_ the subthread. That's OK, because no thread is ever waiting on all those events at once: each subthread only waits on its own.) The previous HT_FOREIGN system didn't really fit into this framework. So I've moved it out into its own system. There's now a handle-wait.c which deals with the relatively simple job of managing a list of handles that need to be waited for, each with a callback function; that's what communicates a list of HANDLEs to event loops, and receives the notification when the event loop notices that one of them has done something. And handle-io.c is now just one client of handle-wait.c, providing a single HANDLE to the event loop, and dealing internally with everything that needs to be done when that handle fires. The new top-level handle-wait.c system *still* can't deal with more than MAXIMUM_WAIT_OBJECTS. At the moment, I'm reasonably convinced it doesn't need to: the only kind of HANDLE that any of our tools could previously have needed to wait on more than one of was the one in handle-io.c that I've just removed. But I've left some assertions and a TODO comment in there just in case we need to change that in future.
2021-05-24 12:06:10 +00:00
int n;
Only run one toplevel callback per event loop iteration. This change attempts to reinstate as a universal property something which was sporadically true of the ad-hockery that came before toplevel callbacks: that if there's a _very long_ queue of things to be done through the callback mechanism, the doing of them will be interleaved with re-checks of other event sources, which might (e.g.) cause a flag to be set which makes the next callback decide not to do anything after all. [originally from svn r10040]
2013-09-15 14:05:31 +00:00
DWORD timeout;
Replace GetQueueStatus with PeekMessage(PM_NOREMOVE). A couple of users report that my recent reworking of the Windows top-level message loop has led to messages occasionally being lost, and MsgWaitForMultipleObjects blocking when it ought to have been called with a zero timeout. I haven't been able to reproduce this myself, but according to one reporter, PeekMessage(PM_NOREMOVE) is effective at checking for a non-empty message queue in a way that GetQueueStatus is not. Switch to using that instead. Thanks to Eric Flumerfelt for debugging and testing help. [originally from svn r10057]
2013-11-11 23:01:47 +00:00
if (toplevel_callback_pending() ||
PeekMessage(&msg, NULL, 0, 0, PM_NOREMOVE)) {
Avoid leaving unread Windows messages in the queue. Jochen Erwied points out that once you've used PeekMessage to remove _one_ message from the message queue, MsgWaitForMultipleObjects will consider the whole queue to have been 'read', or at least looked at and deemed uninteresting, and so it will block until a further message comes in. Hence, my change in r10040 which stops us from looping on PeekMessage until the queue is empty has the effect of causing the rest of the message queue not to be acted on until a new message comes in to unblock it. Fix by checking if the queue is nonempty in advance of calling MsgWaitForMultipleObjects, and if so, giving it a zero timeout just as we do if there's a pending toplevel callback. [originally from svn r10052] [r10040 == 5c4ce2fadf23bff6f38155df44b5d6040cf80d26]
2013-10-25 17:44:02 +00:00
/*
* If we have anything we'd like to do immediately, set
* the timeout for MsgWaitForMultipleObjects to zero so
* that we'll only do a quick check of our handles and
* then get on with whatever that was.
*
* One such option is a pending toplevel callback. The
* other is a non-empty Windows message queue, which you'd
* think we could leave to MsgWaitForMultipleObjects to
* check for us along with all the handles, but in fact we
* can't because once PeekMessage in one iteration of this
* loop has removed a message from the queue, the whole
* queue is considered uninteresting by the next
* invocation of MWFMO. So we check ourselves whether the
* message queue is non-empty, and if so, set this timeout
* to zero to ensure MWFMO doesn't block.
*/
Only run one toplevel callback per event loop iteration. This change attempts to reinstate as a universal property something which was sporadically true of the ad-hockery that came before toplevel callbacks: that if there's a _very long_ queue of things to be done through the callback mechanism, the doing of them will be interleaved with re-checks of other event sources, which might (e.g.) cause a flag to be set which makes the next callback decide not to do anything after all. [originally from svn r10040]
2013-09-15 14:05:31 +00:00
timeout = 0;
} else {
timeout = INFINITE;
/* The messages seem unreliable; especially if we're being tricky */
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
term_set_focus(wgs->term, GetForegroundWindow() == wgs->term_hwnd);
Only run one toplevel callback per event loop iteration. This change attempts to reinstate as a universal property something which was sporadically true of the ad-hockery that came before toplevel callbacks: that if there's a _very long_ queue of things to be done through the callback mechanism, the doing of them will be interleaved with re-checks of other event sources, which might (e.g.) cause a flag to be set which makes the next callback decide not to do anything after all. [originally from svn r10040]
2013-09-15 14:05:31 +00:00
}
New piece of Windows infrastructure: winhandl.c takes Plink's thread-based approach to stdin and stdout, wraps it in a halfway sensible API, and makes it a globally available service across all network tools. There is no direct functionality enhancement from this checkin: winplink.c now talks to the new API instead of doing it all internally, but does nothing different as a result. However, this should lay the groundwork for several diverse pieces of work in future: pipe-based ProxyCommand on Windows, a serial port back end, and (hopefully) a pipe-based means of communicating with Pageant, which should have sensible blocking behaviour and hence permit asynchronous agent requests and decrypt-on-demand. [originally from svn r6797]
2006-08-25 22:10:16 +00:00
Reorganise Windows HANDLE management. Before commit 6e69223dc262755, Pageant would stop working after a certain number of PuTTYs were active at the same time. (At most about 60, but maybe fewer - see below.) This was because of two separate bugs. The easy one, fixed in 6e69223dc262755 itself, was that PuTTY left each named-pipe connection to Pageant open for the rest of its lifetime. So the real problem was that Pageant had too many active connections at once. (And since a given PuTTY might make multiple connections during userauth - one to list keys, and maybe another to actually make a signature - that was why the number of _PuTTYs_ might vary.) It was clearly a bug that PuTTY was leaving connections to Pageant needlessly open. But it was _also_ a bug that Pageant couldn't handle more than about 60 at once. In this commit, I fix that secondary bug. The cause of the bug is that the WaitForMultipleObjects function family in the Windows API have a limit on the number of HANDLE objects they can select between. The limit is MAXIMUM_WAIT_OBJECTS, defined to be 64. And handle-io.c was using a separate event object for each I/O subthread to communicate back to the main thread, so as soon as all those event objects (plus a handful of other HANDLEs) added up to more than 64, we'd start passing an overlarge handle array to WaitForMultipleObjects, and it would start not doing what we wanted. To fix this, I've reorganised handle-io.c so that all its subthreads share just _one_ event object to signal readiness back to the main thread. There's now a linked list of 'struct handle' objects that are ready to be processed, protected by a CRITICAL_SECTION. Each subthread signals readiness by adding itself to the linked list, and setting the event object to indicate that the list is now non-empty. When the main thread receives the event, it iterates over the whole list processing all the ready handles. (Each 'struct handle' still has a separate event object for the main thread to use to communicate _to_ the subthread. That's OK, because no thread is ever waiting on all those events at once: each subthread only waits on its own.) The previous HT_FOREIGN system didn't really fit into this framework. So I've moved it out into its own system. There's now a handle-wait.c which deals with the relatively simple job of managing a list of handles that need to be waited for, each with a callback function; that's what communicates a list of HANDLEs to event loops, and receives the notification when the event loop notices that one of them has done something. And handle-io.c is now just one client of handle-wait.c, providing a single HANDLE to the event loop, and dealing internally with everything that needs to be done when that handle fires. The new top-level handle-wait.c system *still* can't deal with more than MAXIMUM_WAIT_OBJECTS. At the moment, I'm reasonably convinced it doesn't need to: the only kind of HANDLE that any of our tools could previously have needed to wait on more than one of was the one in handle-io.c that I've just removed. But I've left some assertions and a TODO comment in there just in case we need to change that in future.
2021-05-24 12:06:10 +00:00
HandleWaitList *hwl = get_handle_wait_list();
New piece of Windows infrastructure: winhandl.c takes Plink's thread-based approach to stdin and stdout, wraps it in a halfway sensible API, and makes it a globally available service across all network tools. There is no direct functionality enhancement from this checkin: winplink.c now talks to the new API instead of doing it all internally, but does nothing different as a result. However, this should lay the groundwork for several diverse pieces of work in future: pipe-based ProxyCommand on Windows, a serial port back end, and (hopefully) a pipe-based means of communicating with Pageant, which should have sensible blocking behaviour and hence permit asynchronous agent requests and decrypt-on-demand. [originally from svn r6797]
2006-08-25 22:10:16 +00:00
Reorganise Windows HANDLE management. Before commit 6e69223dc262755, Pageant would stop working after a certain number of PuTTYs were active at the same time. (At most about 60, but maybe fewer - see below.) This was because of two separate bugs. The easy one, fixed in 6e69223dc262755 itself, was that PuTTY left each named-pipe connection to Pageant open for the rest of its lifetime. So the real problem was that Pageant had too many active connections at once. (And since a given PuTTY might make multiple connections during userauth - one to list keys, and maybe another to actually make a signature - that was why the number of _PuTTYs_ might vary.) It was clearly a bug that PuTTY was leaving connections to Pageant needlessly open. But it was _also_ a bug that Pageant couldn't handle more than about 60 at once. In this commit, I fix that secondary bug. The cause of the bug is that the WaitForMultipleObjects function family in the Windows API have a limit on the number of HANDLE objects they can select between. The limit is MAXIMUM_WAIT_OBJECTS, defined to be 64. And handle-io.c was using a separate event object for each I/O subthread to communicate back to the main thread, so as soon as all those event objects (plus a handful of other HANDLEs) added up to more than 64, we'd start passing an overlarge handle array to WaitForMultipleObjects, and it would start not doing what we wanted. To fix this, I've reorganised handle-io.c so that all its subthreads share just _one_ event object to signal readiness back to the main thread. There's now a linked list of 'struct handle' objects that are ready to be processed, protected by a CRITICAL_SECTION. Each subthread signals readiness by adding itself to the linked list, and setting the event object to indicate that the list is now non-empty. When the main thread receives the event, it iterates over the whole list processing all the ready handles. (Each 'struct handle' still has a separate event object for the main thread to use to communicate _to_ the subthread. That's OK, because no thread is ever waiting on all those events at once: each subthread only waits on its own.) The previous HT_FOREIGN system didn't really fit into this framework. So I've moved it out into its own system. There's now a handle-wait.c which deals with the relatively simple job of managing a list of handles that need to be waited for, each with a callback function; that's what communicates a list of HANDLEs to event loops, and receives the notification when the event loop notices that one of them has done something. And handle-io.c is now just one client of handle-wait.c, providing a single HANDLE to the event loop, and dealing internally with everything that needs to be done when that handle fires. The new top-level handle-wait.c system *still* can't deal with more than MAXIMUM_WAIT_OBJECTS. At the moment, I'm reasonably convinced it doesn't need to: the only kind of HANDLE that any of our tools could previously have needed to wait on more than one of was the one in handle-io.c that I've just removed. But I've left some assertions and a TODO comment in there just in case we need to change that in future.
2021-05-24 12:06:10 +00:00
n = MsgWaitForMultipleObjects(hwl->nhandles, hwl->handles, false,
Only run one toplevel callback per event loop iteration. This change attempts to reinstate as a universal property something which was sporadically true of the ad-hockery that came before toplevel callbacks: that if there's a _very long_ queue of things to be done through the callback mechanism, the doing of them will be interleaved with re-checks of other event sources, which might (e.g.) cause a flag to be set which makes the next callback decide not to do anything after all. [originally from svn r10040]
2013-09-15 14:05:31 +00:00
timeout, QS_ALLINPUT);
New piece of Windows infrastructure: winhandl.c takes Plink's thread-based approach to stdin and stdout, wraps it in a halfway sensible API, and makes it a globally available service across all network tools. There is no direct functionality enhancement from this checkin: winplink.c now talks to the new API instead of doing it all internally, but does nothing different as a result. However, this should lay the groundwork for several diverse pieces of work in future: pipe-based ProxyCommand on Windows, a serial port back end, and (hopefully) a pipe-based means of communicating with Pageant, which should have sensible blocking behaviour and hence permit asynchronous agent requests and decrypt-on-demand. [originally from svn r6797]
2006-08-25 22:10:16 +00:00
Reorganise Windows HANDLE management. Before commit 6e69223dc262755, Pageant would stop working after a certain number of PuTTYs were active at the same time. (At most about 60, but maybe fewer - see below.) This was because of two separate bugs. The easy one, fixed in 6e69223dc262755 itself, was that PuTTY left each named-pipe connection to Pageant open for the rest of its lifetime. So the real problem was that Pageant had too many active connections at once. (And since a given PuTTY might make multiple connections during userauth - one to list keys, and maybe another to actually make a signature - that was why the number of _PuTTYs_ might vary.) It was clearly a bug that PuTTY was leaving connections to Pageant needlessly open. But it was _also_ a bug that Pageant couldn't handle more than about 60 at once. In this commit, I fix that secondary bug. The cause of the bug is that the WaitForMultipleObjects function family in the Windows API have a limit on the number of HANDLE objects they can select between. The limit is MAXIMUM_WAIT_OBJECTS, defined to be 64. And handle-io.c was using a separate event object for each I/O subthread to communicate back to the main thread, so as soon as all those event objects (plus a handful of other HANDLEs) added up to more than 64, we'd start passing an overlarge handle array to WaitForMultipleObjects, and it would start not doing what we wanted. To fix this, I've reorganised handle-io.c so that all its subthreads share just _one_ event object to signal readiness back to the main thread. There's now a linked list of 'struct handle' objects that are ready to be processed, protected by a CRITICAL_SECTION. Each subthread signals readiness by adding itself to the linked list, and setting the event object to indicate that the list is now non-empty. When the main thread receives the event, it iterates over the whole list processing all the ready handles. (Each 'struct handle' still has a separate event object for the main thread to use to communicate _to_ the subthread. That's OK, because no thread is ever waiting on all those events at once: each subthread only waits on its own.) The previous HT_FOREIGN system didn't really fit into this framework. So I've moved it out into its own system. There's now a handle-wait.c which deals with the relatively simple job of managing a list of handles that need to be waited for, each with a callback function; that's what communicates a list of HANDLEs to event loops, and receives the notification when the event loop notices that one of them has done something. And handle-io.c is now just one client of handle-wait.c, providing a single HANDLE to the event loop, and dealing internally with everything that needs to be done when that handle fires. The new top-level handle-wait.c system *still* can't deal with more than MAXIMUM_WAIT_OBJECTS. At the moment, I'm reasonably convinced it doesn't need to: the only kind of HANDLE that any of our tools could previously have needed to wait on more than one of was the one in handle-io.c that I've just removed. But I've left some assertions and a TODO comment in there just in case we need to change that in future.
2021-05-24 12:06:10 +00:00
if ((unsigned)(n - WAIT_OBJECT_0) < (unsigned)hwl->nhandles)
handle_wait_activate(hwl, n - WAIT_OBJECT_0);
handle_wait_list_free(hwl);
New piece of Windows infrastructure: winhandl.c takes Plink's thread-based approach to stdin and stdout, wraps it in a halfway sensible API, and makes it a globally available service across all network tools. There is no direct functionality enhancement from this checkin: winplink.c now talks to the new API instead of doing it all internally, but does nothing different as a result. However, this should lay the groundwork for several diverse pieces of work in future: pipe-based ProxyCommand on Windows, a serial port back end, and (hopefully) a pipe-based means of communicating with Pageant, which should have sensible blocking behaviour and hence permit asynchronous agent requests and decrypt-on-demand. [originally from svn r6797]
2006-08-25 22:10:16 +00:00
Windows: runtime switch between Unicode and ANSI windows. Turns out that PuTTY hasn't run successfully on legacy Windows since 0.66, in spite of an ongoing intention to keep it working. Among the reasons for this is that CreateWindowExW simply fails with ERROR_CALL_NOT_IMPLEMENTED: apparently Win95 and its ilk just didn't have fully-Unicode windows as an option. Fixed by resurrecting the previous code from the git history (in particular, code removed by commit 67e5ceb9a8e6bc2 was useful), and including it as a runtime alternative. One subtlety was that I found I had to name the A and W window classes differently (by appending ".ansi" to the A one): apparently they occupy the same namespace even though the names are in different character sets, so if you somehow manage to register both classes, they'll collide with each other without that tweak.
2022-03-12 06:43:59 +00:00
while (sw_PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) {
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
if (msg.message == WM_QUIT)
goto finished; /* two-level break */
New piece of Windows infrastructure: winhandl.c takes Plink's thread-based approach to stdin and stdout, wraps it in a halfway sensible API, and makes it a globally available service across all network tools. There is no direct functionality enhancement from this checkin: winplink.c now talks to the new API instead of doing it all internally, but does nothing different as a result. However, this should lay the groundwork for several diverse pieces of work in future: pipe-based ProxyCommand on Windows, a serial port back end, and (hopefully) a pipe-based means of communicating with Pageant, which should have sensible blocking behaviour and hence permit asynchronous agent requests and decrypt-on-demand. [originally from svn r6797]
2006-08-25 22:10:16 +00:00
Move the global 'logbox' into windlg.c. It was only used in one place outside that module, so I've provided an accessor for that one case.
2020-02-02 10:00:42 +00:00
HWND logbox = event_log_window();
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
if (!(IsWindow(logbox) && IsDialogMessage(logbox, &msg)))
Windows: runtime switch between Unicode and ANSI windows. Turns out that PuTTY hasn't run successfully on legacy Windows since 0.66, in spite of an ongoing intention to keep it working. Among the reasons for this is that CreateWindowExW simply fails with ERROR_CALL_NOT_IMPLEMENTED: apparently Win95 and its ilk just didn't have fully-Unicode windows as an option. Fixed by resurrecting the previous code from the git history (in particular, code removed by commit 67e5ceb9a8e6bc2 was useful), and including it as a runtime alternative. One subtlety was that I found I had to name the A and W window classes differently (by appending ".ansi" to the A one): apparently they occupy the same namespace even though the names are in different character sets, so if you somehow manage to register both classes, they'll collide with each other without that tweak.
2022-03-12 06:43:59 +00:00
sw_DispatchMessage(&msg);
Stop Windows PuTTY becoming unresponsive if server floods us. This was an old bug, fixed around 0.59, which apparently regressed when I rewrote the main event loop using the toplevel_callback mechanism. Investigation just now suggests that it has to do with my faulty assumption that Windows PeekMessage would deliver messages in its message queue in FIFO order (i.e. that the thing calling itself a message queue is actually a _queue_). In fact my WM_NETEVENT seems to like to jump the queue, so that once a steady stream of them starts arriving, we never do anything else in the main event loop (except deal with handles). Worked around in a simple and slightly bodgy way, namely, we don't stop looping on PeekMessage and run our toplevel callbacks until we've either run out of messages completely or else seen at least one that _isn't_ a WM_NETEVENT. That way we should reliably interleave NETEVENT processing with processing of other stuff.
2015-03-07 17:10:36 +00:00
/*
* WM_NETEVENT messages seem to jump ahead of others in
* the message queue. I'm not sure why; the docs for
* PeekMessage mention that messages are prioritised in
* some way, but I'm unclear on which priorities go where.
*
* Anyway, in practice I observe that WM_NETEVENT seems to
* jump to the head of the queue, which means that if we
* were to only process one message every time round this
* loop, we'd get nothing but NETEVENTs if the server
* flooded us with data, and stop responding to any other
* kind of window message. So instead, we keep on round
* this loop until we've consumed at least one message
* that _isn't_ a NETEVENT, or run out of messages
* completely (whichever comes first). And we don't go to
* run_toplevel_callbacks (which is where the netevents
* are actually processed, causing fresh NETEVENT messages
* to appear) until we've done this.
*/
if (msg.message != WM_NETEVENT)
break;
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
}
RDB's general resizing cleanup. He's put his favourite resize mode back in again, but as long as it's not the default it doesn't bother me too much :-) [originally from svn r1421]
2001-11-25 18:39:57 +00:00
Only run one toplevel callback per event loop iteration. This change attempts to reinstate as a universal property something which was sporadically true of the ad-hockery that came before toplevel callbacks: that if there's a _very long_ queue of things to be done through the callback mechanism, the doing of them will be interleaved with re-checks of other event sources, which might (e.g.) cause a flag to be set which makes the next callback decide not to do anything after all. [originally from svn r10040]
2013-09-15 14:05:31 +00:00
run_toplevel_callbacks();
Initial checkin: beta 0.43 [originally from svn r11]
1999-01-08 13:02:13 +00:00
}
Formatting: realign labels and case/default statements. My aim has always been to have those back-dented by 2 spaces (half an indent level) compared to the statements around them, so that in particular switch statements have distinct alignment for the statement, the cases and the interior code without consuming two whole indent levels. This patch sweeps up all the violations of that principle found by my bulk-reindentation exercise.
2022-08-03 19:48:46 +00:00
finished:
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
cleanup_exit(msg.wParam); /* this doesn't return... */
return msg.wParam; /* ... but optimiser doesn't know */
Ensure our network layer is properly cleaned up before PuTTY exits. Specifically, we explicitly closesocket() all open sockets, which appears to be necessary since otherwise Windows sends RST rather than FIN. I'm _sure_ that's a Windows bug, but there we go. [originally from svn r1574]
2002-03-06 20:13:22 +00:00
}
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
static void wgs_cleanup(WinGuiSeat *wgs)
{
deinit_fonts(wgs);
sfree(wgs->logpal);
if (wgs->pal)
DeleteObject(wgs->pal);
wgs_unlink(wgs);
sfree(wgs);
}
Move some parts of window.c into putty.c. This prepares the ground for a second essentially similarly-shaped program reusing most of window.c but handling its command line and startup differently. A couple of large parts of WinMain() to do with backend selection and command-line handling are now subfunctions in a separate file putty.c. Also, our custom AppUserModelId is defined in that file, so that it can vary with the client application.
2021-05-08 16:20:50 +00:00
char *handle_restrict_acl_cmdline_prefix(char *p)
{
/*
* Process the &R prefix on a command line, which is equivalent to
* -restrict-acl but lexically easier to prepend when another
* instance of ourself automatically constructs a command line.
*
* If successful, restricts the process ACL and advances the input
* pointer past the prefix. Returns the updated pointer (whether
* it moved or not).
*/
Add some missing casts in ctype functions. I thought I'd found all of these before, but perhaps a few managed to slip in since I last looked. The character argument to the <ctype.h> functions must have the value of an unsigned char or EOF; passing an ordinary char (unless you know char is unsigned on every platform the code will ever go near) risks mistaking '\xFF' for EOF, and causing outright undefined behaviour on byte values in the range 80-FE. Never do it.
2023-03-05 13:15:57 +00:00
while (*p && isspace((unsigned char)*p))
Move some parts of window.c into putty.c. This prepares the ground for a second essentially similarly-shaped program reusing most of window.c but handling its command line and startup differently. A couple of large parts of WinMain() to do with backend selection and command-line handling are now subfunctions in a separate file putty.c. Also, our custom AppUserModelId is defined in that file, so that it can vary with the client application.
2021-05-08 16:20:50 +00:00
p++;
if (*p == '&' && p[1] == 'R' &&
(!p[2] || p[2] == '@' || p[2] == '&')) {
/* &R restrict-acl prefix */
restrict_process_acl();
p += 2;
}
return p;
}
bool handle_special_sessionname_cmdline(char *p, Conf *conf)
{
/*
* Process the special form of command line with an initial @
* followed by the name of a saved session with _no quoting or
* escaping_. This is a very convenient means of automated
* saved-session launching, via IDM_SAVEDSESS or Windows 7 jump
* lists.
*
* If successful, the whole command line has been interpreted in
* this way, so there's nothing left to parse into other arguments.
*/
if (*p != '@')
return false;
ptrlen sessionname = ptrlen_from_asciz(p + 1);
while (sessionname.len > 0 &&
isspace(((unsigned char *)sessionname.ptr)[sessionname.len-1]))
sessionname.len--;
char *dup = mkstr(sessionname);
bool loaded = do_defaults(dup, conf);
sfree(dup);
return loaded;
}
bool handle_special_filemapping_cmdline(char *p, Conf *conf)
{
/*
* Process the special form of command line with an initial &
* followed by the hex value of a HANDLE for a file mapping object
* and the size of the data contained in it, which we must
* interpret as a serialised Conf.
*
* If successful, the whole command line has been interpreted in
* this way, so there's nothing left to parse into other arguments.
*/
if (*p != '&')
return false;
HANDLE filemap;
unsigned cpsize;
if (sscanf(p + 1, "%p:%u", &filemap, &cpsize) != 2)
return false;
void *cp = MapViewOfFile(filemap, FILE_MAP_READ, 0, 0, cpsize);
if (!cp)
return false;
BinarySource src[1];
BinarySource_BARE_INIT(src, cp, cpsize);
if (!conf_deserialise(conf, src))
modalfatalbox("Serialised configuration data was invalid");
UnmapViewOfFile(cp);
CloseHandle(filemap);
return true;
}
Add GUI configuration for choice of clipboards. On all platforms, you can now configure which clipboard the mouse pastes from, which clipboard Ctrl-Ins and Shift-Ins access, and which Ctrl-Shift-C and Ctrl-Shift-V access. In each case, the options are: - nothing at all - a clipboard which is implicitly written by the act of mouse selection (the PRIMARY selection on X, CLIP_LOCAL everywhere else) - the standard clipboard written by explicit copy/paste UI actions (CLIPBOARD on X, the unique system clipboard elsewhere). Also, you can control whether selecting text with the mouse _also_ writes to the explicitly accessed clipboard. The wording of the various messages changes between platforms, but the basic UI shape is the same everywhere.
2017-12-10 17:16:50 +00:00
static void setup_clipboards(Terminal *term, Conf *conf)
{
assert(term->mouse_select_clipboards[0] == CLIP_LOCAL);
term->n_mouse_select_clipboards = 1;
Switch some Conf settings over to being bool. I think this is the full set of things that ought logically to be boolean. One annoyance is that quite a few radio-button controls in config.c address Conf fields that are now bool rather than int, which means that the shared handler function can't just access them all with conf_{get,set}_int. Rather than back out the rigorous separation of int and bool in conf.c itself, I've just added a similar alternative handler function for the bool-typed ones.
2018-10-29 19:57:31 +00:00
if (conf_get_bool(conf, CONF_mouseautocopy)) {
Add GUI configuration for choice of clipboards. On all platforms, you can now configure which clipboard the mouse pastes from, which clipboard Ctrl-Ins and Shift-Ins access, and which Ctrl-Shift-C and Ctrl-Shift-V access. In each case, the options are: - nothing at all - a clipboard which is implicitly written by the act of mouse selection (the PRIMARY selection on X, CLIP_LOCAL everywhere else) - the standard clipboard written by explicit copy/paste UI actions (CLIPBOARD on X, the unique system clipboard elsewhere). Also, you can control whether selecting text with the mouse _also_ writes to the explicitly accessed clipboard. The wording of the various messages changes between platforms, but the basic UI shape is the same everywhere.
2017-12-10 17:16:50 +00:00
term->mouse_select_clipboards[
term->n_mouse_select_clipboards++] = CLIP_SYSTEM;
}
switch (conf_get_int(conf, CONF_mousepaste)) {
case CLIPUI_IMPLICIT:
term->mouse_paste_clipboard = CLIP_LOCAL;
break;
case CLIPUI_EXPLICIT:
term->mouse_paste_clipboard = CLIP_SYSTEM;
break;
default:
term->mouse_paste_clipboard = CLIP_NULL;
break;
}
}
Ensure our network layer is properly cleaned up before PuTTY exits. Specifically, we explicitly closesocket() all open sockets, which appears to be necessary since otherwise Windows sends RST rather than FIN. I'm _sure_ that's a Windows bug, but there we go. [originally from svn r1574]
2002-03-06 20:13:22 +00:00
/*
* Clean up and exit.
*/
void cleanup_exit(int code)
{
Initial checkin: beta 0.43 [originally from svn r11]
1999-01-08 13:02:13 +00:00
/*
* Clean up.
*/
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
while (wgslisthead.next != &wgslisthead) {
WinGuiSeat *wgs = container_of(
wgslisthead.next, WinGuiSeat, wgslistnode);
wgs_cleanup(wgs);
}
Ensure our network layer is properly cleaned up before PuTTY exits. Specifically, we explicitly closesocket() all open sockets, which appears to be necessary since otherwise Windows sends RST rather than FIN. I'm _sure_ that's a Windows bug, but there we go. [originally from svn r1574]
2002-03-06 20:13:22 +00:00
sk_cleanup();
Initial checkin: beta 0.43 [originally from svn r11]
1999-01-08 13:02:13 +00:00
windows/window.c: make random_save_seed call unconditional. The conditionalisation of that call on 'protocol == PROT_SSH' has been around since the beginning of our git history. But in those days, random_save_seed() was unconditional _internally_ - it would always create and write to the seed file regardless of whether the random pool had even been initialised, let alone used. Now random_save_seed() has its own internal condition which prevents it doing anything if the random subsystem was never started up in the first place. So it's better to call it unconditionally from cleanup_exit, and then it'll be able to do its thing whenever needed, without having to second-guess based on the top-level protocol. (In fact, that's what all the other implementations of cleanup_exit() have done all along. On Unix, and in Windows console apps, we do call random_save_seed() unconditionally, and expect it to uncomplainingly do nothing if there's nothing to do.)
2022-09-12 11:55:47 +00:00
random_save_seed();
Initial support for HTML Help. All the ad-hoc help-file finding code and various calls to WinHelp() have been centralised into a new file winhelp.c, which in turn has been modified to detect a .CHM file as well as .HLP and select between them as appropriate. It explicitly tries to load HHCTRL.OCX and use GetProcAddress, meaning that it _should_ still work correctly on pre-HTML-Help platforms, falling gracefully back to WinHelp, but although I tested this by temporarily renaming my own HHCTRL.OCX I haven't yet been able to test it on a real HTML-Help-free platform. Also in this checkin: a new .but file and docs makefile changes to make it convenient to build the sources for a .CHM. As yet, owing to limitations of Halibut's CHM support, I'm not able to write a .CHM directly, more's the pity. [originally from svn r7000]
2006-12-17 11:16:07 +00:00
shutdown_help();
Initial checkin: beta 0.43 [originally from svn r11]
1999-01-08 13:02:13 +00:00
Support for Windows 7 jump lists (right-click on a program's taskbar icon, even if the program isn't running at the time, to be presented with an application-defined collection of helpful links). The current jump list is updated every time a saved session is loaded, and shows the last few launchable saved sessions (i.e. not those like Default Settings) that were loaded. Also, if Pageant or PuTTYgen or both is in the same directory as the PuTTY binary, the jump list will present links to launch those too. Based on a patch sent last year by Daniel B. Roy, though it's barely recognisable any more... [originally from svn r9046]
2010-12-23 17:32:28 +00:00
/* Clean up COM. */
CoUninitialize();
Ensure our network layer is properly cleaned up before PuTTY exits. Specifically, we explicitly closesocket() all open sockets, which appears to be necessary since otherwise Windows sends RST rather than FIN. I'm _sure_ that's a Windows bug, but there we go. [originally from svn r1574]
2002-03-06 20:13:22 +00:00
exit(code);
Initial checkin: beta 0.43 [originally from svn r11]
1999-01-08 13:02:13 +00:00
}
If a new session was saved from Change Settings, a side-effect on Windows was that the global `sesslist' got out of sync with the saved-sessions submenu, causing the latter to launch the wrong sessions. Also, Change Settings wasn't getting a fresh session list, so if the set of sessions had changed since session startup it wouldn't reflect that (at least until a session was saved). Fixed (on all platforms). Therefore, since the global sesslist didn't seem to be useful, I've got rid of it; config.c creates one as needed, as do the frontends. (Not tried compiling Mac changes.) Also, we now build the saved-sessions submenu on demand on Windows and Unix. (This should probably also be done on the Mac.) [originally from svn r5609]
2005-04-07 01:36:28 +00:00
/*
* Refresh the saved-session submenu from `sesslist'.
*/
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
static void update_savedsess_menu(WinGuiSeat *wgs)
If a new session was saved from Change Settings, a side-effect on Windows was that the global `sesslist' got out of sync with the saved-sessions submenu, causing the latter to launch the wrong sessions. Also, Change Settings wasn't getting a fresh session list, so if the set of sessions had changed since session startup it wouldn't reflect that (at least until a session was saved). Fixed (on all platforms). Therefore, since the global sesslist didn't seem to be useful, I've got rid of it; config.c creates one as needed, as do the frontends. (Not tried compiling Mac changes.) Also, we now build the saved-sessions submenu on demand on Windows and Unix. (This should probably also be done on the Mac.) [originally from svn r5609]
2005-04-07 01:36:28 +00:00
{
int i;
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
while (DeleteMenu(wgs->savedsess_menu, 0, MF_BYPOSITION)) ;
If a new session was saved from Change Settings, a side-effect on Windows was that the global `sesslist' got out of sync with the saved-sessions submenu, causing the latter to launch the wrong sessions. Also, Change Settings wasn't getting a fresh session list, so if the set of sessions had changed since session startup it wouldn't reflect that (at least until a session was saved). Fixed (on all platforms). Therefore, since the global sesslist didn't seem to be useful, I've got rid of it; config.c creates one as needed, as do the frontends. (Not tried compiling Mac changes.) Also, we now build the saved-sessions submenu on demand on Windows and Unix. (This should probably also be done on the Mac.) [originally from svn r5609]
2005-04-07 01:36:28 +00:00
/* skip sesslist.sessions[0] == Default Settings */
for (i = 1;
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
i < ((sesslist.nsessions <= MENU_SAVED_MAX+1) ? sesslist.nsessions
: MENU_SAVED_MAX+1);
i++)
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
AppendMenu(wgs->savedsess_menu, MF_ENABLED,
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
IDM_SAVED_MIN + (i-1)*MENU_SAVED_STEP,
sesslist.sessions[i]);
If there are no saved sessions, put a grayed "(No sessions)" entry on the saved sessions submenu of the terminal window context menu (as Pageant does), rather than an empty menu (which often renders poorly). [originally from svn r8648]
2009-09-13 23:29:11 +00:00
if (sesslist.nsessions <= 1)
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
AppendMenu(wgs->savedsess_menu, MF_GRAYED, IDM_SAVED_MIN,
"(No sessions)");
If a new session was saved from Change Settings, a side-effect on Windows was that the global `sesslist' got out of sync with the saved-sessions submenu, causing the latter to launch the wrong sessions. Also, Change Settings wasn't getting a fresh session list, so if the set of sessions had changed since session startup it wouldn't reflect that (at least until a session was saved). Fixed (on all platforms). Therefore, since the global sesslist didn't seem to be useful, I've got rid of it; config.c creates one as needed, as do the frontends. (Not tried compiling Mac changes.) Also, we now build the saved-sessions submenu on demand on Windows and Unix. (This should probably also be done on the Mac.) [originally from svn r5609]
2005-04-07 01:36:28 +00:00
}
Turned the old `Telnet Command' System-submenu into a more general `Special Command' menu, in which any backend can place its own list of magical things the user might want to ask the backend to do. In particular I've implemented the recently proposed "break" extension in SSH2 using this mechanism. NB this checkin slightly breaks the Mac build, since it needs to provide at least a stub form of update_specials_menu(). [originally from svn r3054]
2003-04-04 20:21:05 +00:00
/*
* Update the Special Commands submenu.
*/
New abstraction 'Seat', to pass to backends. This is a new vtable-based abstraction which is passed to a backend in place of Frontend, and it implements only the subset of the Frontend functions needed by a backend. (Many other Frontend functions still exist, notably the wide range of things called by terminal.c providing platform-independent operations on the GUI terminal window.) The purpose of making it a vtable is that this opens up the possibility of creating a backend as an internal implementation detail of some other activity, by providing just that one backend with a custom Seat that implements the methods differently. For example, this refactoring should make it feasible to directly implement an SSH proxy type, aka the 'jump host' feature supported by OpenSSH, aka 'open a secondary SSH session in MAINCHAN_DIRECT_TCP mode, and then expose the main channel of that as the Socket for the primary connection'. (Which of course you can already do by spawning 'plink -nc' as a separate proxy process, but this would permit it in the _same_ process without anything getting confused.) I've centralised a full set of stub methods in misc.c for the new abstraction, which allows me to get rid of several annoying stubs in the previous code. Also, while I'm here, I've moved a lot of duplicated modalfatalbox() type functions from application main program files into wincons.c / uxcons.c, which I think saves duplication overall. (A minor visible effect is that the prefixes on those console-based fatal error messages will now be more consistent between applications.)
2018-10-11 18:58:42 +00:00
static void win_seat_update_specials_menu(Seat *seat)
Turned the old `Telnet Command' System-submenu into a more general `Special Command' menu, in which any backend can place its own list of magical things the user might want to ask the backend to do. In particular I've implemented the recently proposed "break" extension in SSH2 using this mechanism. NB this checkin slightly breaks the Mac build, since it needs to provide at least a stub form of update_specials_menu(). [originally from svn r3054]
2003-04-04 20:21:05 +00:00
{
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
WinGuiSeat *wgs = container_of(seat, WinGuiSeat, seat);
Users of Virtual Dimension are reporting that the "Close" menu item and button tend to get disabled on login. After a suggestion by "Tkil", change the way we handle the specials menu to be robust against the window menu being externally modified. [originally from svn r6546] [this svn revision also touched putty-wishlist]
2006-02-09 23:06:57 +00:00
HMENU new_menu;
Introduce a context menu which appears on Ctrl+rightclick. This menu contains all the stuff in the System menu except for the standard System menu bits (move, resize, close etc), and also contains `Paste'. [originally from svn r3555]
2003-11-19 20:48:30 +00:00
int i, j;
Turned the old `Telnet Command' System-submenu into a more general `Special Command' menu, in which any backend can place its own list of magical things the user might want to ask the backend to do. In particular I've implemented the recently proposed "break" extension in SSH2 using this mechanism. NB this checkin slightly breaks the Mac build, since it needs to provide at least a stub form of update_specials_menu(). [originally from svn r3054]
2003-04-04 20:21:05 +00:00
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
if (wgs->backend)
wgs->specials = backend_get_specials(wgs->backend);
Implement `Restart Session', in both Unix and Windows PuTTY. Largely because Owen questioned whether it was really easy enough to be labelled `fun' in the bug database :-) [originally from svn r4453]
2004-08-14 13:04:18 +00:00
else
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
wgs->specials = NULL;
Implement `Restart Session', in both Unix and Windows PuTTY. Largely because Owen questioned whether it was really easy enough to be labelled `fun' in the bug database :-) [originally from svn r4453]
2004-08-14 13:04:18 +00:00
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
if (wgs->specials) {
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
/* We can't use Windows to provide a stack for submenus, so
* here's a lame "stack" that will do for now. */
HMENU saved_menu = NULL;
int nesting = 1;
new_menu = CreatePopupMenu();
for (i = 0; nesting > 0; i++) {
assert(IDM_SPECIAL_MIN + 0x10 * i < IDM_SPECIAL_MAX);
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
switch (wgs->specials[i].code) {
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
case SS_SEP:
AppendMenu(new_menu, MF_SEPARATOR, 0, 0);
break;
case SS_SUBMENU:
assert(nesting < 2);
nesting++;
saved_menu = new_menu; /* XXX lame stacking */
new_menu = CreatePopupMenu();
AppendMenu(saved_menu, MF_POPUP | MF_ENABLED,
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
(UINT_PTR) new_menu, wgs->specials[i].name);
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
break;
case SS_EXITMENU:
nesting--;
if (nesting) {
new_menu = saved_menu; /* XXX lame stacking */
saved_menu = NULL;
}
break;
default:
AppendMenu(new_menu, MF_ENABLED, IDM_SPECIAL_MIN + 0x10 * i,
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
wgs->specials[i].name);
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
break;
}
}
/* Squirrel the highest special. */
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
wgs->n_specials = i - 1;
Support the SSH-2 mechanism for sending signals to a running session. Neither of the SSH servers I conveniently have access to (Debian stable OpenSSH -- 3.4p1 -- and lshd) seem to take a blind bit of notice, but the channel requests look fine to me in the packet log. I've included all the signals explicitly defined by draft-ietf-secsh-connect-19, but I've put the more obscure ones in a submenu of the specials menu; there's therefore been some minor upheaval to support such submenus. [originally from svn r4652]
2004-10-17 21:22:22 +00:00
} else {
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
new_menu = NULL;
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
wgs->n_specials = 0;
Support the SSH-2 mechanism for sending signals to a running session. Neither of the SSH servers I conveniently have access to (Debian stable OpenSSH -- 3.4p1 -- and lshd) seem to take a blind bit of notice, but the channel requests look fine to me in the packet log. I've included all the signals explicitly defined by draft-ietf-secsh-connect-19, but I've put the more obscure ones in a submenu of the specials menu; there's therefore been some minor upheaval to support such submenus. [originally from svn r4652]
2004-10-17 21:22:22 +00:00
}
Implement `Restart Session', in both Unix and Windows PuTTY. Largely because Owen questioned whether it was really easy enough to be labelled `fun' in the bug database :-) [originally from svn r4453]
2004-08-14 13:04:18 +00:00
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
for (j = 0; j < lenof(wgs->popup_menus); j++) {
if (wgs->specials_menu) {
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
/* XXX does this free up all submenus? */
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
DeleteMenu(wgs->popup_menus[j].menu, (UINT_PTR)wgs->specials_menu,
64-bit cleanness: use INT_PTR/UINT_PTR where appropriate. These integer types are correct for the id/handle parameter to AppendMenu / InsertMenu / DeleteMenu, and also for the return type of dialog box procedures.
2016-04-02 13:10:27 +00:00
MF_BYCOMMAND);
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
DeleteMenu(wgs->popup_menus[j].menu, IDM_SPECIALSEP, MF_BYCOMMAND);
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
}
if (new_menu) {
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
InsertMenu(wgs->popup_menus[j].menu, IDM_SHOWLOG,
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
MF_BYCOMMAND | MF_POPUP | MF_ENABLED,
(UINT_PTR) new_menu, "S&pecial Command");
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
InsertMenu(wgs->popup_menus[j].menu, IDM_SHOWLOG,
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
MF_BYCOMMAND | MF_SEPARATOR, IDM_SPECIALSEP, 0);
}
Turned the old `Telnet Command' System-submenu into a more general `Special Command' menu, in which any backend can place its own list of magical things the user might want to ask the backend to do. In particular I've implemented the recently proposed "break" extension in SSH2 using this mechanism. NB this checkin slightly breaks the Mac build, since it needs to provide at least a stub form of update_specials_menu(). [originally from svn r3054]
2003-04-04 20:21:05 +00:00
}
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
wgs->specials_menu = new_menu;
Turned the old `Telnet Command' System-submenu into a more general `Special Command' menu, in which any backend can place its own list of magical things the user might want to ask the backend to do. In particular I've implemented the recently proposed "break" extension in SSH2 using this mechanism. NB this checkin slightly breaks the Mac build, since it needs to provide at least a stub form of update_specials_menu(). [originally from svn r3054]
2003-04-04 20:21:05 +00:00
}
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
static void update_mouse_pointer(WinGuiSeat *wgs)
The terminal window can now indicate that PuTTY is busy in various ways, by changing its mouse pointer. Currently this is only used in the (slightly- arbitrarily-defined) "heavy" bits of SSH-2 key exchange. We override pointer hiding while PuTTY is busy, but preserve pointer-hiding state. Not yet implemented on the Mac. Also switch to frobbing window-class cursor in Windows rather than relying on SetCursor(). [originally from svn r5303]
2005-02-15 17:05:58 +00:00
{
Fix a few compiler warnings from MinGW. A few variables that gcc couldn't tell I'd initialised on all the important paths, a variable that didn't really need to be there anyway, and yet another use of GET_WINDOWS_FUNCTION_NO_TYPECHECK.
2018-06-03 20:48:08 +00:00
LPTSTR curstype = NULL;
Convert a lot of 'int' variables to 'bool'. My normal habit these days, in new code, is to treat int and bool as _almost_ completely separate types. I'm still willing to use C's implicit test for zero on an integer (e.g. 'if (!blob.len)' is fine, no need to spell it out as blob.len != 0), but generally, if a variable is going to be conceptually a boolean, I like to declare it bool and assign to it using 'true' or 'false' rather than 0 or 1. PuTTY is an exception, because it predates the C99 bool, and I've stuck to its existing coding style even when adding new code to it. But it's been annoying me more and more, so now that I've decided C99 bool is an acceptable thing to require from our toolchain in the first place, here's a quite thorough trawl through the source doing 'boolification'. Many variables and function parameters are now typed as bool rather than int; many assignments of 0 or 1 to those variables are now spelled 'true' or 'false'. I managed this thorough conversion with the help of a custom clang plugin that I wrote to trawl the AST and apply heuristics to point out where things might want changing. So I've even managed to do a decent job on parts of the code I haven't looked at in years! To make the plugin's work easier, I pushed platform front ends generally in the direction of using standard 'bool' in preference to platform-specific boolean types like Windows BOOL or GTK's gboolean; I've left the platform booleans in places they _have_ to be for the platform APIs to work right, but variables only used by my own code have been converted wherever I found them. In a few places there are int values that look very like booleans in _most_ of the places they're used, but have a rarely-used third value, or a distinction between different nonzero values that most users don't care about. In these cases, I've _removed_ uses of 'true' and 'false' for the return values, to emphasise that there's something more subtle going on than a simple boolean answer: - the 'multisel' field in dialog.h's list box structure, for which the GTK front end in particular recognises a difference between 1 and 2 but nearly everything else treats as boolean - the 'urgent' parameter to plug_receive, where 1 vs 2 tells you something about the specific location of the urgent pointer, but most clients only care about 0 vs 'something nonzero' - the return value of wc_match, where -1 indicates a syntax error in the wildcard. - the return values from SSH-1 RSA-key loading functions, which use -1 for 'wrong passphrase' and 0 for all other failures (so any caller which already knows it's not loading an _encrypted private_ key can treat them as boolean) - term->esc_query, and the 'query' parameter in toggle_mode in terminal.c, which _usually_ hold 0 for ESC[123h or 1 for ESC[?123h, but can also hold -1 for some other intervening character that we don't support. In a few places there's an integer that I haven't turned into a bool even though it really _can_ only take values 0 or 1 (and, as above, tried to make the call sites consistent in not calling those values true and false), on the grounds that I thought it would make it more confusing to imply that the 0 value was in some sense 'negative' or bad and the 1 positive or good: - the return value of plug_accepting uses the POSIXish convention of 0=success and nonzero=error; I think if I made it bool then I'd also want to reverse its sense, and that's a job for a separate piece of work. - the 'screen' parameter to lineptr() in terminal.c, where 0 and 1 represent the default and alternate screens. There's no obvious reason why one of those should be considered 'true' or 'positive' or 'success' - they're just indices - so I've left it as int. ssh_scp_recv had particularly confusing semantics for its previous int return value: its call sites used '<= 0' to check for error, but it never actually returned a negative number, just 0 or 1. Now the function and its call sites agree that it's a bool. In a couple of places I've renamed variables called 'ret', because I don't like that name any more - it's unclear whether it means the return value (in preparation) for the _containing_ function or the return value received from a subroutine call, and occasionally I've accidentally used the same variable for both and introduced a bug. So where one of those got in my way, I've renamed it to 'toret' or 'retd' (the latter short for 'returned') in line with my usual modern practice, but I haven't done a thorough job of finding all of them. Finally, one amusing side effect of doing this is that I've had to separate quite a few chained assignments. It used to be perfectly fine to write 'a = b = c = TRUE' when a,b,c were int and TRUE was just a the 'true' defined by stdbool.h, that idiom provokes a warning from gcc: 'suggest parentheses around assignment used as truth value'!
2018-11-02 19:23:19 +00:00
bool force_visible = false;
static bool forced_visible = false;
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
switch (wgs->busy_status) {
The terminal window can now indicate that PuTTY is busy in various ways, by changing its mouse pointer. Currently this is only used in the (slightly- arbitrarily-defined) "heavy" bits of SSH-2 key exchange. We override pointer hiding while PuTTY is busy, but preserve pointer-hiding state. Not yet implemented on the Mac. Also switch to frobbing window-class cursor in Windows rather than relying on SetCursor(). [originally from svn r5303]
2005-02-15 17:05:58 +00:00
case BUSY_NOT:
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
if (wgs->pointer_indicates_raw_mouse)
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
curstype = IDC_ARROW;
else
curstype = IDC_IBEAM;
break;
The terminal window can now indicate that PuTTY is busy in various ways, by changing its mouse pointer. Currently this is only used in the (slightly- arbitrarily-defined) "heavy" bits of SSH-2 key exchange. We override pointer hiding while PuTTY is busy, but preserve pointer-hiding state. Not yet implemented on the Mac. Also switch to frobbing window-class cursor in Windows rather than relying on SetCursor(). [originally from svn r5303]
2005-02-15 17:05:58 +00:00
case BUSY_WAITING:
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
curstype = IDC_APPSTARTING; /* this may be an abuse */
force_visible = true;
break;
The terminal window can now indicate that PuTTY is busy in various ways, by changing its mouse pointer. Currently this is only used in the (slightly- arbitrarily-defined) "heavy" bits of SSH-2 key exchange. We override pointer hiding while PuTTY is busy, but preserve pointer-hiding state. Not yet implemented on the Mac. Also switch to frobbing window-class cursor in Windows rather than relying on SetCursor(). [originally from svn r5303]
2005-02-15 17:05:58 +00:00
case BUSY_CPU:
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
curstype = IDC_WAIT;
force_visible = true;
break;
The terminal window can now indicate that PuTTY is busy in various ways, by changing its mouse pointer. Currently this is only used in the (slightly- arbitrarily-defined) "heavy" bits of SSH-2 key exchange. We override pointer hiding while PuTTY is busy, but preserve pointer-hiding state. Not yet implemented on the Mac. Also switch to frobbing window-class cursor in Windows rather than relying on SetCursor(). [originally from svn r5303]
2005-02-15 17:05:58 +00:00
default:
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
unreachable("Bad busy_status");
The terminal window can now indicate that PuTTY is busy in various ways, by changing its mouse pointer. Currently this is only used in the (slightly- arbitrarily-defined) "heavy" bits of SSH-2 key exchange. We override pointer hiding while PuTTY is busy, but preserve pointer-hiding state. Not yet implemented on the Mac. Also switch to frobbing window-class cursor in Windows rather than relying on SetCursor(). [originally from svn r5303]
2005-02-15 17:05:58 +00:00
}
{
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
HCURSOR cursor = LoadCursor(NULL, curstype);
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
SetClassLongPtr(wgs->term_hwnd, GCLP_HCURSOR, (LONG_PTR)cursor);
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
SetCursor(cursor); /* force redraw of cursor at current posn */
The terminal window can now indicate that PuTTY is busy in various ways, by changing its mouse pointer. Currently this is only used in the (slightly- arbitrarily-defined) "heavy" bits of SSH-2 key exchange. We override pointer hiding while PuTTY is busy, but preserve pointer-hiding state. Not yet implemented on the Mac. Also switch to frobbing window-class cursor in Windows rather than relying on SetCursor(). [originally from svn r5303]
2005-02-15 17:05:58 +00:00
}
if (force_visible != forced_visible) {
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
/* We want some cursor shapes to be visible always.
* Along with show_mouseptr(), this manages the ShowCursor()
* counter such that if we switch back to a non-force_visible
* cursor, the previous visibility state is restored. */
ShowCursor(force_visible);
forced_visible = force_visible;
The terminal window can now indicate that PuTTY is busy in various ways, by changing its mouse pointer. Currently this is only used in the (slightly- arbitrarily-defined) "heavy" bits of SSH-2 key exchange. We override pointer hiding while PuTTY is busy, but preserve pointer-hiding state. Not yet implemented on the Mac. Also switch to frobbing window-class cursor in Windows rather than relying on SetCursor(). [originally from svn r5303]
2005-02-15 17:05:58 +00:00
}
}
New abstraction 'Seat', to pass to backends. This is a new vtable-based abstraction which is passed to a backend in place of Frontend, and it implements only the subset of the Frontend functions needed by a backend. (Many other Frontend functions still exist, notably the wide range of things called by terminal.c providing platform-independent operations on the GUI terminal window.) The purpose of making it a vtable is that this opens up the possibility of creating a backend as an internal implementation detail of some other activity, by providing just that one backend with a custom Seat that implements the methods differently. For example, this refactoring should make it feasible to directly implement an SSH proxy type, aka the 'jump host' feature supported by OpenSSH, aka 'open a secondary SSH session in MAINCHAN_DIRECT_TCP mode, and then expose the main channel of that as the Socket for the primary connection'. (Which of course you can already do by spawning 'plink -nc' as a separate proxy process, but this would permit it in the _same_ process without anything getting confused.) I've centralised a full set of stub methods in misc.c for the new abstraction, which allows me to get rid of several annoying stubs in the previous code. Also, while I'm here, I've moved a lot of duplicated modalfatalbox() type functions from application main program files into wincons.c / uxcons.c, which I think saves duplication overall. (A minor visible effect is that the prefixes on those console-based fatal error messages will now be more consistent between applications.)
2018-10-11 18:58:42 +00:00
static void win_seat_set_busy_status(Seat *seat, BusyStatus status)
The terminal window can now indicate that PuTTY is busy in various ways, by changing its mouse pointer. Currently this is only used in the (slightly- arbitrarily-defined) "heavy" bits of SSH-2 key exchange. We override pointer hiding while PuTTY is busy, but preserve pointer-hiding state. Not yet implemented on the Mac. Also switch to frobbing window-class cursor in Windows rather than relying on SetCursor(). [originally from svn r5303]
2005-02-15 17:05:58 +00:00
{
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
WinGuiSeat *wgs = container_of(seat, WinGuiSeat, seat);
wgs->busy_status = status;
update_mouse_pointer(wgs);
The terminal window can now indicate that PuTTY is busy in various ways, by changing its mouse pointer. Currently this is only used in the (slightly- arbitrarily-defined) "heavy" bits of SSH-2 key exchange. We override pointer hiding while PuTTY is busy, but preserve pointer-hiding state. Not yet implemented on the Mac. Also switch to frobbing window-class cursor in Windows rather than relying on SetCursor(). [originally from svn r5303]
2005-02-15 17:05:58 +00:00
}
Convert a lot of 'int' variables to 'bool'. My normal habit these days, in new code, is to treat int and bool as _almost_ completely separate types. I'm still willing to use C's implicit test for zero on an integer (e.g. 'if (!blob.len)' is fine, no need to spell it out as blob.len != 0), but generally, if a variable is going to be conceptually a boolean, I like to declare it bool and assign to it using 'true' or 'false' rather than 0 or 1. PuTTY is an exception, because it predates the C99 bool, and I've stuck to its existing coding style even when adding new code to it. But it's been annoying me more and more, so now that I've decided C99 bool is an acceptable thing to require from our toolchain in the first place, here's a quite thorough trawl through the source doing 'boolification'. Many variables and function parameters are now typed as bool rather than int; many assignments of 0 or 1 to those variables are now spelled 'true' or 'false'. I managed this thorough conversion with the help of a custom clang plugin that I wrote to trawl the AST and apply heuristics to point out where things might want changing. So I've even managed to do a decent job on parts of the code I haven't looked at in years! To make the plugin's work easier, I pushed platform front ends generally in the direction of using standard 'bool' in preference to platform-specific boolean types like Windows BOOL or GTK's gboolean; I've left the platform booleans in places they _have_ to be for the platform APIs to work right, but variables only used by my own code have been converted wherever I found them. In a few places there are int values that look very like booleans in _most_ of the places they're used, but have a rarely-used third value, or a distinction between different nonzero values that most users don't care about. In these cases, I've _removed_ uses of 'true' and 'false' for the return values, to emphasise that there's something more subtle going on than a simple boolean answer: - the 'multisel' field in dialog.h's list box structure, for which the GTK front end in particular recognises a difference between 1 and 2 but nearly everything else treats as boolean - the 'urgent' parameter to plug_receive, where 1 vs 2 tells you something about the specific location of the urgent pointer, but most clients only care about 0 vs 'something nonzero' - the return value of wc_match, where -1 indicates a syntax error in the wildcard. - the return values from SSH-1 RSA-key loading functions, which use -1 for 'wrong passphrase' and 0 for all other failures (so any caller which already knows it's not loading an _encrypted private_ key can treat them as boolean) - term->esc_query, and the 'query' parameter in toggle_mode in terminal.c, which _usually_ hold 0 for ESC[123h or 1 for ESC[?123h, but can also hold -1 for some other intervening character that we don't support. In a few places there's an integer that I haven't turned into a bool even though it really _can_ only take values 0 or 1 (and, as above, tried to make the call sites consistent in not calling those values true and false), on the grounds that I thought it would make it more confusing to imply that the 0 value was in some sense 'negative' or bad and the 1 positive or good: - the return value of plug_accepting uses the POSIXish convention of 0=success and nonzero=error; I think if I made it bool then I'd also want to reverse its sense, and that's a job for a separate piece of work. - the 'screen' parameter to lineptr() in terminal.c, where 0 and 1 represent the default and alternate screens. There's no obvious reason why one of those should be considered 'true' or 'positive' or 'success' - they're just indices - so I've left it as int. ssh_scp_recv had particularly confusing semantics for its previous int return value: its call sites used '<= 0' to check for error, but it never actually returned a negative number, just 0 or 1. Now the function and its call sites agree that it's a bool. In a couple of places I've renamed variables called 'ret', because I don't like that name any more - it's unclear whether it means the return value (in preparation) for the _containing_ function or the return value received from a subroutine call, and occasionally I've accidentally used the same variable for both and introduced a bug. So where one of those got in my way, I've renamed it to 'toret' or 'retd' (the latter short for 'returned') in line with my usual modern practice, but I haven't done a thorough job of finding all of them. Finally, one amusing side effect of doing this is that I've had to separate quite a few chained assignments. It used to be perfectly fine to write 'a = b = c = TRUE' when a,b,c were int and TRUE was just a the 'true' defined by stdbool.h, that idiom provokes a warning from gcc: 'suggest parentheses around assignment used as truth value'!
2018-11-02 19:23:19 +00:00
static void wintw_set_raw_mouse_mode(TermWin *tw, bool activate)
Wez Furlong's patch to add xterm mouse reporting and proper mouse wheel support. [originally from svn r1097]
2001-05-06 14:20:41 +00:00
{
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
WinGuiSeat *wgs = container_of(tw, WinGuiSeat, termwin);
wgs->send_raw_mouse = activate;
Decouple frontend's raw mouse mode from pointer shape. This paves the way for a followup commit that will make them happen at slightly different times.
2021-02-07 19:59:21 +00:00
}
static void wintw_set_raw_mouse_mode_pointer(TermWin *tw, bool activate)
{
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
WinGuiSeat *wgs = container_of(tw, WinGuiSeat, termwin);
wgs->pointer_indicates_raw_mouse = activate;
update_mouse_pointer(wgs);
Wez Furlong's patch to add xterm mouse reporting and proper mouse wheel support. [originally from svn r1097]
2001-05-06 14:20:41 +00:00
}
Prevent network errors from summarily closing the window when CoE is off [originally from svn r613]
2000-09-22 11:04:57 +00:00
/*
* Print a message box and close the connection.
*/
New abstraction 'Seat', to pass to backends. This is a new vtable-based abstraction which is passed to a backend in place of Frontend, and it implements only the subset of the Frontend functions needed by a backend. (Many other Frontend functions still exist, notably the wide range of things called by terminal.c providing platform-independent operations on the GUI terminal window.) The purpose of making it a vtable is that this opens up the possibility of creating a backend as an internal implementation detail of some other activity, by providing just that one backend with a custom Seat that implements the methods differently. For example, this refactoring should make it feasible to directly implement an SSH proxy type, aka the 'jump host' feature supported by OpenSSH, aka 'open a secondary SSH session in MAINCHAN_DIRECT_TCP mode, and then expose the main channel of that as the Socket for the primary connection'. (Which of course you can already do by spawning 'plink -nc' as a separate proxy process, but this would permit it in the _same_ process without anything getting confused.) I've centralised a full set of stub methods in misc.c for the new abstraction, which allows me to get rid of several annoying stubs in the previous code. Also, while I'm here, I've moved a lot of duplicated modalfatalbox() type functions from application main program files into wincons.c / uxcons.c, which I think saves duplication overall. (A minor visible effect is that the prefixes on those console-based fatal error messages will now be more consistent between applications.)
2018-10-11 18:58:42 +00:00
static void win_seat_connection_fatal(Seat *seat, const char *msg)
Run entire source base through GNU indent to tidy up the varying coding styles of the various contributors! Woohoo! [originally from svn r1098]
2001-05-06 14:35:20 +00:00
{
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
WinGuiSeat *wgs = container_of(seat, WinGuiSeat, seat);
Remove a load of obsolete printf string limits. In the previous commit I happened to notice a %.150s in a ppl_logevent call, which was probably an important safety precaution a couple of decades ago when that format string was being used for an sprintf into a fixed-size buffer, but now it's just pointless cruft. This commit removes all printf string formatting directives with a compile-time fixed size, with the one exception of a %.3s used to cut out a 3-letter month name in scpserver.c. In cases where the format string in question was already going to an arbitrary-length function like dupprintf or ppl_logevent, that's all I've done; in cases where there was still a fixed-size buffer, I've replaced it with a dynamic buffer and dupprintf.
2018-12-08 21:03:51 +00:00
char *title = dupprintf("%s Fatal Error", appname);
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
show_mouseptr(wgs, true);
MessageBox(wgs->term_hwnd, msg, title, MB_ICONERROR | MB_OK);
Remove a load of obsolete printf string limits. In the previous commit I happened to notice a %.150s in a ppl_logevent call, which was probably an important safety precaution a couple of decades ago when that format string was being used for an sprintf into a fixed-size buffer, but now it's just pointless cruft. This commit removes all printf string formatting directives with a compile-time fixed size, with the one exception of a %.3s used to cut out a 3-letter month name in scpserver.c. In cases where the format string in question was already going to an arbitrary-length function like dupprintf or ppl_logevent, that's all I've done; in cases where there was still a fixed-size buffer, I've replaced it with a dynamic buffer and dupprintf.
2018-12-08 21:03:51 +00:00
sfree(title);
Colin's and my fixes to connection_fatal(). [originally from svn r3161]
2003-05-04 14:14:10 +00:00
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
if (conf_get_int(wgs->conf, CONF_close_on_exit) == FORCE_ON)
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
PostQuitMessage(1);
Prevent network errors from summarily closing the window when CoE is off [originally from svn r613]
2000-09-22 11:04:57 +00:00
else {
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
queue_toplevel_callback(close_session, wgs);
Prevent network errors from summarily closing the window when CoE is off [originally from svn r613]
2000-09-22 11:04:57 +00:00
}
}
New Seat method, seat_nonfatal(). This is like the seat-independent nonfatal(), but specifies a Seat, which allows the GUI dialog box to have the right terminal window as its parent (if there are multiple ones). Changed over all the nonfatal() calls in the code base that could be localised to a Seat, which means all the ones that come up if something goes horribly wrong in host key storage. To make that possible, I've added a 'seat' parameter to store_host_key(); it turns out that all its call sites had one available already.
2022-09-13 07:49:38 +00:00
/*
* Print a message box and don't close the connection.
*/
static void win_seat_nonfatal(Seat *seat, const char *msg)
{
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
WinGuiSeat *wgs = container_of(seat, WinGuiSeat, seat);
New Seat method, seat_nonfatal(). This is like the seat-independent nonfatal(), but specifies a Seat, which allows the GUI dialog box to have the right terminal window as its parent (if there are multiple ones). Changed over all the nonfatal() calls in the code base that could be localised to a Seat, which means all the ones that come up if something goes horribly wrong in host key storage. To make that possible, I've added a 'seat' parameter to store_host_key(); it turns out that all its call sites had one available already.
2022-09-13 07:49:38 +00:00
char *title = dupprintf("%s Error", appname);
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
show_mouseptr(wgs, true);
MessageBox(wgs->term_hwnd, msg, title, MB_ICONERROR | MB_OK);
New Seat method, seat_nonfatal(). This is like the seat-independent nonfatal(), but specifies a Seat, which allows the GUI dialog box to have the right terminal window as its parent (if there are multiple ones). Changed over all the nonfatal() calls in the code base that could be localised to a Seat, which means all the ones that come up if something goes horribly wrong in host key storage. To make that possible, I've added a 'seat' parameter to store_host_key(); it turns out that all its call sites had one available already.
2022-09-13 07:49:38 +00:00
sfree(title);
}
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
static HWND find_window_for_msgbox(void)
{
if (wgslisthead.next != &wgslisthead) {
WinGuiSeat *wgs = container_of(
wgslisthead.next, WinGuiSeat, wgslistnode);
return wgs->term_hwnd;
}
return NULL;
}
Revamp of command-line handling. Most command line options should now be processed in cmdline.c, which is called from all utilities (well, not Pageant or PuTTYgen). This should mean we get to standardise almost all options across almost all tools. Also one major change: `-load' is now the preferred option for loading a saved session in PuTTY proper. `@session' still works but is deprecated. [originally from svn r1799]
2002-08-04 21:18:56 +00:00
/*
* Report an error at the command-line parsing stage.
*/
Giant const-correctness patch of doom! Having found a lot of unfixed constness issues in recent development, I thought perhaps it was time to get proactive, so I compiled the whole codebase with -Wwrite-strings. That turned up a huge load of const problems, which I've fixed in this commit: the Unix build now goes cleanly through with -Wwrite-strings, and the Windows build is as close as I could get it (there are some lingering issues due to occasional Windows API functions like AcquireCredentialsHandle not having the right constness). Notable fallout beyond the purely mechanical changing of types: - the stuff saved by cmdline_save_param() is now explicitly dupstr()ed, and freed in cmdline_run_saved. - I couldn't make both string arguments to cmdline_process_param() const, because it intentionally writes to one of them in the case where it's the argument to -pw (in the vain hope of being at least slightly friendly to 'ps'), so elsewhere I had to temporarily dupstr() something for the sake of passing it to that function - I had to invent a silly parallel version of const_cmp() so I could pass const string literals in to lookup functions. - stripslashes() in pscp.c and psftp.c has the annoying strchr nature
2015-05-15 10:15:42 +00:00
void cmdline_error(const char *fmt, ...)
Revamp of command-line handling. Most command line options should now be processed in cmdline.c, which is called from all utilities (well, not Pageant or PuTTYgen). This should mean we get to standardise almost all options across almost all tools. Also one major change: `-load' is now the preferred option for loading a saved session in PuTTY proper. `@session' still works but is deprecated. [originally from svn r1799]
2002-08-04 21:18:56 +00:00
{
va_list ap;
Remove a load of obsolete printf string limits. In the previous commit I happened to notice a %.150s in a ppl_logevent call, which was probably an important safety precaution a couple of decades ago when that format string was being used for an sprintf into a fixed-size buffer, but now it's just pointless cruft. This commit removes all printf string formatting directives with a compile-time fixed size, with the one exception of a %.3s used to cut out a 3-letter month name in scpserver.c. In cases where the format string in question was already going to an arbitrary-length function like dupprintf or ppl_logevent, that's all I've done; in cases where there was still a fixed-size buffer, I've replaced it with a dynamic buffer and dupprintf.
2018-12-08 21:03:51 +00:00
char *message, *title;
Revamp of command-line handling. Most command line options should now be processed in cmdline.c, which is called from all utilities (well, not Pageant or PuTTYgen). This should mean we get to standardise almost all options across almost all tools. Also one major change: `-load' is now the preferred option for loading a saved session in PuTTY proper. `@session' still works but is deprecated. [originally from svn r1799]
2002-08-04 21:18:56 +00:00
va_start(ap, fmt);
Remove a load of obsolete printf string limits. In the previous commit I happened to notice a %.150s in a ppl_logevent call, which was probably an important safety precaution a couple of decades ago when that format string was being used for an sprintf into a fixed-size buffer, but now it's just pointless cruft. This commit removes all printf string formatting directives with a compile-time fixed size, with the one exception of a %.3s used to cut out a 3-letter month name in scpserver.c. In cases where the format string in question was already going to an arbitrary-length function like dupprintf or ppl_logevent, that's all I've done; in cases where there was still a fixed-size buffer, I've replaced it with a dynamic buffer and dupprintf.
2018-12-08 21:03:51 +00:00
message = dupvprintf(fmt, ap);
Revamp of command-line handling. Most command line options should now be processed in cmdline.c, which is called from all utilities (well, not Pageant or PuTTYgen). This should mean we get to standardise almost all options across almost all tools. Also one major change: `-load' is now the preferred option for loading a saved session in PuTTY proper. `@session' still works but is deprecated. [originally from svn r1799]
2002-08-04 21:18:56 +00:00
va_end(ap);
Remove a load of obsolete printf string limits. In the previous commit I happened to notice a %.150s in a ppl_logevent call, which was probably an important safety precaution a couple of decades ago when that format string was being used for an sprintf into a fixed-size buffer, but now it's just pointless cruft. This commit removes all printf string formatting directives with a compile-time fixed size, with the one exception of a %.3s used to cut out a 3-letter month name in scpserver.c. In cases where the format string in question was already going to an arbitrary-length function like dupprintf or ppl_logevent, that's all I've done; in cases where there was still a fixed-size buffer, I've replaced it with a dynamic buffer and dupprintf.
2018-12-08 21:03:51 +00:00
title = dupprintf("%s Command Line Error", appname);
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
MessageBox(find_window_for_msgbox(), message, title, MB_ICONERROR | MB_OK);
Remove a load of obsolete printf string limits. In the previous commit I happened to notice a %.150s in a ppl_logevent call, which was probably an important safety precaution a couple of decades ago when that format string was being used for an sprintf into a fixed-size buffer, but now it's just pointless cruft. This commit removes all printf string formatting directives with a compile-time fixed size, with the one exception of a %.3s used to cut out a 3-letter month name in scpserver.c. In cases where the format string in question was already going to an arbitrary-length function like dupprintf or ppl_logevent, that's all I've done; in cases where there was still a fixed-size buffer, I've replaced it with a dynamic buffer and dupprintf.
2018-12-08 21:03:51 +00:00
sfree(message);
sfree(title);
Revamp of command-line handling. Most command line options should now be processed in cmdline.c, which is called from all utilities (well, not Pageant or PuTTYgen). This should mean we get to standardise almost all options across almost all tools. Also one major change: `-load' is now the preferred option for loading a saved session in PuTTY proper. `@session' still works but is deprecated. [originally from svn r1799]
2002-08-04 21:18:56 +00:00
exit(1);
}
Centralise palette setup into terminal.c. Now terminal.c makes nearly all the decisions about what the colour palette should actually contain: it does the job of reading the GUI-configurable colours out of Conf, and also the job of making up the rest of the xterm-256 palette. The only exception is that TermWin can provide a method to override some of the default colours, which on Windows is used to implement the 'Use system colours' config option. This saves code overall, partly because the front ends don't have to be able to send palette data back to the Terminal any more (the Terminal keeps the master copy and can answer palette-query escape sequences from its own knowledge), and also because now there's only one copy of the xterm-256 palette setup code (previously gtkwin.c and window.c each had their own version of it). In this rewrite, I've also introduced a multi-layered storage system for the palette data in Terminal. One layer contains the palette information derived from Conf; the next contains platform overrides (currently just Windows's 'Use system colours'); the last one contains overrides set by escape sequences in the middle of the session. The topmost two layers can each _conditionally_ override the ones below. As a result, if a server-side application manually resets (say) the default fg and bg colours in mid-session to something that works well in a particular application, those changes won't be wiped out by a change in the Windows system colours or the Conf, which they would have been before. Instead, changes in Conf or the system colours alter the lower layers of the structure, but then when palette_rebuild is called, the upper layer continues to override them, until a palette reset (ESC]R) or terminal reset (e.g. ESC c) removes those upper-layer changes. This seems like a more consistent strategy, in that the same set of configuration settings will produce the same end result regardless of what order they were applied in. The palette-related methods in TermWin have had a total rework. palette_get and palette_reset are both gone; palette_set can now set a contiguous range of colours in one go; and the new palette_get_overrides replaces window.c's old systopalette().
2021-02-07 19:59:21 +00:00
static inline rgb rgb_from_colorref(COLORREF cr)
Run entire source base through GNU indent to tidy up the varying coding styles of the various contributors! Woohoo! [originally from svn r1098]
2001-05-06 14:35:20 +00:00
{
Centralise palette setup into terminal.c. Now terminal.c makes nearly all the decisions about what the colour palette should actually contain: it does the job of reading the GUI-configurable colours out of Conf, and also the job of making up the rest of the xterm-256 palette. The only exception is that TermWin can provide a method to override some of the default colours, which on Windows is used to implement the 'Use system colours' config option. This saves code overall, partly because the front ends don't have to be able to send palette data back to the Terminal any more (the Terminal keeps the master copy and can answer palette-query escape sequences from its own knowledge), and also because now there's only one copy of the xterm-256 palette setup code (previously gtkwin.c and window.c each had their own version of it). In this rewrite, I've also introduced a multi-layered storage system for the palette data in Terminal. One layer contains the palette information derived from Conf; the next contains platform overrides (currently just Windows's 'Use system colours'); the last one contains overrides set by escape sequences in the middle of the session. The topmost two layers can each _conditionally_ override the ones below. As a result, if a server-side application manually resets (say) the default fg and bg colours in mid-session to something that works well in a particular application, those changes won't be wiped out by a change in the Windows system colours or the Conf, which they would have been before. Instead, changes in Conf or the system colours alter the lower layers of the structure, but then when palette_rebuild is called, the upper layer continues to override them, until a palette reset (ESC]R) or terminal reset (e.g. ESC c) removes those upper-layer changes. This seems like a more consistent strategy, in that the same set of configuration settings will produce the same end result regardless of what order they were applied in. The palette-related methods in TermWin have had a total rework. palette_get and palette_reset are both gone; palette_set can now set a contiguous range of colours in one go; and the new palette_get_overrides replaces window.c's old systopalette().
2021-02-07 19:59:21 +00:00
rgb toret;
toret.r = GetRValue(cr);
toret.g = GetGValue(cr);
toret.b = GetBValue(cr);
return toret;
Implement `default-colours' on Windows based loosely on Michael Wardle's patch. [originally from svn r3444]
2003-09-03 20:14:38 +00:00
}
Make TermWin's palette_get_overrides() take a Terminal *. Less than 12 hours after 0.75 went out of the door, a user pointed out that enabling the 'Use system colours' config option causes an immediate NULL-dereference crash. The reason is because a chain of calls from term_init() ends up calling back to the Windows implementation of the palette_get_overrides() method, which responds by trying to call functions on the static variable 'term' in window.c, which won't be initialised until term_init() has returned. Simple fix: palette_get_overrides() is now given a pointer to the Terminal that it should be updating, because it can't find it out any other way.
2021-05-08 17:13:06 +00:00
static void wintw_palette_get_overrides(TermWin *tw, Terminal *term)
Implement `default-colours' on Windows based loosely on Michael Wardle's patch. [originally from svn r3444]
2003-09-03 20:14:38 +00:00
{
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
WinGuiSeat *wgs = container_of(tw, WinGuiSeat, termwin);
if (conf_get_bool(wgs->conf, CONF_system_colour)) {
Centralise palette setup into terminal.c. Now terminal.c makes nearly all the decisions about what the colour palette should actually contain: it does the job of reading the GUI-configurable colours out of Conf, and also the job of making up the rest of the xterm-256 palette. The only exception is that TermWin can provide a method to override some of the default colours, which on Windows is used to implement the 'Use system colours' config option. This saves code overall, partly because the front ends don't have to be able to send palette data back to the Terminal any more (the Terminal keeps the master copy and can answer palette-query escape sequences from its own knowledge), and also because now there's only one copy of the xterm-256 palette setup code (previously gtkwin.c and window.c each had their own version of it). In this rewrite, I've also introduced a multi-layered storage system for the palette data in Terminal. One layer contains the palette information derived from Conf; the next contains platform overrides (currently just Windows's 'Use system colours'); the last one contains overrides set by escape sequences in the middle of the session. The topmost two layers can each _conditionally_ override the ones below. As a result, if a server-side application manually resets (say) the default fg and bg colours in mid-session to something that works well in a particular application, those changes won't be wiped out by a change in the Windows system colours or the Conf, which they would have been before. Instead, changes in Conf or the system colours alter the lower layers of the structure, but then when palette_rebuild is called, the upper layer continues to override them, until a palette reset (ESC]R) or terminal reset (e.g. ESC c) removes those upper-layer changes. This seems like a more consistent strategy, in that the same set of configuration settings will produce the same end result regardless of what order they were applied in. The palette-related methods in TermWin have had a total rework. palette_get and palette_reset are both gone; palette_set can now set a contiguous range of colours in one go; and the new palette_get_overrides replaces window.c's old systopalette().
2021-02-07 19:59:21 +00:00
rgb rgb;
Initial checkin: beta 0.43 [originally from svn r11]
1999-01-08 13:02:13 +00:00
Centralise palette setup into terminal.c. Now terminal.c makes nearly all the decisions about what the colour palette should actually contain: it does the job of reading the GUI-configurable colours out of Conf, and also the job of making up the rest of the xterm-256 palette. The only exception is that TermWin can provide a method to override some of the default colours, which on Windows is used to implement the 'Use system colours' config option. This saves code overall, partly because the front ends don't have to be able to send palette data back to the Terminal any more (the Terminal keeps the master copy and can answer palette-query escape sequences from its own knowledge), and also because now there's only one copy of the xterm-256 palette setup code (previously gtkwin.c and window.c each had their own version of it). In this rewrite, I've also introduced a multi-layered storage system for the palette data in Terminal. One layer contains the palette information derived from Conf; the next contains platform overrides (currently just Windows's 'Use system colours'); the last one contains overrides set by escape sequences in the middle of the session. The topmost two layers can each _conditionally_ override the ones below. As a result, if a server-side application manually resets (say) the default fg and bg colours in mid-session to something that works well in a particular application, those changes won't be wiped out by a change in the Windows system colours or the Conf, which they would have been before. Instead, changes in Conf or the system colours alter the lower layers of the structure, but then when palette_rebuild is called, the upper layer continues to override them, until a palette reset (ESC]R) or terminal reset (e.g. ESC c) removes those upper-layer changes. This seems like a more consistent strategy, in that the same set of configuration settings will produce the same end result regardless of what order they were applied in. The palette-related methods in TermWin have had a total rework. palette_get and palette_reset are both gone; palette_set can now set a contiguous range of colours in one go; and the new palette_get_overrides replaces window.c's old systopalette().
2021-02-07 19:59:21 +00:00
rgb = rgb_from_colorref(GetSysColor(COLOR_WINDOWTEXT));
term_palette_override(term, OSC4_COLOUR_fg, rgb);
term_palette_override(term, OSC4_COLOUR_fg_bold, rgb);
Support OSC 4 terminal colour-palette queries. Markus Gans points out that some applications which (not at all unreasonably) don't trust $TERM to tell them the full capabilities of their terminal will use the sequence "OSC 4 ; nn ; ? BEL" to ask for the colour-palette value in position nn, and they may not particularly care _what_ the results are but they will use them to decide whether the right number of colour palette entries even exist.
2017-10-05 19:43:02 +00:00
Centralise palette setup into terminal.c. Now terminal.c makes nearly all the decisions about what the colour palette should actually contain: it does the job of reading the GUI-configurable colours out of Conf, and also the job of making up the rest of the xterm-256 palette. The only exception is that TermWin can provide a method to override some of the default colours, which on Windows is used to implement the 'Use system colours' config option. This saves code overall, partly because the front ends don't have to be able to send palette data back to the Terminal any more (the Terminal keeps the master copy and can answer palette-query escape sequences from its own knowledge), and also because now there's only one copy of the xterm-256 palette setup code (previously gtkwin.c and window.c each had their own version of it). In this rewrite, I've also introduced a multi-layered storage system for the palette data in Terminal. One layer contains the palette information derived from Conf; the next contains platform overrides (currently just Windows's 'Use system colours'); the last one contains overrides set by escape sequences in the middle of the session. The topmost two layers can each _conditionally_ override the ones below. As a result, if a server-side application manually resets (say) the default fg and bg colours in mid-session to something that works well in a particular application, those changes won't be wiped out by a change in the Windows system colours or the Conf, which they would have been before. Instead, changes in Conf or the system colours alter the lower layers of the structure, but then when palette_rebuild is called, the upper layer continues to override them, until a palette reset (ESC]R) or terminal reset (e.g. ESC c) removes those upper-layer changes. This seems like a more consistent strategy, in that the same set of configuration settings will produce the same end result regardless of what order they were applied in. The palette-related methods in TermWin have had a total rework. palette_get and palette_reset are both gone; palette_set can now set a contiguous range of colours in one go; and the new palette_get_overrides replaces window.c's old systopalette().
2021-02-07 19:59:21 +00:00
rgb = rgb_from_colorref(GetSysColor(COLOR_WINDOW));
term_palette_override(term, OSC4_COLOUR_bg, rgb);
term_palette_override(term, OSC4_COLOUR_bg_bold, rgb);
rgb = rgb_from_colorref(GetSysColor(COLOR_HIGHLIGHTTEXT));
term_palette_override(term, OSC4_COLOUR_cursor_fg, rgb);
rgb = rgb_from_colorref(GetSysColor(COLOR_HIGHLIGHT));
term_palette_override(term, OSC4_COLOUR_cursor_bg, rgb);
Initial checkin: beta 0.43 [originally from svn r11]
1999-01-08 13:02:13 +00:00
}
}
At last! After much delay, much faffing back and forth, and much enhancement and fiddling, I have now massaged Arabeyes' first patch into a form I'm happy to check in. Phew. [originally from svn r4236]
2004-05-22 10:36:50 +00:00
/*
* This is a wrapper to ExtTextOut() to force Windows to display
* the precise glyphs we give it. Otherwise it would do its own
* bidi and Arabic shaping, and we would end up uncertain which
* characters it had put where.
*/
static void exact_textout(HDC hdc, int x, int y, CONST RECT *lprc,
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
unsigned short *lpString, UINT cbCount,
CONST INT *lpDx, bool opaque)
At last! After much delay, much faffing back and forth, and much enhancement and fiddling, I have now massaged Arabeyes' first patch into a form I'm happy to check in. Phew. [originally from svn r4236]
2004-05-22 10:36:50 +00:00
{
Replace mkfiles.pl with a CMake build system. This brings various concrete advantages over the previous system: - consistent support for out-of-tree builds on all platforms - more thorough support for Visual Studio IDE project files - support for Ninja-based builds, which is particularly useful on Windows where the alternative nmake has no parallel option - a really simple set of build instructions that work the same way on all the major platforms (look how much shorter README is!) - better decoupling of the project configuration from the toolchain configuration, so that my Windows cross-building doesn't need (much) special treatment in CMakeLists.txt - configure-time tests on Windows as well as Linux, so that a lot of ad-hoc #ifdefs second-guessing a particular feature's presence from the compiler version can now be replaced by tests of the feature itself Also some longer-term software-engineering advantages: - other people have actually heard of CMake, so they'll be able to produce patches to the new build setup more easily - unlike the old mkfiles.pl, CMake is not my personal problem to maintain - most importantly, mkfiles.pl was just a horrible pile of unmaintainable cruft, which even I found it painful to make changes to or to use, and desperately needed throwing in the bin. I've already thrown away all the variants of it I had in other projects of mine, and was only delaying this one so we could make the 0.75 release branch first. This change comes with a noticeable build-level restructuring. The previous Recipe worked by compiling every object file exactly once, and then making each executable by linking a precisely specified subset of the same object files. But in CMake, that's not the natural way to work - if you write the obvious command that puts the same source file into two executable targets, CMake generates a makefile that compiles it once per target. That can be an advantage, because it gives you the freedom to compile it differently in each case (e.g. with a #define telling it which program it's part of). But in a project that has many executable targets and had carefully contrived to _never_ need to build any module more than once, all it does is bloat the build time pointlessly! To avoid slowing down the build by a large factor, I've put most of the modules of the code base into a collection of static libraries organised vaguely thematically (SSH, other backends, crypto, network, ...). That means all those modules can still be compiled just once each, because once each library is built it's reused unchanged for all the executable targets. One upside of this library-based structure is that now I don't have to manually specify exactly which objects go into which programs any more - it's enough to specify which libraries are needed, and the linker will figure out the fine detail automatically. So there's less maintenance to do in CMakeLists.txt when the source code changes. But that reorganisation also adds fragility, because of the trad Unix linker semantics of walking along the library list once each, so that cyclic references between your libraries will provoke link errors. The current setup builds successfully, but I suspect it only just manages it. (In particular, I've found that MinGW is the most finicky on this score of the Windows compilers I've tried building with. So I've included a MinGW test build in the new-look Buildscr, because otherwise I think there'd be a significant risk of introducing MinGW-only build failures due to library search order, which wasn't a risk in the previous library-free build organisation.) In the longer term I hope to be able to reduce the risk of that, via gradual reorganisation (in particular, breaking up too-monolithic modules, to reduce the risk of knock-on references when you included a module for function A and it also contains function B with an unsatisfied dependency you didn't really need). Ideally I want to reach a state in which the libraries all have sensibly described purposes, a clearly documented (partial) order in which they're permitted to depend on each other, and a specification of what stubs you have to put where if you're leaving one of them out (e.g. nocrypto) and what callbacks you have to define in your non-library objects to satisfy dependencies from things low in the stack (e.g. out_of_memory()). One thing that's gone completely missing in this migration, unfortunately, is the unfinished MacOS port linked against Quartz GTK. That's because it turned out that I can't currently build it myself, on my own Mac: my previous installation of GTK had bit-rotted as a side effect of an Xcode upgrade, and I haven't yet been able to persuade jhbuild to make me a new one. So I can't even build the MacOS port with the _old_ makefiles, and hence, I have no way of checking that the new ones also work. I hope to bring that port back to life at some point, but I don't want it to block the rest of this change.
2021-04-10 14:21:11 +00:00
#if HAVE_GCP_RESULTSW
GCP_RESULTSW gcpr;
#else
Further fix for lcc-win32. The PuTTY suite now compiles fine for me using lcc-win32 v3.8 (compilation date Mar 2 2005 18:40:17) provided I pass COMPAT="-DNO_IPV6 -DNO_MULTIMON" on the command line. [originally from svn r5573]
2005-03-30 19:33:24 +00:00
/*
Replace mkfiles.pl with a CMake build system. This brings various concrete advantages over the previous system: - consistent support for out-of-tree builds on all platforms - more thorough support for Visual Studio IDE project files - support for Ninja-based builds, which is particularly useful on Windows where the alternative nmake has no parallel option - a really simple set of build instructions that work the same way on all the major platforms (look how much shorter README is!) - better decoupling of the project configuration from the toolchain configuration, so that my Windows cross-building doesn't need (much) special treatment in CMakeLists.txt - configure-time tests on Windows as well as Linux, so that a lot of ad-hoc #ifdefs second-guessing a particular feature's presence from the compiler version can now be replaced by tests of the feature itself Also some longer-term software-engineering advantages: - other people have actually heard of CMake, so they'll be able to produce patches to the new build setup more easily - unlike the old mkfiles.pl, CMake is not my personal problem to maintain - most importantly, mkfiles.pl was just a horrible pile of unmaintainable cruft, which even I found it painful to make changes to or to use, and desperately needed throwing in the bin. I've already thrown away all the variants of it I had in other projects of mine, and was only delaying this one so we could make the 0.75 release branch first. This change comes with a noticeable build-level restructuring. The previous Recipe worked by compiling every object file exactly once, and then making each executable by linking a precisely specified subset of the same object files. But in CMake, that's not the natural way to work - if you write the obvious command that puts the same source file into two executable targets, CMake generates a makefile that compiles it once per target. That can be an advantage, because it gives you the freedom to compile it differently in each case (e.g. with a #define telling it which program it's part of). But in a project that has many executable targets and had carefully contrived to _never_ need to build any module more than once, all it does is bloat the build time pointlessly! To avoid slowing down the build by a large factor, I've put most of the modules of the code base into a collection of static libraries organised vaguely thematically (SSH, other backends, crypto, network, ...). That means all those modules can still be compiled just once each, because once each library is built it's reused unchanged for all the executable targets. One upside of this library-based structure is that now I don't have to manually specify exactly which objects go into which programs any more - it's enough to specify which libraries are needed, and the linker will figure out the fine detail automatically. So there's less maintenance to do in CMakeLists.txt when the source code changes. But that reorganisation also adds fragility, because of the trad Unix linker semantics of walking along the library list once each, so that cyclic references between your libraries will provoke link errors. The current setup builds successfully, but I suspect it only just manages it. (In particular, I've found that MinGW is the most finicky on this score of the Windows compilers I've tried building with. So I've included a MinGW test build in the new-look Buildscr, because otherwise I think there'd be a significant risk of introducing MinGW-only build failures due to library search order, which wasn't a risk in the previous library-free build organisation.) In the longer term I hope to be able to reduce the risk of that, via gradual reorganisation (in particular, breaking up too-monolithic modules, to reduce the risk of knock-on references when you included a module for function A and it also contains function B with an unsatisfied dependency you didn't really need). Ideally I want to reach a state in which the libraries all have sensibly described purposes, a clearly documented (partial) order in which they're permitted to depend on each other, and a specification of what stubs you have to put where if you're leaving one of them out (e.g. nocrypto) and what callbacks you have to define in your non-library objects to satisfy dependencies from things low in the stack (e.g. out_of_memory()). One thing that's gone completely missing in this migration, unfortunately, is the unfinished MacOS port linked against Quartz GTK. That's because it turned out that I can't currently build it myself, on my own Mac: my previous installation of GTK had bit-rotted as a side effect of an Xcode upgrade, and I haven't yet been able to persuade jhbuild to make me a new one. So I can't even build the MacOS port with the _old_ makefiles, and hence, I have no way of checking that the new ones also work. I hope to bring that port back to life at some point, but I don't want it to block the rest of this change.
2021-04-10 14:21:11 +00:00
* If building against old enough headers that the GCP_RESULTSW
* type isn't available, we can make do with GCP_RESULTS proper:
* the differences aren't important to us (the only variable-width
* string parameter is one we don't use anyway).
Further fix for lcc-win32. The PuTTY suite now compiles fine for me using lcc-win32 v3.8 (compilation date Mar 2 2005 18:40:17) provided I pass COMPAT="-DNO_IPV6 -DNO_MULTIMON" on the command line. [originally from svn r5573]
2005-03-30 19:33:24 +00:00
*/
GCP_RESULTS gcpr;
#endif
At last! After much delay, much faffing back and forth, and much enhancement and fiddling, I have now massaged Arabeyes' first patch into a form I'm happy to check in. Phew. [originally from svn r4236]
2004-05-22 10:36:50 +00:00
char *buffer = snewn(cbCount*2+2, char);
char *classbuffer = snewn(cbCount, char);
memset(&gcpr, 0, sizeof(gcpr));
memset(buffer, 0, cbCount*2+2);
memset(classbuffer, GCPCLASS_NEUTRAL, cbCount);
gcpr.lStructSize = sizeof(gcpr);
gcpr.lpGlyphs = (void *)buffer;
According to Frank Dijcks, this cast makes OpenWatcom happier. [originally from svn r7089]
2007-01-10 00:46:45 +00:00
gcpr.lpClass = (void *)classbuffer;
At last! After much delay, much faffing back and forth, and much enhancement and fiddling, I have now massaged Arabeyes' first patch into a form I'm happy to check in. Phew. [originally from svn r4236]
2004-05-22 10:36:50 +00:00
gcpr.nGlyphs = cbCount;
GetCharacterPlacementW(hdc, lpString, cbCount, 0, &gcpr,
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
FLI_MASK | GCP_CLASSIN | GCP_DIACRITIC);
At last! After much delay, much faffing back and forth, and much enhancement and fiddling, I have now massaged Arabeyes' first patch into a form I'm happy to check in. Phew. [originally from svn r4236]
2004-05-22 10:36:50 +00:00
First-stage support for Unicode combining characters. The `chars' array of each `termline' structure now contains optional additional entries after the normal number of columns, which are used to chain a linked list of combining characters off any primary termchar that needs it. This means we support arbitrarily many combining characters per cell (unlike xterm's hard limit of 2). Cut and paste works correctly (selecting a character cell containing multiple code points causes all those code points to be cut and pasted). Display works by simply overlaying all the relevant characters on top of one another; this is good enough for Unix (xterm does the same thing), and mostly seems OK for Windows except that the Windows Unicode fonts have a nasty habit of not containing most of the combining characters and thus overlaying an unknown-code-point box on your perfectly good base glyph. I had no idea how to add support in the Mac do_text(), so I've simply stuck in an assertion that will trigger the first time a combining character is displayed, and hopefully this will bite someone with the clue to fix it. [originally from svn r4622]
2004-10-14 16:42:43 +00:00
ExtTextOut(hdc, x, y,
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
ETO_GLYPH_INDEX | ETO_CLIPPED | (opaque ? ETO_OPAQUE : 0),
lprc, buffer, cbCount, lpDx);
At last! After much delay, much faffing back and forth, and much enhancement and fiddling, I have now massaged Arabeyes' first patch into a form I'm happy to check in. Phew. [originally from svn r4236]
2004-05-22 10:36:50 +00:00
}
Reinstate as much of the Windows font-linking behaviour as I can easily manage, by adopting a hybrid approach to Unicode text display. The old approach of simply calling ExtTextOutW provided font linking without us having to lift a finger, but didn't do the right thing when it came to bidirectional or Arabic-shaped text. Arabeyes' replacement exact_textout() supported the latter, but turned out to break the former (with no warning from the Windows API documentation, so it's not their fault). So now I've got a second wrapper layer called general_textout(), which splits the input string into substrings based on bidi character class. Any character liable to cause bidi or shaping behaviour if fed straight to ExtTextOutW is instead fed through Arabeyes' exact_textout(), but the rest is fed straight to ExtTextOutW as it used to be. The effect appears to be that font linking is restored for all characters _except_ Arabic and other bidi scripts, which means in particular that we are no longer in a state of regression over 0.57. (0.57 would have done font linking on Arabic as well, but would also have misbidied it, so we've merely exchanged one failure mode for another slightly less harmful one in that situation.) [originally from svn r6910]
2006-11-18 15:10:48 +00:00
/*
* The exact_textout() wrapper, unfortunately, destroys the useful
* Windows `font linking' behaviour: automatic handling of Unicode
* code points not supported in this font by falling back to a font
* which does contain them. Therefore, we adopt a multi-layered
* approach: for any potentially-bidi text, we use exact_textout(),
* and for everything else we use a simple ExtTextOut as we did
* before exact_textout() was introduced.
*/
windows/window.c: move more variables into WinGuiSeat. In commit f9e572595bb8cb6 I claimed that I'd removed very nearly all the global and static variables from windows/window.c. It turns out that this was wildly overoptimistic - I missed quite a few of them! I'm not quite sure how I managed that; my best guess is that I used an underpowered 'nm' command that failed to find some classes of variable. Some of the remaining function-scope statics were removed completely by commit afb3dab1e97a09f just now. In this commit, I've swept up some more and turn them into fields of WinGuiSeat, where they should have been moved last September. The (hopefully complete this time) list of remaining variables, generated by running this rune in the Windows build directory: nm windows/CMakeFiles/putty.dir/window.c.obj | grep -E '^([^ ]+)? *[bBcCdDgGsS] [^\.]' consists of the following variables which are legitimately global across the whole process and not related to a particular window: - 'hinst' and 'hprev', instance handles for Windows loadable modules - 'classname' in the terminal_window_class_a() and terminal_window_class_w() functions, which allocate a window class reusably - some pointers to Windows API functions retrieved via the DECL_WINDOWS_FUNCTION / GET_WINDOWS_FUNCTION system, such as p_AdjustWindowRectExForDpi and p_FlashWindowEx - some pointers to Windows API functions set up by assigning them at startup to the right one of the ANSI or Unicode version depending on the Windows version, e.g. sw_DefWindowProc and sw_DispatchMessage - 'unicode_window', a boolean flag set at the same time as those sw_Foo function pointers - 'sesslist', storing the last-retrieved version of the saved sessions menu - 'cursor_visible' in show_mouseptr() and 'forced_visible' in update_mouse_pointer(), each of which tracks the cumulative number of times that function has shown or hidden the mouse pointer, so as to manage its effect on the global state updated by ShowCursor - 'trust_icon', loaded from the executable's resources - 'wgslisthead', the list of all active WinGuiSeats - 'wm_mousewheel', the window-message id we use for mouse wheel events and the following which are nothing to do with our code: - '_OptionsStorage' in __local_stdio_printf_options() and __local_stdio_scanf_options(), which I'd never noticed before, but apparently are internal to a standard library header.
2023-05-27 13:59:20 +00:00
static void general_textout(
WinGuiSeat *wgs, HDC hdc, int x, int y, CONST RECT *lprc,
unsigned short *lpString, UINT cbCount, CONST INT *lpDx, bool opaque)
Reinstate as much of the Windows font-linking behaviour as I can easily manage, by adopting a hybrid approach to Unicode text display. The old approach of simply calling ExtTextOutW provided font linking without us having to lift a finger, but didn't do the right thing when it came to bidirectional or Arabic-shaped text. Arabeyes' replacement exact_textout() supported the latter, but turned out to break the former (with no warning from the Windows API documentation, so it's not their fault). So now I've got a second wrapper layer called general_textout(), which splits the input string into substrings based on bidi character class. Any character liable to cause bidi or shaping behaviour if fed straight to ExtTextOutW is instead fed through Arabeyes' exact_textout(), but the rest is fed straight to ExtTextOutW as it used to be. The effect appears to be that font linking is restored for all characters _except_ Arabic and other bidi scripts, which means in particular that we are no longer in a state of regression over 0.57. (0.57 would have done font linking on Arabic as well, but would also have misbidied it, so we've merely exchanged one failure mode for another slightly less harmful one in that situation.) [originally from svn r6910]
2006-11-18 15:10:48 +00:00
{
int i, j, xp, xn;
Convert a lot of 'int' variables to 'bool'. My normal habit these days, in new code, is to treat int and bool as _almost_ completely separate types. I'm still willing to use C's implicit test for zero on an integer (e.g. 'if (!blob.len)' is fine, no need to spell it out as blob.len != 0), but generally, if a variable is going to be conceptually a boolean, I like to declare it bool and assign to it using 'true' or 'false' rather than 0 or 1. PuTTY is an exception, because it predates the C99 bool, and I've stuck to its existing coding style even when adding new code to it. But it's been annoying me more and more, so now that I've decided C99 bool is an acceptable thing to require from our toolchain in the first place, here's a quite thorough trawl through the source doing 'boolification'. Many variables and function parameters are now typed as bool rather than int; many assignments of 0 or 1 to those variables are now spelled 'true' or 'false'. I managed this thorough conversion with the help of a custom clang plugin that I wrote to trawl the AST and apply heuristics to point out where things might want changing. So I've even managed to do a decent job on parts of the code I haven't looked at in years! To make the plugin's work easier, I pushed platform front ends generally in the direction of using standard 'bool' in preference to platform-specific boolean types like Windows BOOL or GTK's gboolean; I've left the platform booleans in places they _have_ to be for the platform APIs to work right, but variables only used by my own code have been converted wherever I found them. In a few places there are int values that look very like booleans in _most_ of the places they're used, but have a rarely-used third value, or a distinction between different nonzero values that most users don't care about. In these cases, I've _removed_ uses of 'true' and 'false' for the return values, to emphasise that there's something more subtle going on than a simple boolean answer: - the 'multisel' field in dialog.h's list box structure, for which the GTK front end in particular recognises a difference between 1 and 2 but nearly everything else treats as boolean - the 'urgent' parameter to plug_receive, where 1 vs 2 tells you something about the specific location of the urgent pointer, but most clients only care about 0 vs 'something nonzero' - the return value of wc_match, where -1 indicates a syntax error in the wildcard. - the return values from SSH-1 RSA-key loading functions, which use -1 for 'wrong passphrase' and 0 for all other failures (so any caller which already knows it's not loading an _encrypted private_ key can treat them as boolean) - term->esc_query, and the 'query' parameter in toggle_mode in terminal.c, which _usually_ hold 0 for ESC[123h or 1 for ESC[?123h, but can also hold -1 for some other intervening character that we don't support. In a few places there's an integer that I haven't turned into a bool even though it really _can_ only take values 0 or 1 (and, as above, tried to make the call sites consistent in not calling those values true and false), on the grounds that I thought it would make it more confusing to imply that the 0 value was in some sense 'negative' or bad and the 1 positive or good: - the return value of plug_accepting uses the POSIXish convention of 0=success and nonzero=error; I think if I made it bool then I'd also want to reverse its sense, and that's a job for a separate piece of work. - the 'screen' parameter to lineptr() in terminal.c, where 0 and 1 represent the default and alternate screens. There's no obvious reason why one of those should be considered 'true' or 'positive' or 'success' - they're just indices - so I've left it as int. ssh_scp_recv had particularly confusing semantics for its previous int return value: its call sites used '<= 0' to check for error, but it never actually returned a negative number, just 0 or 1. Now the function and its call sites agree that it's a bool. In a couple of places I've renamed variables called 'ret', because I don't like that name any more - it's unclear whether it means the return value (in preparation) for the _containing_ function or the return value received from a subroutine call, and occasionally I've accidentally used the same variable for both and introduced a bug. So where one of those got in my way, I've renamed it to 'toret' or 'retd' (the latter short for 'returned') in line with my usual modern practice, but I haven't done a thorough job of finding all of them. Finally, one amusing side effect of doing this is that I've had to separate quite a few chained assignments. It used to be perfectly fine to write 'a = b = c = TRUE' when a,b,c were int and TRUE was just a the 'true' defined by stdbool.h, that idiom provokes a warning from gcc: 'suggest parentheses around assignment used as truth value'!
2018-11-02 19:23:19 +00:00
int bkmode = 0;
bool got_bkmode = false;
Reinstate as much of the Windows font-linking behaviour as I can easily manage, by adopting a hybrid approach to Unicode text display. The old approach of simply calling ExtTextOutW provided font linking without us having to lift a finger, but didn't do the right thing when it came to bidirectional or Arabic-shaped text. Arabeyes' replacement exact_textout() supported the latter, but turned out to break the former (with no warning from the Windows API documentation, so it's not their fault). So now I've got a second wrapper layer called general_textout(), which splits the input string into substrings based on bidi character class. Any character liable to cause bidi or shaping behaviour if fed straight to ExtTextOutW is instead fed through Arabeyes' exact_textout(), but the rest is fed straight to ExtTextOutW as it used to be. The effect appears to be that font linking is restored for all characters _except_ Arabic and other bidi scripts, which means in particular that we are no longer in a state of regression over 0.57. (0.57 would have done font linking on Arabic as well, but would also have misbidied it, so we've merely exchanged one failure mode for another slightly less harmful one in that situation.) [originally from svn r6910]
2006-11-18 15:10:48 +00:00
xp = xn = x;
Get rid of all the MSVC warnings. [originally from svn r7086]
2007-01-09 18:24:07 +00:00
for (i = 0; i < (int)cbCount ;) {
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
bool rtl = is_rtl(lpString[i]);
xn += lpDx[i];
for (j = i+1; j < (int)cbCount; j++) {
if (rtl != is_rtl(lpString[j]))
break;
xn += lpDx[j];
}
/*
* Now [i,j) indicates a maximal substring of lpString
* which should be displayed using the same textout
* function.
*/
if (rtl) {
exact_textout(hdc, xp, y, lprc, lpString+i, j-i,
windows/window.c: move more variables into WinGuiSeat. In commit f9e572595bb8cb6 I claimed that I'd removed very nearly all the global and static variables from windows/window.c. It turns out that this was wildly overoptimistic - I missed quite a few of them! I'm not quite sure how I managed that; my best guess is that I used an underpowered 'nm' command that failed to find some classes of variable. Some of the remaining function-scope statics were removed completely by commit afb3dab1e97a09f just now. In this commit, I've swept up some more and turn them into fields of WinGuiSeat, where they should have been moved last September. The (hopefully complete this time) list of remaining variables, generated by running this rune in the Windows build directory: nm windows/CMakeFiles/putty.dir/window.c.obj | grep -E '^([^ ]+)? *[bBcCdDgGsS] [^\.]' consists of the following variables which are legitimately global across the whole process and not related to a particular window: - 'hinst' and 'hprev', instance handles for Windows loadable modules - 'classname' in the terminal_window_class_a() and terminal_window_class_w() functions, which allocate a window class reusably - some pointers to Windows API functions retrieved via the DECL_WINDOWS_FUNCTION / GET_WINDOWS_FUNCTION system, such as p_AdjustWindowRectExForDpi and p_FlashWindowEx - some pointers to Windows API functions set up by assigning them at startup to the right one of the ANSI or Unicode version depending on the Windows version, e.g. sw_DefWindowProc and sw_DispatchMessage - 'unicode_window', a boolean flag set at the same time as those sw_Foo function pointers - 'sesslist', storing the last-retrieved version of the saved sessions menu - 'cursor_visible' in show_mouseptr() and 'forced_visible' in update_mouse_pointer(), each of which tracks the cumulative number of times that function has shown or hidden the mouse pointer, so as to manage its effect on the global state updated by ShowCursor - 'trust_icon', loaded from the executable's resources - 'wgslisthead', the list of all active WinGuiSeats - 'wm_mousewheel', the window-message id we use for mouse wheel events and the following which are nothing to do with our code: - '_OptionsStorage' in __local_stdio_printf_options() and __local_stdio_scanf_options(), which I'd never noticed before, but apparently are internal to a standard library header.
2023-05-27 13:59:20 +00:00
wgs->font_varpitch ? NULL : lpDx+i, opaque);
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
} else {
ExtTextOutW(hdc, xp, y, ETO_CLIPPED | (opaque ? ETO_OPAQUE : 0),
lprc, lpString+i, j-i,
windows/window.c: move more variables into WinGuiSeat. In commit f9e572595bb8cb6 I claimed that I'd removed very nearly all the global and static variables from windows/window.c. It turns out that this was wildly overoptimistic - I missed quite a few of them! I'm not quite sure how I managed that; my best guess is that I used an underpowered 'nm' command that failed to find some classes of variable. Some of the remaining function-scope statics were removed completely by commit afb3dab1e97a09f just now. In this commit, I've swept up some more and turn them into fields of WinGuiSeat, where they should have been moved last September. The (hopefully complete this time) list of remaining variables, generated by running this rune in the Windows build directory: nm windows/CMakeFiles/putty.dir/window.c.obj | grep -E '^([^ ]+)? *[bBcCdDgGsS] [^\.]' consists of the following variables which are legitimately global across the whole process and not related to a particular window: - 'hinst' and 'hprev', instance handles for Windows loadable modules - 'classname' in the terminal_window_class_a() and terminal_window_class_w() functions, which allocate a window class reusably - some pointers to Windows API functions retrieved via the DECL_WINDOWS_FUNCTION / GET_WINDOWS_FUNCTION system, such as p_AdjustWindowRectExForDpi and p_FlashWindowEx - some pointers to Windows API functions set up by assigning them at startup to the right one of the ANSI or Unicode version depending on the Windows version, e.g. sw_DefWindowProc and sw_DispatchMessage - 'unicode_window', a boolean flag set at the same time as those sw_Foo function pointers - 'sesslist', storing the last-retrieved version of the saved sessions menu - 'cursor_visible' in show_mouseptr() and 'forced_visible' in update_mouse_pointer(), each of which tracks the cumulative number of times that function has shown or hidden the mouse pointer, so as to manage its effect on the global state updated by ShowCursor - 'trust_icon', loaded from the executable's resources - 'wgslisthead', the list of all active WinGuiSeats - 'wm_mousewheel', the window-message id we use for mouse wheel events and the following which are nothing to do with our code: - '_OptionsStorage' in __local_stdio_printf_options() and __local_stdio_scanf_options(), which I'd never noticed before, but apparently are internal to a standard library header.
2023-05-27 13:59:20 +00:00
wgs->font_varpitch ? NULL : lpDx+i);
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
}
Reinstate as much of the Windows font-linking behaviour as I can easily manage, by adopting a hybrid approach to Unicode text display. The old approach of simply calling ExtTextOutW provided font linking without us having to lift a finger, but didn't do the right thing when it came to bidirectional or Arabic-shaped text. Arabeyes' replacement exact_textout() supported the latter, but turned out to break the former (with no warning from the Windows API documentation, so it's not their fault). So now I've got a second wrapper layer called general_textout(), which splits the input string into substrings based on bidi character class. Any character liable to cause bidi or shaping behaviour if fed straight to ExtTextOutW is instead fed through Arabeyes' exact_textout(), but the rest is fed straight to ExtTextOutW as it used to be. The effect appears to be that font linking is restored for all characters _except_ Arabic and other bidi scripts, which means in particular that we are no longer in a state of regression over 0.57. (0.57 would have done font linking on Arabic as well, but would also have misbidied it, so we've merely exchanged one failure mode for another slightly less harmful one in that situation.) [originally from svn r6910]
2006-11-18 15:10:48 +00:00
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
i = j;
xp = xn;
Stop general_textout() from trying to slice up the input clipping rectangle into smaller ones: it doesn't work any more, since the new variable-pitch code can now call general_textout() with a larger clipping rectangle than the text it's meant to be displaying. Instead, general_textout() now uses the same semantics as the next loop up in do_text_internal(): the first piece of text it displays uses the opacity setting passed in, which blanks the entire clipping rectangle if necessary, and then subsequent overlays are non-opaque. And the same clipping rectangle is used throughout. [originally from svn r9067]
2010-12-30 00:06:43 +00:00
bkmode = GetBkMode(hdc);
Adopt C99 <stdbool.h>'s true/false. This commit includes <stdbool.h> from defs.h and deletes my traditional definitions of TRUE and FALSE, but other than that, it's a 100% mechanical search-and-replace transforming all uses of TRUE and FALSE into the C99-standardised lowercase spellings. No actual types are changed in this commit; that will come next. This is just getting the noise out of the way, so that subsequent commits can have a higher proportion of signal.
2018-10-29 19:50:29 +00:00
got_bkmode = true;
Stop general_textout() from trying to slice up the input clipping rectangle into smaller ones: it doesn't work any more, since the new variable-pitch code can now call general_textout() with a larger clipping rectangle than the text it's meant to be displaying. Instead, general_textout() now uses the same semantics as the next loop up in do_text_internal(): the first piece of text it displays uses the opacity setting passed in, which blanks the entire clipping rectangle if necessary, and then subsequent overlays are non-opaque. And the same clipping rectangle is used throughout. [originally from svn r9067]
2010-12-30 00:06:43 +00:00
SetBkMode(hdc, TRANSPARENT);
Adopt C99 <stdbool.h>'s true/false. This commit includes <stdbool.h> from defs.h and deletes my traditional definitions of TRUE and FALSE, but other than that, it's a 100% mechanical search-and-replace transforming all uses of TRUE and FALSE into the C99-standardised lowercase spellings. No actual types are changed in this commit; that will come next. This is just getting the noise out of the way, so that subsequent commits can have a higher proportion of signal.
2018-10-29 19:50:29 +00:00
opaque = false;
Reinstate as much of the Windows font-linking behaviour as I can easily manage, by adopting a hybrid approach to Unicode text display. The old approach of simply calling ExtTextOutW provided font linking without us having to lift a finger, but didn't do the right thing when it came to bidirectional or Arabic-shaped text. Arabeyes' replacement exact_textout() supported the latter, but turned out to break the former (with no warning from the Windows API documentation, so it's not their fault). So now I've got a second wrapper layer called general_textout(), which splits the input string into substrings based on bidi character class. Any character liable to cause bidi or shaping behaviour if fed straight to ExtTextOutW is instead fed through Arabeyes' exact_textout(), but the rest is fed straight to ExtTextOutW as it used to be. The effect appears to be that font linking is restored for all characters _except_ Arabic and other bidi scripts, which means in particular that we are no longer in a state of regression over 0.57. (0.57 would have done font linking on Arabic as well, but would also have misbidied it, so we've merely exchanged one failure mode for another slightly less harmful one in that situation.) [originally from svn r6910]
2006-11-18 15:10:48 +00:00
}
Stop general_textout() from trying to slice up the input clipping rectangle into smaller ones: it doesn't work any more, since the new variable-pitch code can now call general_textout() with a larger clipping rectangle than the text it's meant to be displaying. Instead, general_textout() now uses the same semantics as the next loop up in do_text_internal(): the first piece of text it displays uses the opacity setting passed in, which blanks the entire clipping rectangle if necessary, and then subsequent overlays are non-opaque. And the same clipping rectangle is used throughout. [originally from svn r9067]
2010-12-30 00:06:43 +00:00
if (got_bkmode)
SetBkMode(hdc, bkmode);
Reinstate as much of the Windows font-linking behaviour as I can easily manage, by adopting a hybrid approach to Unicode text display. The old approach of simply calling ExtTextOutW provided font linking without us having to lift a finger, but didn't do the right thing when it came to bidirectional or Arabic-shaped text. Arabeyes' replacement exact_textout() supported the latter, but turned out to break the former (with no warning from the Windows API documentation, so it's not their fault). So now I've got a second wrapper layer called general_textout(), which splits the input string into substrings based on bidi character class. Any character liable to cause bidi or shaping behaviour if fed straight to ExtTextOutW is instead fed through Arabeyes' exact_textout(), but the rest is fed straight to ExtTextOutW as it used to be. The effect appears to be that font linking is restored for all characters _except_ Arabic and other bidi scripts, which means in particular that we are no longer in a state of regression over 0.57. (0.57 would have done font linking on Arabic as well, but would also have misbidied it, so we've merely exchanged one failure mode for another slightly less harmful one in that situation.) [originally from svn r6910]
2006-11-18 15:10:48 +00:00
}
windows/window.c: move more variables into WinGuiSeat. In commit f9e572595bb8cb6 I claimed that I'd removed very nearly all the global and static variables from windows/window.c. It turns out that this was wildly overoptimistic - I missed quite a few of them! I'm not quite sure how I managed that; my best guess is that I used an underpowered 'nm' command that failed to find some classes of variable. Some of the remaining function-scope statics were removed completely by commit afb3dab1e97a09f just now. In this commit, I've swept up some more and turn them into fields of WinGuiSeat, where they should have been moved last September. The (hopefully complete this time) list of remaining variables, generated by running this rune in the Windows build directory: nm windows/CMakeFiles/putty.dir/window.c.obj | grep -E '^([^ ]+)? *[bBcCdDgGsS] [^\.]' consists of the following variables which are legitimately global across the whole process and not related to a particular window: - 'hinst' and 'hprev', instance handles for Windows loadable modules - 'classname' in the terminal_window_class_a() and terminal_window_class_w() functions, which allocate a window class reusably - some pointers to Windows API functions retrieved via the DECL_WINDOWS_FUNCTION / GET_WINDOWS_FUNCTION system, such as p_AdjustWindowRectExForDpi and p_FlashWindowEx - some pointers to Windows API functions set up by assigning them at startup to the right one of the ANSI or Unicode version depending on the Windows version, e.g. sw_DefWindowProc and sw_DispatchMessage - 'unicode_window', a boolean flag set at the same time as those sw_Foo function pointers - 'sesslist', storing the last-retrieved version of the saved sessions menu - 'cursor_visible' in show_mouseptr() and 'forced_visible' in update_mouse_pointer(), each of which tracks the cumulative number of times that function has shown or hidden the mouse pointer, so as to manage its effect on the global state updated by ShowCursor - 'trust_icon', loaded from the executable's resources - 'wgslisthead', the list of all active WinGuiSeats - 'wm_mousewheel', the window-message id we use for mouse wheel events and the following which are nothing to do with our code: - '_OptionsStorage' in __local_stdio_printf_options() and __local_stdio_scanf_options(), which I'd never noticed before, but apparently are internal to a standard library header.
2023-05-27 13:59:20 +00:00
static int get_font_width(WinGuiSeat *wgs, HDC hdc, const TEXTMETRIC *tm)
Support for using variable-pitch fonts for the terminal on Windows. Done in much the same way as it is in the GTK front end: the character cell width is determined using the font's digits (which seems to give generally not-too-offensive spacing in most cases, at the expense of Ms and Ws typically overhanging a bit into adjacent cells) and each character is centred in its cell. Overhangs never leave permanent droppings on the window, because the existing work done in r5003 handles them just fine even in this stressful scenario. There's a hacky new checkbox in the Appearance panel to make variable-pitch fonts appear in the font selector (they still don't by default, because I still think it's _usually_ not What You Want); the checkbox state is not actually stored as part of a saved session, but it should be automatically ticked when reloading a session that's got a variable pitch font selected. (I'm half-expecting a potential flurry of requests for this feature in the wake of http://xkcd.com/840/ , so I thought I'd pre-empt them :-) [originally from svn r9063] [r5003 == ba470dec5e37ffbde05425f48e7e9a64219aec2e]
2010-12-29 14:11:25 +00:00
{
int ret;
/* Note that the TMPF_FIXED_PITCH bit is defined upside down :-( */
if (!(tm->tmPitchAndFamily & TMPF_FIXED_PITCH)) {
ret = tm->tmAveCharWidth;
} else {
#define FIRST '0'
#define LAST '9'
ABCFLOAT widths[LAST-FIRST + 1];
int j;
windows/window.c: move more variables into WinGuiSeat. In commit f9e572595bb8cb6 I claimed that I'd removed very nearly all the global and static variables from windows/window.c. It turns out that this was wildly overoptimistic - I missed quite a few of them! I'm not quite sure how I managed that; my best guess is that I used an underpowered 'nm' command that failed to find some classes of variable. Some of the remaining function-scope statics were removed completely by commit afb3dab1e97a09f just now. In this commit, I've swept up some more and turn them into fields of WinGuiSeat, where they should have been moved last September. The (hopefully complete this time) list of remaining variables, generated by running this rune in the Windows build directory: nm windows/CMakeFiles/putty.dir/window.c.obj | grep -E '^([^ ]+)? *[bBcCdDgGsS] [^\.]' consists of the following variables which are legitimately global across the whole process and not related to a particular window: - 'hinst' and 'hprev', instance handles for Windows loadable modules - 'classname' in the terminal_window_class_a() and terminal_window_class_w() functions, which allocate a window class reusably - some pointers to Windows API functions retrieved via the DECL_WINDOWS_FUNCTION / GET_WINDOWS_FUNCTION system, such as p_AdjustWindowRectExForDpi and p_FlashWindowEx - some pointers to Windows API functions set up by assigning them at startup to the right one of the ANSI or Unicode version depending on the Windows version, e.g. sw_DefWindowProc and sw_DispatchMessage - 'unicode_window', a boolean flag set at the same time as those sw_Foo function pointers - 'sesslist', storing the last-retrieved version of the saved sessions menu - 'cursor_visible' in show_mouseptr() and 'forced_visible' in update_mouse_pointer(), each of which tracks the cumulative number of times that function has shown or hidden the mouse pointer, so as to manage its effect on the global state updated by ShowCursor - 'trust_icon', loaded from the executable's resources - 'wgslisthead', the list of all active WinGuiSeats - 'wm_mousewheel', the window-message id we use for mouse wheel events and the following which are nothing to do with our code: - '_OptionsStorage' in __local_stdio_printf_options() and __local_stdio_scanf_options(), which I'd never noticed before, but apparently are internal to a standard library header.
2023-05-27 13:59:20 +00:00
wgs->font_varpitch = true;
wgs->font_dualwidth = true;
Support for using variable-pitch fonts for the terminal on Windows. Done in much the same way as it is in the GTK front end: the character cell width is determined using the font's digits (which seems to give generally not-too-offensive spacing in most cases, at the expense of Ms and Ws typically overhanging a bit into adjacent cells) and each character is centred in its cell. Overhangs never leave permanent droppings on the window, because the existing work done in r5003 handles them just fine even in this stressful scenario. There's a hacky new checkbox in the Appearance panel to make variable-pitch fonts appear in the font selector (they still don't by default, because I still think it's _usually_ not What You Want); the checkbox state is not actually stored as part of a saved session, but it should be automatically ticked when reloading a session that's got a variable pitch font selected. (I'm half-expecting a potential flurry of requests for this feature in the wake of http://xkcd.com/840/ , so I thought I'd pre-empt them :-) [originally from svn r9063] [r5003 == ba470dec5e37ffbde05425f48e7e9a64219aec2e]
2010-12-29 14:11:25 +00:00
if (GetCharABCWidthsFloat(hdc, FIRST, LAST, widths)) {
ret = 0;
for (j = 0; j < lenof(widths); j++) {
int width = (int)(0.5 + widths[j].abcfA +
widths[j].abcfB + widths[j].abcfC);
if (ret < width)
ret = width;
}
} else {
ret = tm->tmMaxCharWidth;
}
#undef FIRST
#undef LAST
}
return ret;
}
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
static void init_dpi_info(WinGuiSeat *wgs)
Windows 10: add per monitor DPI awareness support. On a system with 2 or more displays with different DPI settings, moving the PuTTY window from one display to another will make Windows resize the window using its "bitmap" strategy, stretching/compressing the text, making it fuzzy and harder to read. This change makes PuTTY resize its window and font size to accurately fit the DPI of the display it is on. We process the WM_DPICHANGED message, saving the new DPI, window size and position. We proceed to then reset the window, recreating the fonts using the new DPI and calculate the new window size and position based on the new font size, user display options (ie. with/without scrollbar) and the suggested window position provided by Windows. The suggested window size is usually not a perfect fit, therefore we must add a small offset to the new window position in order to avoid issues with repeated DPI changes while dragging the window from one display to another.
2021-03-29 15:31:13 +00:00
{
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
if (wgs->dpi_info.cur_dpi.x == 0 || wgs->dpi_info.cur_dpi.y == 0) {
Remove hard dependencies on multi-monitor functions. These are more functions that don't exist on all our supported legacy versions of Windows, so we need to follow the same policy as everywhere else, by trying to acquire them at run time and having a fallback if they aren't available.
2022-03-11 18:32:26 +00:00
if (p_GetDpiForMonitor && p_MonitorFromWindow) {
Windows 10: add per monitor DPI awareness support. On a system with 2 or more displays with different DPI settings, moving the PuTTY window from one display to another will make Windows resize the window using its "bitmap" strategy, stretching/compressing the text, making it fuzzy and harder to read. This change makes PuTTY resize its window and font size to accurately fit the DPI of the display it is on. We process the WM_DPICHANGED message, saving the new DPI, window size and position. We proceed to then reset the window, recreating the fonts using the new DPI and calculate the new window size and position based on the new font size, user display options (ie. with/without scrollbar) and the suggested window position provided by Windows. The suggested window size is usually not a perfect fit, therefore we must add a small offset to the new window position in order to avoid issues with repeated DPI changes while dragging the window from one display to another.
2021-03-29 15:31:13 +00:00
UINT dpiX, dpiY;
Remove hard dependencies on multi-monitor functions. These are more functions that don't exist on all our supported legacy versions of Windows, so we need to follow the same policy as everywhere else, by trying to acquire them at run time and having a fallback if they aren't available.
2022-03-11 18:32:26 +00:00
HMONITOR currentMonitor = p_MonitorFromWindow(
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
wgs->term_hwnd, MONITOR_DEFAULTTOPRIMARY);
Windows 10: add per monitor DPI awareness support. On a system with 2 or more displays with different DPI settings, moving the PuTTY window from one display to another will make Windows resize the window using its "bitmap" strategy, stretching/compressing the text, making it fuzzy and harder to read. This change makes PuTTY resize its window and font size to accurately fit the DPI of the display it is on. We process the WM_DPICHANGED message, saving the new DPI, window size and position. We proceed to then reset the window, recreating the fonts using the new DPI and calculate the new window size and position based on the new font size, user display options (ie. with/without scrollbar) and the suggested window position provided by Windows. The suggested window size is usually not a perfect fit, therefore we must add a small offset to the new window position in order to avoid issues with repeated DPI changes while dragging the window from one display to another.
2021-03-29 15:31:13 +00:00
if (p_GetDpiForMonitor(currentMonitor, MDT_EFFECTIVE_DPI,
&dpiX, &dpiY) == S_OK) {
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
wgs->dpi_info.cur_dpi.x = (int)dpiX;
wgs->dpi_info.cur_dpi.y = (int)dpiY;
Windows 10: add per monitor DPI awareness support. On a system with 2 or more displays with different DPI settings, moving the PuTTY window from one display to another will make Windows resize the window using its "bitmap" strategy, stretching/compressing the text, making it fuzzy and harder to read. This change makes PuTTY resize its window and font size to accurately fit the DPI of the display it is on. We process the WM_DPICHANGED message, saving the new DPI, window size and position. We proceed to then reset the window, recreating the fonts using the new DPI and calculate the new window size and position based on the new font size, user display options (ie. with/without scrollbar) and the suggested window position provided by Windows. The suggested window size is usually not a perfect fit, therefore we must add a small offset to the new window position in order to avoid issues with repeated DPI changes while dragging the window from one display to another.
2021-03-29 15:31:13 +00:00
}
}
/* Fall back to system DPI */
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
if (wgs->dpi_info.cur_dpi.x == 0 || wgs->dpi_info.cur_dpi.y == 0) {
HDC hdc = GetDC(wgs->term_hwnd);
wgs->dpi_info.cur_dpi.x = GetDeviceCaps(hdc, LOGPIXELSX);
wgs->dpi_info.cur_dpi.y = GetDeviceCaps(hdc, LOGPIXELSY);
ReleaseDC(wgs->term_hwnd, hdc);
Windows 10: add per monitor DPI awareness support. On a system with 2 or more displays with different DPI settings, moving the PuTTY window from one display to another will make Windows resize the window using its "bitmap" strategy, stretching/compressing the text, making it fuzzy and harder to read. This change makes PuTTY resize its window and font size to accurately fit the DPI of the display it is on. We process the WM_DPICHANGED message, saving the new DPI, window size and position. We proceed to then reset the window, recreating the fonts using the new DPI and calculate the new window size and position based on the new font size, user display options (ie. with/without scrollbar) and the suggested window position provided by Windows. The suggested window size is usually not a perfect fit, therefore we must add a small offset to the new window position in order to avoid issues with repeated DPI changes while dragging the window from one display to another.
2021-03-29 15:31:13 +00:00
}
}
}
Initial checkin: beta 0.43 [originally from svn r11]
1999-01-08 13:02:13 +00:00
/*
RDB's Unicode patch. Fonts are now used in Unicode mode where possible and we have a single unified means of trying to display any Unicode code point. Instead of the various ad-hoc translation modes we had before, we now have a single `codepage' option which allows us to treat the incoming (and outgoing) text as any given character set, and locally we map that to Unicode and back. [originally from svn r1110]
2001-05-10 08:34:20 +00:00
* Initialise all the fonts we will need initially. There may be as many as
A comment typo fix I've had lying around for a while. [originally from svn r8974]
2010-07-30 19:45:40 +00:00
* three or as few as one. The other (potentially) twenty-one fonts are done
RDB's Unicode patch. Fonts are now used in Unicode mode where possible and we have a single unified means of trying to display any Unicode code point. Instead of the various ad-hoc translation modes we had before, we now have a single `codepage' option which allows us to treat the incoming (and outgoing) text as any given character set, and locally we map that to Unicode and back. [originally from svn r1110]
2001-05-10 08:34:20 +00:00
* if/when they are needed.
*
* We also:
Initial checkin: beta 0.43 [originally from svn r11]
1999-01-08 13:02:13 +00:00
*
* - check the font width and height, correcting our guesses if
* necessary.
*
* - verify that the bold font is the same width as the ordinary
* one, and engage shadow bolding if not.
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
*
Initial checkin: beta 0.43 [originally from svn r11]
1999-01-08 13:02:13 +00:00
* - verify that the underlined font is the same width as the
* ordinary one (manual underlining by means of line drawing can
* be done in a pinch).
Slightly nicer trust sigil on Windows. Re-consider the icon in light of the font size, so that we pick the icon whose size mostly closely matches the terminal font, rather than always scaling the default icon.
2019-03-30 15:44:01 +00:00
*
* - find a trust sigil icon that will look OK with the chosen font.
Initial checkin: beta 0.43 [originally from svn r11]
1999-01-08 13:02:13 +00:00
*/
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
static void init_fonts(WinGuiSeat *wgs, int pick_width, int pick_height)
Run entire source base through GNU indent to tidy up the varying coding styles of the various contributors! Woohoo! [originally from svn r1098]
2001-05-06 14:35:20 +00:00
{
Initial checkin: beta 0.43 [originally from svn r11]
1999-01-08 13:02:13 +00:00
TEXTMETRIC tm;
Support SGR 9 for strikethrough effect on text. This is mostly easy: it's just like drawing an underline, except that you put it at a different height in the character cell. The only question is _where_ in the character cell. Pango, and Windows GetOutlineTextMetrics, will tell you exactly where the font wants to have it. Following xterm, I fall back to 3/8 of the font's ascent (above the baseline) if either of those is unavailable.
2020-08-13 20:08:53 +00:00
OUTLINETEXTMETRIC otm;
RDB's Unicode patch. Fonts are now used in Unicode mode where possible and we have a single unified means of trying to display any Unicode code point. Instead of the various ad-hoc translation modes we had before, we now have a single `codepage' option which allows us to treat the incoming (and outgoing) text as any given character set, and locally we map that to Unicode and back. [originally from svn r1110]
2001-05-10 08:34:20 +00:00
CPINFO cpinfo;
Post-release destabilisation! Completely remove the struct type 'Config' in putty.h, which stores all PuTTY's settings and includes an arbitrary length limit on every single one of those settings which is stored in string form. In place of it is 'Conf', an opaque data type everywhere outside the new file conf.c, which stores a list of (key, value) pairs in which every key contains an integer identifying a configuration setting, and for some of those integers the key also contains extra parts (so that, for instance, CONF_environmt is a string-to-string mapping). Everywhere that a Config was previously used, a Conf is now; everywhere there was a Config structure copy, conf_copy() is called; every lookup, adjustment, load and save operation on a Config has been rewritten; and there's a mechanism for serialising a Conf into a binary blob and back for use with Duplicate Session. User-visible effects of this change _should_ be minimal, though I don't doubt I've introduced one or two bugs here and there which will eventually be found. The _intended_ visible effects of this change are that all arbitrary limits on configuration strings and lists (e.g. limit on number of port forwardings) should now disappear; that list boxes in the configuration will now be displayed in a sorted order rather than the arbitrary order in which they were added to the list (since the underlying data structure is now a sorted tree234 rather than an ad-hoc comma-separated string); and one more specific change, which is that local and dynamic port forwardings on the same port number are now mutually exclusive in the configuration (putting 'D' in the key rather than the value was a mistake in the first place). One other reorganisation as a result of this is that I've moved all the dialog.c standard handlers (dlg_stdeditbox_handler and friends) out into config.c, because I can't really justify calling them generic any more. When they took a pointer to an arbitrary structure type and the offset of a field within that structure, they were independent of whether that structure was a Config or something completely different, but now they really do expect to talk to a Conf, which can _only_ be used for PuTTY configuration, so I've renamed them all things like conf_editbox_handler and moved them out of the nominally independent dialog-box management module into the PuTTY-specific config.c. [originally from svn r9214]
2011-07-14 18:52:21 +00:00
FontSpec *font;
RDB's Unicode patch. Fonts are now used in Unicode mode where possible and we have a single unified means of trying to display any Unicode code point. Instead of the various ad-hoc translation modes we had before, we now have a single `codepage' option which allows us to treat the incoming (and outgoing) text as any given character set, and locally we map that to Unicode and back. [originally from svn r1110]
2001-05-10 08:34:20 +00:00
int fontsize[3];
Robert de Bath's patch: be much more careful about font heights and widths, including underline mode and OEM/ANSI size mismatch. [originally from svn r405]
2000-03-11 14:15:24 +00:00
int i;
Post-release destabilisation! Completely remove the struct type 'Config' in putty.h, which stores all PuTTY's settings and includes an arbitrary length limit on every single one of those settings which is stored in string form. In place of it is 'Conf', an opaque data type everywhere outside the new file conf.c, which stores a list of (key, value) pairs in which every key contains an integer identifying a configuration setting, and for some of those integers the key also contains extra parts (so that, for instance, CONF_environmt is a string-to-string mapping). Everywhere that a Config was previously used, a Conf is now; everywhere there was a Config structure copy, conf_copy() is called; every lookup, adjustment, load and save operation on a Config has been rewritten; and there's a mechanism for serialising a Conf into a binary blob and back for use with Duplicate Session. User-visible effects of this change _should_ be minimal, though I don't doubt I've introduced one or two bugs here and there which will eventually be found. The _intended_ visible effects of this change are that all arbitrary limits on configuration strings and lists (e.g. limit on number of port forwardings) should now disappear; that list boxes in the configuration will now be displayed in a sorted order rather than the arbitrary order in which they were added to the list (since the underlying data structure is now a sorted tree234 rather than an ad-hoc comma-separated string); and one more specific change, which is that local and dynamic port forwardings on the same port number are now mutually exclusive in the configuration (putting 'D' in the key rather than the value was a mistake in the first place). One other reorganisation as a result of this is that I've moved all the dialog.c standard handlers (dlg_stdeditbox_handler and friends) out into config.c, because I can't really justify calling them generic any more. When they took a pointer to an arbitrary structure type and the offset of a field within that structure, they were independent of whether that structure was a Config or something completely different, but now they really do expect to talk to a Conf, which can _only_ be used for PuTTY configuration, so I've renamed them all things like conf_editbox_handler and moved them out of the nominally independent dialog-box management module into the PuTTY-specific config.c. [originally from svn r9214]
2011-07-14 18:52:21 +00:00
int quality;
Initial checkin: beta 0.43 [originally from svn r11]
1999-01-08 13:02:13 +00:00
HDC hdc;
int fw_dontcare, fw_bold;
RDB's Unicode patch. Fonts are now used in Unicode mode where possible and we have a single unified means of trying to display any Unicode code point. Instead of the various ad-hoc translation modes we had before, we now have a single `codepage' option which allows us to treat the incoming (and outgoing) text as any given character set, and locally we map that to Unicode and back. [originally from svn r1110]
2001-05-10 08:34:20 +00:00
for (i = 0; i < FONT_MAXNO; i++)
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
wgs->fonts[i] = NULL;
Initial checkin: beta 0.43 [originally from svn r11]
1999-01-08 13:02:13 +00:00
Cleanup: make symbolic names for CONF_bold_style bits. CONF_bold_style is a pair of bit flags rather than an enum, so its values aren't just BOLD_STYLE_FONT and BOLD_STYLE_COLOUR but also the bitwise OR of them. (Hopefully not neither.)
2023-05-29 14:51:56 +00:00
wgs->bold_font_mode =
conf_get_int(wgs->conf, CONF_bold_style) & BOLD_STYLE_FONT ?
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
BOLD_FONT : BOLD_NONE;
Cleanup: make symbolic names for CONF_bold_style bits. CONF_bold_style is a pair of bit flags rather than an enum, so its values aren't just BOLD_STYLE_FONT and BOLD_STYLE_COLOUR but also the bitwise OR of them. (Hopefully not neither.)
2023-05-29 14:51:56 +00:00
wgs->bold_colours =
conf_get_int(wgs->conf, CONF_bold_style) & BOLD_STYLE_COLOUR ?
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
true : false;
wgs->und_mode = UND_FONT;
Three more patches from RDB: one to make Atomica work right, one to fiddle with the widths of characters in DBCS screen fonts, and (the big one) one to enable a mode in which resizing the window locks the terminal size and lets the font change, instead of vice versa. That should shut up a few feature requests! [originally from svn r1269]
2001-09-15 15:54:24 +00:00
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
font = conf_get_fontspec(wgs->conf, CONF_font);
Post-release destabilisation! Completely remove the struct type 'Config' in putty.h, which stores all PuTTY's settings and includes an arbitrary length limit on every single one of those settings which is stored in string form. In place of it is 'Conf', an opaque data type everywhere outside the new file conf.c, which stores a list of (key, value) pairs in which every key contains an integer identifying a configuration setting, and for some of those integers the key also contains extra parts (so that, for instance, CONF_environmt is a string-to-string mapping). Everywhere that a Config was previously used, a Conf is now; everywhere there was a Config structure copy, conf_copy() is called; every lookup, adjustment, load and save operation on a Config has been rewritten; and there's a mechanism for serialising a Conf into a binary blob and back for use with Duplicate Session. User-visible effects of this change _should_ be minimal, though I don't doubt I've introduced one or two bugs here and there which will eventually be found. The _intended_ visible effects of this change are that all arbitrary limits on configuration strings and lists (e.g. limit on number of port forwardings) should now disappear; that list boxes in the configuration will now be displayed in a sorted order rather than the arbitrary order in which they were added to the list (since the underlying data structure is now a sorted tree234 rather than an ad-hoc comma-separated string); and one more specific change, which is that local and dynamic port forwardings on the same port number are now mutually exclusive in the configuration (putting 'D' in the key rather than the value was a mistake in the first place). One other reorganisation as a result of this is that I've moved all the dialog.c standard handlers (dlg_stdeditbox_handler and friends) out into config.c, because I can't really justify calling them generic any more. When they took a pointer to an arbitrary structure type and the offset of a field within that structure, they were independent of whether that structure was a Config or something completely different, but now they really do expect to talk to a Conf, which can _only_ be used for PuTTY configuration, so I've renamed them all things like conf_editbox_handler and moved them out of the nominally independent dialog-box management module into the PuTTY-specific config.c. [originally from svn r9214]
2011-07-14 18:52:21 +00:00
if (font->isbold) {
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
fw_dontcare = FW_BOLD;
fw_bold = FW_HEAVY;
Run entire source base through GNU indent to tidy up the varying coding styles of the various contributors! Woohoo! [originally from svn r1098]
2001-05-06 14:35:20 +00:00
} else {
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
fw_dontcare = FW_DONTCARE;
fw_bold = FW_BOLD;
Initial checkin: beta 0.43 [originally from svn r11]
1999-01-08 13:02:13 +00:00
}
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
hdc = GetDC(wgs->term_hwnd);
Robert de Bath's patch: be much more careful about font heights and widths, including underline mode and OEM/ANSI size mismatch. [originally from svn r405]
2000-03-11 14:15:24 +00:00
Three more patches from RDB: one to make Atomica work right, one to fiddle with the widths of characters in DBCS screen fonts, and (the big one) one to enable a mode in which resizing the window locks the terminal size and lets the font change, instead of vice versa. That should shut up a few feature requests! [originally from svn r1269]
2001-09-15 15:54:24 +00:00
if (pick_height)
windows/window.c: move more variables into WinGuiSeat. In commit f9e572595bb8cb6 I claimed that I'd removed very nearly all the global and static variables from windows/window.c. It turns out that this was wildly overoptimistic - I missed quite a few of them! I'm not quite sure how I managed that; my best guess is that I used an underpowered 'nm' command that failed to find some classes of variable. Some of the remaining function-scope statics were removed completely by commit afb3dab1e97a09f just now. In this commit, I've swept up some more and turn them into fields of WinGuiSeat, where they should have been moved last September. The (hopefully complete this time) list of remaining variables, generated by running this rune in the Windows build directory: nm windows/CMakeFiles/putty.dir/window.c.obj | grep -E '^([^ ]+)? *[bBcCdDgGsS] [^\.]' consists of the following variables which are legitimately global across the whole process and not related to a particular window: - 'hinst' and 'hprev', instance handles for Windows loadable modules - 'classname' in the terminal_window_class_a() and terminal_window_class_w() functions, which allocate a window class reusably - some pointers to Windows API functions retrieved via the DECL_WINDOWS_FUNCTION / GET_WINDOWS_FUNCTION system, such as p_AdjustWindowRectExForDpi and p_FlashWindowEx - some pointers to Windows API functions set up by assigning them at startup to the right one of the ANSI or Unicode version depending on the Windows version, e.g. sw_DefWindowProc and sw_DispatchMessage - 'unicode_window', a boolean flag set at the same time as those sw_Foo function pointers - 'sesslist', storing the last-retrieved version of the saved sessions menu - 'cursor_visible' in show_mouseptr() and 'forced_visible' in update_mouse_pointer(), each of which tracks the cumulative number of times that function has shown or hidden the mouse pointer, so as to manage its effect on the global state updated by ShowCursor - 'trust_icon', loaded from the executable's resources - 'wgslisthead', the list of all active WinGuiSeats - 'wm_mousewheel', the window-message id we use for mouse wheel events and the following which are nothing to do with our code: - '_OptionsStorage' in __local_stdio_printf_options() and __local_stdio_scanf_options(), which I'd never noticed before, but apparently are internal to a standard library header.
2023-05-27 13:59:20 +00:00
wgs->font_height = pick_height;
Three more patches from RDB: one to make Atomica work right, one to fiddle with the widths of characters in DBCS screen fonts, and (the big one) one to enable a mode in which resizing the window locks the terminal size and lets the font change, instead of vice versa. That should shut up a few feature requests! [originally from svn r1269]
2001-09-15 15:54:24 +00:00
else {
windows/window.c: move more variables into WinGuiSeat. In commit f9e572595bb8cb6 I claimed that I'd removed very nearly all the global and static variables from windows/window.c. It turns out that this was wildly overoptimistic - I missed quite a few of them! I'm not quite sure how I managed that; my best guess is that I used an underpowered 'nm' command that failed to find some classes of variable. Some of the remaining function-scope statics were removed completely by commit afb3dab1e97a09f just now. In this commit, I've swept up some more and turn them into fields of WinGuiSeat, where they should have been moved last September. The (hopefully complete this time) list of remaining variables, generated by running this rune in the Windows build directory: nm windows/CMakeFiles/putty.dir/window.c.obj | grep -E '^([^ ]+)? *[bBcCdDgGsS] [^\.]' consists of the following variables which are legitimately global across the whole process and not related to a particular window: - 'hinst' and 'hprev', instance handles for Windows loadable modules - 'classname' in the terminal_window_class_a() and terminal_window_class_w() functions, which allocate a window class reusably - some pointers to Windows API functions retrieved via the DECL_WINDOWS_FUNCTION / GET_WINDOWS_FUNCTION system, such as p_AdjustWindowRectExForDpi and p_FlashWindowEx - some pointers to Windows API functions set up by assigning them at startup to the right one of the ANSI or Unicode version depending on the Windows version, e.g. sw_DefWindowProc and sw_DispatchMessage - 'unicode_window', a boolean flag set at the same time as those sw_Foo function pointers - 'sesslist', storing the last-retrieved version of the saved sessions menu - 'cursor_visible' in show_mouseptr() and 'forced_visible' in update_mouse_pointer(), each of which tracks the cumulative number of times that function has shown or hidden the mouse pointer, so as to manage its effect on the global state updated by ShowCursor - 'trust_icon', loaded from the executable's resources - 'wgslisthead', the list of all active WinGuiSeats - 'wm_mousewheel', the window-message id we use for mouse wheel events and the following which are nothing to do with our code: - '_OptionsStorage' in __local_stdio_printf_options() and __local_stdio_scanf_options(), which I'd never noticed before, but apparently are internal to a standard library header.
2023-05-27 13:59:20 +00:00
wgs->font_height = font->height;
if (wgs->font_height > 0) {
wgs->font_height = -MulDiv(
wgs->font_height, wgs->dpi_info.cur_dpi.y, 72);
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
}
Finally fixed the point/pixel confusion in font handling. Thanks to Roman Surma for pointing me at the relevant bits of documentation. All font sizes should now be measured in points, and everything should be consistent, and (with any luck) old Registry settings should adapt gracefully too. [originally from svn r992]
2001-03-12 12:24:07 +00:00
}
windows/window.c: move more variables into WinGuiSeat. In commit f9e572595bb8cb6 I claimed that I'd removed very nearly all the global and static variables from windows/window.c. It turns out that this was wildly overoptimistic - I missed quite a few of them! I'm not quite sure how I managed that; my best guess is that I used an underpowered 'nm' command that failed to find some classes of variable. Some of the remaining function-scope statics were removed completely by commit afb3dab1e97a09f just now. In this commit, I've swept up some more and turn them into fields of WinGuiSeat, where they should have been moved last September. The (hopefully complete this time) list of remaining variables, generated by running this rune in the Windows build directory: nm windows/CMakeFiles/putty.dir/window.c.obj | grep -E '^([^ ]+)? *[bBcCdDgGsS] [^\.]' consists of the following variables which are legitimately global across the whole process and not related to a particular window: - 'hinst' and 'hprev', instance handles for Windows loadable modules - 'classname' in the terminal_window_class_a() and terminal_window_class_w() functions, which allocate a window class reusably - some pointers to Windows API functions retrieved via the DECL_WINDOWS_FUNCTION / GET_WINDOWS_FUNCTION system, such as p_AdjustWindowRectExForDpi and p_FlashWindowEx - some pointers to Windows API functions set up by assigning them at startup to the right one of the ANSI or Unicode version depending on the Windows version, e.g. sw_DefWindowProc and sw_DispatchMessage - 'unicode_window', a boolean flag set at the same time as those sw_Foo function pointers - 'sesslist', storing the last-retrieved version of the saved sessions menu - 'cursor_visible' in show_mouseptr() and 'forced_visible' in update_mouse_pointer(), each of which tracks the cumulative number of times that function has shown or hidden the mouse pointer, so as to manage its effect on the global state updated by ShowCursor - 'trust_icon', loaded from the executable's resources - 'wgslisthead', the list of all active WinGuiSeats - 'wm_mousewheel', the window-message id we use for mouse wheel events and the following which are nothing to do with our code: - '_OptionsStorage' in __local_stdio_printf_options() and __local_stdio_scanf_options(), which I'd never noticed before, but apparently are internal to a standard library header.
2023-05-27 13:59:20 +00:00
wgs->font_width = pick_width;
Robert de Bath's patch: be much more careful about font heights and widths, including underline mode and OEM/ANSI size mismatch. [originally from svn r405]
2000-03-11 14:15:24 +00:00
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
quality = conf_get_int(wgs->conf, CONF_font_quality);
windows/window.c: move more variables into WinGuiSeat. In commit f9e572595bb8cb6 I claimed that I'd removed very nearly all the global and static variables from windows/window.c. It turns out that this was wildly overoptimistic - I missed quite a few of them! I'm not quite sure how I managed that; my best guess is that I used an underpowered 'nm' command that failed to find some classes of variable. Some of the remaining function-scope statics were removed completely by commit afb3dab1e97a09f just now. In this commit, I've swept up some more and turn them into fields of WinGuiSeat, where they should have been moved last September. The (hopefully complete this time) list of remaining variables, generated by running this rune in the Windows build directory: nm windows/CMakeFiles/putty.dir/window.c.obj | grep -E '^([^ ]+)? *[bBcCdDgGsS] [^\.]' consists of the following variables which are legitimately global across the whole process and not related to a particular window: - 'hinst' and 'hprev', instance handles for Windows loadable modules - 'classname' in the terminal_window_class_a() and terminal_window_class_w() functions, which allocate a window class reusably - some pointers to Windows API functions retrieved via the DECL_WINDOWS_FUNCTION / GET_WINDOWS_FUNCTION system, such as p_AdjustWindowRectExForDpi and p_FlashWindowEx - some pointers to Windows API functions set up by assigning them at startup to the right one of the ANSI or Unicode version depending on the Windows version, e.g. sw_DefWindowProc and sw_DispatchMessage - 'unicode_window', a boolean flag set at the same time as those sw_Foo function pointers - 'sesslist', storing the last-retrieved version of the saved sessions menu - 'cursor_visible' in show_mouseptr() and 'forced_visible' in update_mouse_pointer(), each of which tracks the cumulative number of times that function has shown or hidden the mouse pointer, so as to manage its effect on the global state updated by ShowCursor - 'trust_icon', loaded from the executable's resources - 'wgslisthead', the list of all active WinGuiSeats - 'wm_mousewheel', the window-message id we use for mouse wheel events and the following which are nothing to do with our code: - '_OptionsStorage' in __local_stdio_printf_options() and __local_stdio_scanf_options(), which I'd never noticed before, but apparently are internal to a standard library header.
2023-05-27 13:59:20 +00:00
#define f(i,c,w,u) \
wgs->fonts[i] = CreateFont( \
wgs->font_height, wgs->font_width, 0, 0, w, false, u, false, c, \
OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS, FONT_QUALITY(quality), \
FIXED_PITCH | FF_DONTCARE, font->name)
Robert de Bath's patch: be much more careful about font heights and widths, including underline mode and OEM/ANSI size mismatch. [originally from svn r405]
2000-03-11 14:15:24 +00:00
Adopt C99 <stdbool.h>'s true/false. This commit includes <stdbool.h> from defs.h and deletes my traditional definitions of TRUE and FALSE, but other than that, it's a 100% mechanical search-and-replace transforming all uses of TRUE and FALSE into the C99-standardised lowercase spellings. No actual types are changed in this commit; that will come next. This is just getting the noise out of the way, so that subsequent commits can have a higher proportion of signal.
2018-10-29 19:50:29 +00:00
f(FONT_NORMAL, font->charset, fw_dontcare, false);
Robert de Bath's patch: be much more careful about font heights and widths, including underline mode and OEM/ANSI size mismatch. [originally from svn r405]
2000-03-11 14:15:24 +00:00
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
SelectObject(hdc, wgs->fonts[FONT_NORMAL]);
RDB's Unicode patch. Fonts are now used in Unicode mode where possible and we have a single unified means of trying to display any Unicode code point. Instead of the various ad-hoc translation modes we had before, we now have a single `codepage' option which allows us to treat the incoming (and outgoing) text as any given character set, and locally we map that to Unicode and back. [originally from svn r1110]
2001-05-10 08:34:20 +00:00
GetTextMetrics(hdc, &tm);
Support SGR 9 for strikethrough effect on text. This is mostly easy: it's just like drawing an underline, except that you put it at a different height in the character cell. The only question is _where_ in the character cell. Pango, and Windows GetOutlineTextMetrics, will tell you exactly where the font wants to have it. Following xterm, I fall back to 3/8 of the font's ascent (above the baseline) if either of those is unavailable.
2020-08-13 20:08:53 +00:00
if (GetOutlineTextMetrics(hdc, sizeof(otm), &otm))
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
wgs->font_strikethrough_y = tm.tmAscent - otm.otmsStrikeoutPosition;
Support SGR 9 for strikethrough effect on text. This is mostly easy: it's just like drawing an underline, except that you put it at a different height in the character cell. The only question is _where_ in the character cell. Pango, and Windows GetOutlineTextMetrics, will tell you exactly where the font wants to have it. Following xterm, I fall back to 3/8 of the font's ascent (above the baseline) if either of those is unavailable.
2020-08-13 20:08:53 +00:00
else
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
wgs->font_strikethrough_y = tm.tmAscent - (tm.tmAscent * 3 / 8);
Three more patches from RDB: one to make Atomica work right, one to fiddle with the widths of characters in DBCS screen fonts, and (the big one) one to enable a mode in which resizing the window locks the terminal size and lets the font change, instead of vice versa. That should shut up a few feature requests! [originally from svn r1269]
2001-09-15 15:54:24 +00:00
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
GetObject(wgs->fonts[FONT_NORMAL], sizeof(LOGFONT), &wgs->lfont);
Improvement for IME font display from Hung-Te Lin. Not tested, but it appears only to affect Glenn Maynard's r1406 code from <20011006170741.A23470@zewt.org> and nothing else, so seems harmless enough. [originally from svn r5533] [r1406 == d9f7fc44bc177da552a14b879c199cc99f991e19]
2005-03-21 01:05:38 +00:00
Support for using variable-pitch fonts for the terminal on Windows. Done in much the same way as it is in the GTK front end: the character cell width is determined using the font's digits (which seems to give generally not-too-offensive spacing in most cases, at the expense of Ms and Ws typically overhanging a bit into adjacent cells) and each character is centred in its cell. Overhangs never leave permanent droppings on the window, because the existing work done in r5003 handles them just fine even in this stressful scenario. There's a hacky new checkbox in the Appearance panel to make variable-pitch fonts appear in the font selector (they still don't by default, because I still think it's _usually_ not What You Want); the checkbox state is not actually stored as part of a saved session, but it should be automatically ticked when reloading a session that's got a variable pitch font selected. (I'm half-expecting a potential flurry of requests for this feature in the wake of http://xkcd.com/840/ , so I thought I'd pre-empt them :-) [originally from svn r9063] [r5003 == ba470dec5e37ffbde05425f48e7e9a64219aec2e]
2010-12-29 14:11:25 +00:00
/* Note that the TMPF_FIXED_PITCH bit is defined upside down :-( */
if (!(tm.tmPitchAndFamily & TMPF_FIXED_PITCH)) {
windows/window.c: move more variables into WinGuiSeat. In commit f9e572595bb8cb6 I claimed that I'd removed very nearly all the global and static variables from windows/window.c. It turns out that this was wildly overoptimistic - I missed quite a few of them! I'm not quite sure how I managed that; my best guess is that I used an underpowered 'nm' command that failed to find some classes of variable. Some of the remaining function-scope statics were removed completely by commit afb3dab1e97a09f just now. In this commit, I've swept up some more and turn them into fields of WinGuiSeat, where they should have been moved last September. The (hopefully complete this time) list of remaining variables, generated by running this rune in the Windows build directory: nm windows/CMakeFiles/putty.dir/window.c.obj | grep -E '^([^ ]+)? *[bBcCdDgGsS] [^\.]' consists of the following variables which are legitimately global across the whole process and not related to a particular window: - 'hinst' and 'hprev', instance handles for Windows loadable modules - 'classname' in the terminal_window_class_a() and terminal_window_class_w() functions, which allocate a window class reusably - some pointers to Windows API functions retrieved via the DECL_WINDOWS_FUNCTION / GET_WINDOWS_FUNCTION system, such as p_AdjustWindowRectExForDpi and p_FlashWindowEx - some pointers to Windows API functions set up by assigning them at startup to the right one of the ANSI or Unicode version depending on the Windows version, e.g. sw_DefWindowProc and sw_DispatchMessage - 'unicode_window', a boolean flag set at the same time as those sw_Foo function pointers - 'sesslist', storing the last-retrieved version of the saved sessions menu - 'cursor_visible' in show_mouseptr() and 'forced_visible' in update_mouse_pointer(), each of which tracks the cumulative number of times that function has shown or hidden the mouse pointer, so as to manage its effect on the global state updated by ShowCursor - 'trust_icon', loaded from the executable's resources - 'wgslisthead', the list of all active WinGuiSeats - 'wm_mousewheel', the window-message id we use for mouse wheel events and the following which are nothing to do with our code: - '_OptionsStorage' in __local_stdio_printf_options() and __local_stdio_scanf_options(), which I'd never noticed before, but apparently are internal to a standard library header.
2023-05-27 13:59:20 +00:00
wgs->font_varpitch = false;
wgs->font_dualwidth = (tm.tmAveCharWidth != tm.tmMaxCharWidth);
Support for using variable-pitch fonts for the terminal on Windows. Done in much the same way as it is in the GTK front end: the character cell width is determined using the font's digits (which seems to give generally not-too-offensive spacing in most cases, at the expense of Ms and Ws typically overhanging a bit into adjacent cells) and each character is centred in its cell. Overhangs never leave permanent droppings on the window, because the existing work done in r5003 handles them just fine even in this stressful scenario. There's a hacky new checkbox in the Appearance panel to make variable-pitch fonts appear in the font selector (they still don't by default, because I still think it's _usually_ not What You Want); the checkbox state is not actually stored as part of a saved session, but it should be automatically ticked when reloading a session that's got a variable pitch font selected. (I'm half-expecting a potential flurry of requests for this feature in the wake of http://xkcd.com/840/ , so I thought I'd pre-empt them :-) [originally from svn r9063] [r5003 == ba470dec5e37ffbde05425f48e7e9a64219aec2e]
2010-12-29 14:11:25 +00:00
} else {
windows/window.c: move more variables into WinGuiSeat. In commit f9e572595bb8cb6 I claimed that I'd removed very nearly all the global and static variables from windows/window.c. It turns out that this was wildly overoptimistic - I missed quite a few of them! I'm not quite sure how I managed that; my best guess is that I used an underpowered 'nm' command that failed to find some classes of variable. Some of the remaining function-scope statics were removed completely by commit afb3dab1e97a09f just now. In this commit, I've swept up some more and turn them into fields of WinGuiSeat, where they should have been moved last September. The (hopefully complete this time) list of remaining variables, generated by running this rune in the Windows build directory: nm windows/CMakeFiles/putty.dir/window.c.obj | grep -E '^([^ ]+)? *[bBcCdDgGsS] [^\.]' consists of the following variables which are legitimately global across the whole process and not related to a particular window: - 'hinst' and 'hprev', instance handles for Windows loadable modules - 'classname' in the terminal_window_class_a() and terminal_window_class_w() functions, which allocate a window class reusably - some pointers to Windows API functions retrieved via the DECL_WINDOWS_FUNCTION / GET_WINDOWS_FUNCTION system, such as p_AdjustWindowRectExForDpi and p_FlashWindowEx - some pointers to Windows API functions set up by assigning them at startup to the right one of the ANSI or Unicode version depending on the Windows version, e.g. sw_DefWindowProc and sw_DispatchMessage - 'unicode_window', a boolean flag set at the same time as those sw_Foo function pointers - 'sesslist', storing the last-retrieved version of the saved sessions menu - 'cursor_visible' in show_mouseptr() and 'forced_visible' in update_mouse_pointer(), each of which tracks the cumulative number of times that function has shown or hidden the mouse pointer, so as to manage its effect on the global state updated by ShowCursor - 'trust_icon', loaded from the executable's resources - 'wgslisthead', the list of all active WinGuiSeats - 'wm_mousewheel', the window-message id we use for mouse wheel events and the following which are nothing to do with our code: - '_OptionsStorage' in __local_stdio_printf_options() and __local_stdio_scanf_options(), which I'd never noticed before, but apparently are internal to a standard library header.
2023-05-27 13:59:20 +00:00
wgs->font_varpitch = true;
wgs->font_dualwidth = true;
Support for using variable-pitch fonts for the terminal on Windows. Done in much the same way as it is in the GTK front end: the character cell width is determined using the font's digits (which seems to give generally not-too-offensive spacing in most cases, at the expense of Ms and Ws typically overhanging a bit into adjacent cells) and each character is centred in its cell. Overhangs never leave permanent droppings on the window, because the existing work done in r5003 handles them just fine even in this stressful scenario. There's a hacky new checkbox in the Appearance panel to make variable-pitch fonts appear in the font selector (they still don't by default, because I still think it's _usually_ not What You Want); the checkbox state is not actually stored as part of a saved session, but it should be automatically ticked when reloading a session that's got a variable pitch font selected. (I'm half-expecting a potential flurry of requests for this feature in the wake of http://xkcd.com/840/ , so I thought I'd pre-empt them :-) [originally from svn r9063] [r5003 == ba470dec5e37ffbde05425f48e7e9a64219aec2e]
2010-12-29 14:11:25 +00:00
}
Three more patches from RDB: one to make Atomica work right, one to fiddle with the widths of characters in DBCS screen fonts, and (the big one) one to enable a mode in which resizing the window locks the terminal size and lets the font change, instead of vice versa. That should shut up a few feature requests! [originally from svn r1269]
2001-09-15 15:54:24 +00:00
if (pick_width == 0 || pick_height == 0) {
windows/window.c: move more variables into WinGuiSeat. In commit f9e572595bb8cb6 I claimed that I'd removed very nearly all the global and static variables from windows/window.c. It turns out that this was wildly overoptimistic - I missed quite a few of them! I'm not quite sure how I managed that; my best guess is that I used an underpowered 'nm' command that failed to find some classes of variable. Some of the remaining function-scope statics were removed completely by commit afb3dab1e97a09f just now. In this commit, I've swept up some more and turn them into fields of WinGuiSeat, where they should have been moved last September. The (hopefully complete this time) list of remaining variables, generated by running this rune in the Windows build directory: nm windows/CMakeFiles/putty.dir/window.c.obj | grep -E '^([^ ]+)? *[bBcCdDgGsS] [^\.]' consists of the following variables which are legitimately global across the whole process and not related to a particular window: - 'hinst' and 'hprev', instance handles for Windows loadable modules - 'classname' in the terminal_window_class_a() and terminal_window_class_w() functions, which allocate a window class reusably - some pointers to Windows API functions retrieved via the DECL_WINDOWS_FUNCTION / GET_WINDOWS_FUNCTION system, such as p_AdjustWindowRectExForDpi and p_FlashWindowEx - some pointers to Windows API functions set up by assigning them at startup to the right one of the ANSI or Unicode version depending on the Windows version, e.g. sw_DefWindowProc and sw_DispatchMessage - 'unicode_window', a boolean flag set at the same time as those sw_Foo function pointers - 'sesslist', storing the last-retrieved version of the saved sessions menu - 'cursor_visible' in show_mouseptr() and 'forced_visible' in update_mouse_pointer(), each of which tracks the cumulative number of times that function has shown or hidden the mouse pointer, so as to manage its effect on the global state updated by ShowCursor - 'trust_icon', loaded from the executable's resources - 'wgslisthead', the list of all active WinGuiSeats - 'wm_mousewheel', the window-message id we use for mouse wheel events and the following which are nothing to do with our code: - '_OptionsStorage' in __local_stdio_printf_options() and __local_stdio_scanf_options(), which I'd never noticed before, but apparently are internal to a standard library header.
2023-05-27 13:59:20 +00:00
wgs->font_height = tm.tmHeight;
wgs->font_width = get_font_width(wgs, hdc, &tm);
Three more patches from RDB: one to make Atomica work right, one to fiddle with the widths of characters in DBCS screen fonts, and (the big one) one to enable a mode in which resizing the window locks the terminal size and lets the font change, instead of vice versa. That should shut up a few feature requests! [originally from svn r1269]
2001-09-15 15:54:24 +00:00
}
RDB's Unicode patch. Fonts are now used in Unicode mode where possible and we have a single unified means of trying to display any Unicode code point. Instead of the various ad-hoc translation modes we had before, we now have a single `codepage' option which allows us to treat the incoming (and outgoing) text as any given character set, and locally we map that to Unicode and back. [originally from svn r1110]
2001-05-10 08:34:20 +00:00
{
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
CHARSETINFO info;
DWORD cset = tm.tmCharSet;
memset(&info, 0xFF, sizeof(info));
/* !!! Yes the next line is right */
if (cset == OEM_CHARSET)
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
wgs->ucsdata.font_codepage = GetOEMCP();
Formatting: miscellaneous. This patch fixes a few other whitespace and formatting issues which were pointed out by the bulk-reindent or which I spotted in passing, some involving manual editing to break lines more nicely. I think the weirdest hunk in here is the one in windows/window.c TranslateKey() where _half_ of an assignment statement inside an 'if' was on the same line as the trailing paren of the if condition. No idea at all how that one managed to happen!
2022-08-03 19:48:46 +00:00
else if (TranslateCharsetInfo ((DWORD *)(ULONG_PTR)cset,
&info, TCI_SRCCHARSET))
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
wgs->ucsdata.font_codepage = info.ciACP;
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
else
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
wgs->ucsdata.font_codepage = -1;
Run entire source base through GNU indent to tidy up the varying coding styles of the various contributors! Woohoo! [originally from svn r1098]
2001-05-06 14:35:20 +00:00
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
GetCPInfo(wgs->ucsdata.font_codepage, &cpinfo);
wgs->ucsdata.dbcs_screenfont = (cpinfo.MaxCharSize > 1);
RDB's Unicode patch. Fonts are now used in Unicode mode where possible and we have a single unified means of trying to display any Unicode code point. Instead of the various ad-hoc translation modes we had before, we now have a single `codepage' option which allows us to treat the incoming (and outgoing) text as any given character set, and locally we map that to Unicode and back. [originally from svn r1110]
2001-05-10 08:34:20 +00:00
}
Robert de Bath's patch: be much more careful about font heights and widths, including underline mode and OEM/ANSI size mismatch. [originally from svn r405]
2000-03-11 14:15:24 +00:00
Adopt C99 <stdbool.h>'s true/false. This commit includes <stdbool.h> from defs.h and deletes my traditional definitions of TRUE and FALSE, but other than that, it's a 100% mechanical search-and-replace transforming all uses of TRUE and FALSE into the C99-standardised lowercase spellings. No actual types are changed in this commit; that will come next. This is just getting the noise out of the way, so that subsequent commits can have a higher proportion of signal.
2018-10-29 19:50:29 +00:00
f(FONT_UNDERLINE, font->charset, fw_dontcare, true);
Robert de Bath's patch: be much more careful about font heights and widths, including underline mode and OEM/ANSI size mismatch. [originally from svn r405]
2000-03-11 14:15:24 +00:00
RDB's Unicode patch. Fonts are now used in Unicode mode where possible and we have a single unified means of trying to display any Unicode code point. Instead of the various ad-hoc translation modes we had before, we now have a single `codepage' option which allows us to treat the incoming (and outgoing) text as any given character set, and locally we map that to Unicode and back. [originally from svn r1110]
2001-05-10 08:34:20 +00:00
/*
* Some fonts, e.g. 9-pt Courier, draw their underlines
* outside their character cell. We successfully prevent
* screen corruption by clipping the text output, but then
* we lose the underline completely. Here we try to work
* out whether this is such a font, and if it is, we set a
* flag that causes underlines to be drawn by hand.
*
* Having tried other more sophisticated approaches (such
* as examining the TEXTMETRIC structure or requesting the
* height of a string), I think we'll do this the brute
* force way: we create a small bitmap, draw an underlined
* space on it, and test to see whether any pixels are
* foreground-coloured. (Since we expect the underline to
* go all the way across the character cell, we only search
* down a single column of the bitmap, half way across.)
*/
{
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
HDC und_dc;
HBITMAP und_bm, und_oldbm;
int i;
Convert a lot of 'int' variables to 'bool'. My normal habit these days, in new code, is to treat int and bool as _almost_ completely separate types. I'm still willing to use C's implicit test for zero on an integer (e.g. 'if (!blob.len)' is fine, no need to spell it out as blob.len != 0), but generally, if a variable is going to be conceptually a boolean, I like to declare it bool and assign to it using 'true' or 'false' rather than 0 or 1. PuTTY is an exception, because it predates the C99 bool, and I've stuck to its existing coding style even when adding new code to it. But it's been annoying me more and more, so now that I've decided C99 bool is an acceptable thing to require from our toolchain in the first place, here's a quite thorough trawl through the source doing 'boolification'. Many variables and function parameters are now typed as bool rather than int; many assignments of 0 or 1 to those variables are now spelled 'true' or 'false'. I managed this thorough conversion with the help of a custom clang plugin that I wrote to trawl the AST and apply heuristics to point out where things might want changing. So I've even managed to do a decent job on parts of the code I haven't looked at in years! To make the plugin's work easier, I pushed platform front ends generally in the direction of using standard 'bool' in preference to platform-specific boolean types like Windows BOOL or GTK's gboolean; I've left the platform booleans in places they _have_ to be for the platform APIs to work right, but variables only used by my own code have been converted wherever I found them. In a few places there are int values that look very like booleans in _most_ of the places they're used, but have a rarely-used third value, or a distinction between different nonzero values that most users don't care about. In these cases, I've _removed_ uses of 'true' and 'false' for the return values, to emphasise that there's something more subtle going on than a simple boolean answer: - the 'multisel' field in dialog.h's list box structure, for which the GTK front end in particular recognises a difference between 1 and 2 but nearly everything else treats as boolean - the 'urgent' parameter to plug_receive, where 1 vs 2 tells you something about the specific location of the urgent pointer, but most clients only care about 0 vs 'something nonzero' - the return value of wc_match, where -1 indicates a syntax error in the wildcard. - the return values from SSH-1 RSA-key loading functions, which use -1 for 'wrong passphrase' and 0 for all other failures (so any caller which already knows it's not loading an _encrypted private_ key can treat them as boolean) - term->esc_query, and the 'query' parameter in toggle_mode in terminal.c, which _usually_ hold 0 for ESC[123h or 1 for ESC[?123h, but can also hold -1 for some other intervening character that we don't support. In a few places there's an integer that I haven't turned into a bool even though it really _can_ only take values 0 or 1 (and, as above, tried to make the call sites consistent in not calling those values true and false), on the grounds that I thought it would make it more confusing to imply that the 0 value was in some sense 'negative' or bad and the 1 positive or good: - the return value of plug_accepting uses the POSIXish convention of 0=success and nonzero=error; I think if I made it bool then I'd also want to reverse its sense, and that's a job for a separate piece of work. - the 'screen' parameter to lineptr() in terminal.c, where 0 and 1 represent the default and alternate screens. There's no obvious reason why one of those should be considered 'true' or 'positive' or 'success' - they're just indices - so I've left it as int. ssh_scp_recv had particularly confusing semantics for its previous int return value: its call sites used '<= 0' to check for error, but it never actually returned a negative number, just 0 or 1. Now the function and its call sites agree that it's a bool. In a couple of places I've renamed variables called 'ret', because I don't like that name any more - it's unclear whether it means the return value (in preparation) for the _containing_ function or the return value received from a subroutine call, and occasionally I've accidentally used the same variable for both and introduced a bug. So where one of those got in my way, I've renamed it to 'toret' or 'retd' (the latter short for 'returned') in line with my usual modern practice, but I haven't done a thorough job of finding all of them. Finally, one amusing side effect of doing this is that I've had to separate quite a few chained assignments. It used to be perfectly fine to write 'a = b = c = TRUE' when a,b,c were int and TRUE was just a the 'true' defined by stdbool.h, that idiom provokes a warning from gcc: 'suggest parentheses around assignment used as truth value'!
2018-11-02 19:23:19 +00:00
bool gotit;
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
COLORREF c;
und_dc = CreateCompatibleDC(hdc);
windows/window.c: move more variables into WinGuiSeat. In commit f9e572595bb8cb6 I claimed that I'd removed very nearly all the global and static variables from windows/window.c. It turns out that this was wildly overoptimistic - I missed quite a few of them! I'm not quite sure how I managed that; my best guess is that I used an underpowered 'nm' command that failed to find some classes of variable. Some of the remaining function-scope statics were removed completely by commit afb3dab1e97a09f just now. In this commit, I've swept up some more and turn them into fields of WinGuiSeat, where they should have been moved last September. The (hopefully complete this time) list of remaining variables, generated by running this rune in the Windows build directory: nm windows/CMakeFiles/putty.dir/window.c.obj | grep -E '^([^ ]+)? *[bBcCdDgGsS] [^\.]' consists of the following variables which are legitimately global across the whole process and not related to a particular window: - 'hinst' and 'hprev', instance handles for Windows loadable modules - 'classname' in the terminal_window_class_a() and terminal_window_class_w() functions, which allocate a window class reusably - some pointers to Windows API functions retrieved via the DECL_WINDOWS_FUNCTION / GET_WINDOWS_FUNCTION system, such as p_AdjustWindowRectExForDpi and p_FlashWindowEx - some pointers to Windows API functions set up by assigning them at startup to the right one of the ANSI or Unicode version depending on the Windows version, e.g. sw_DefWindowProc and sw_DispatchMessage - 'unicode_window', a boolean flag set at the same time as those sw_Foo function pointers - 'sesslist', storing the last-retrieved version of the saved sessions menu - 'cursor_visible' in show_mouseptr() and 'forced_visible' in update_mouse_pointer(), each of which tracks the cumulative number of times that function has shown or hidden the mouse pointer, so as to manage its effect on the global state updated by ShowCursor - 'trust_icon', loaded from the executable's resources - 'wgslisthead', the list of all active WinGuiSeats - 'wm_mousewheel', the window-message id we use for mouse wheel events and the following which are nothing to do with our code: - '_OptionsStorage' in __local_stdio_printf_options() and __local_stdio_scanf_options(), which I'd never noticed before, but apparently are internal to a standard library header.
2023-05-27 13:59:20 +00:00
und_bm = CreateCompatibleBitmap(
hdc, wgs->font_width, wgs->font_height);
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
und_oldbm = SelectObject(und_dc, und_bm);
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
SelectObject(und_dc, wgs->fonts[FONT_UNDERLINE]);
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
SetTextAlign(und_dc, TA_TOP | TA_LEFT | TA_NOUPDATECP);
SetTextColor(und_dc, RGB(255, 255, 255));
SetBkColor(und_dc, RGB(0, 0, 0));
SetBkMode(und_dc, OPAQUE);
ExtTextOut(und_dc, 0, 0, ETO_OPAQUE, NULL, " ", 1, NULL);
gotit = false;
windows/window.c: move more variables into WinGuiSeat. In commit f9e572595bb8cb6 I claimed that I'd removed very nearly all the global and static variables from windows/window.c. It turns out that this was wildly overoptimistic - I missed quite a few of them! I'm not quite sure how I managed that; my best guess is that I used an underpowered 'nm' command that failed to find some classes of variable. Some of the remaining function-scope statics were removed completely by commit afb3dab1e97a09f just now. In this commit, I've swept up some more and turn them into fields of WinGuiSeat, where they should have been moved last September. The (hopefully complete this time) list of remaining variables, generated by running this rune in the Windows build directory: nm windows/CMakeFiles/putty.dir/window.c.obj | grep -E '^([^ ]+)? *[bBcCdDgGsS] [^\.]' consists of the following variables which are legitimately global across the whole process and not related to a particular window: - 'hinst' and 'hprev', instance handles for Windows loadable modules - 'classname' in the terminal_window_class_a() and terminal_window_class_w() functions, which allocate a window class reusably - some pointers to Windows API functions retrieved via the DECL_WINDOWS_FUNCTION / GET_WINDOWS_FUNCTION system, such as p_AdjustWindowRectExForDpi and p_FlashWindowEx - some pointers to Windows API functions set up by assigning them at startup to the right one of the ANSI or Unicode version depending on the Windows version, e.g. sw_DefWindowProc and sw_DispatchMessage - 'unicode_window', a boolean flag set at the same time as those sw_Foo function pointers - 'sesslist', storing the last-retrieved version of the saved sessions menu - 'cursor_visible' in show_mouseptr() and 'forced_visible' in update_mouse_pointer(), each of which tracks the cumulative number of times that function has shown or hidden the mouse pointer, so as to manage its effect on the global state updated by ShowCursor - 'trust_icon', loaded from the executable's resources - 'wgslisthead', the list of all active WinGuiSeats - 'wm_mousewheel', the window-message id we use for mouse wheel events and the following which are nothing to do with our code: - '_OptionsStorage' in __local_stdio_printf_options() and __local_stdio_scanf_options(), which I'd never noticed before, but apparently are internal to a standard library header.
2023-05-27 13:59:20 +00:00
for (i = 0; i < wgs->font_height; i++) {
c = GetPixel(und_dc, wgs->font_width / 2, i);
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
if (c != RGB(0, 0, 0))
gotit = true;
}
SelectObject(und_dc, und_oldbm);
DeleteObject(und_bm);
DeleteDC(und_dc);
if (!gotit) {
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
wgs->und_mode = UND_LINE;
DeleteObject(wgs->fonts[FONT_UNDERLINE]);
wgs->fonts[FONT_UNDERLINE] = 0;
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
}
RDB's Unicode patch. Fonts are now used in Unicode mode where possible and we have a single unified means of trying to display any Unicode code point. Instead of the various ad-hoc translation modes we had before, we now have a single `codepage' option which allows us to treat the incoming (and outgoing) text as any given character set, and locally we map that to Unicode and back. [originally from svn r1110]
2001-05-10 08:34:20 +00:00
}
Robert de Bath's patch: be much more careful about font heights and widths, including underline mode and OEM/ANSI size mismatch. [originally from svn r405]
2000-03-11 14:15:24 +00:00
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
if (wgs->bold_font_mode == BOLD_FONT) {
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
f(FONT_BOLD, font->charset, fw_bold, false);
Initial checkin: beta 0.43 [originally from svn r11]
1999-01-08 13:02:13 +00:00
}
#undef f
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
wgs->descent = tm.tmAscent + 1;
windows/window.c: move more variables into WinGuiSeat. In commit f9e572595bb8cb6 I claimed that I'd removed very nearly all the global and static variables from windows/window.c. It turns out that this was wildly overoptimistic - I missed quite a few of them! I'm not quite sure how I managed that; my best guess is that I used an underpowered 'nm' command that failed to find some classes of variable. Some of the remaining function-scope statics were removed completely by commit afb3dab1e97a09f just now. In this commit, I've swept up some more and turn them into fields of WinGuiSeat, where they should have been moved last September. The (hopefully complete this time) list of remaining variables, generated by running this rune in the Windows build directory: nm windows/CMakeFiles/putty.dir/window.c.obj | grep -E '^([^ ]+)? *[bBcCdDgGsS] [^\.]' consists of the following variables which are legitimately global across the whole process and not related to a particular window: - 'hinst' and 'hprev', instance handles for Windows loadable modules - 'classname' in the terminal_window_class_a() and terminal_window_class_w() functions, which allocate a window class reusably - some pointers to Windows API functions retrieved via the DECL_WINDOWS_FUNCTION / GET_WINDOWS_FUNCTION system, such as p_AdjustWindowRectExForDpi and p_FlashWindowEx - some pointers to Windows API functions set up by assigning them at startup to the right one of the ANSI or Unicode version depending on the Windows version, e.g. sw_DefWindowProc and sw_DispatchMessage - 'unicode_window', a boolean flag set at the same time as those sw_Foo function pointers - 'sesslist', storing the last-retrieved version of the saved sessions menu - 'cursor_visible' in show_mouseptr() and 'forced_visible' in update_mouse_pointer(), each of which tracks the cumulative number of times that function has shown or hidden the mouse pointer, so as to manage its effect on the global state updated by ShowCursor - 'trust_icon', loaded from the executable's resources - 'wgslisthead', the list of all active WinGuiSeats - 'wm_mousewheel', the window-message id we use for mouse wheel events and the following which are nothing to do with our code: - '_OptionsStorage' in __local_stdio_printf_options() and __local_stdio_scanf_options(), which I'd never noticed before, but apparently are internal to a standard library header.
2023-05-27 13:59:20 +00:00
if (wgs->descent >= wgs->font_height)
wgs->descent = wgs->font_height - 1;
Initial checkin: beta 0.43 [originally from svn r11]
1999-01-08 13:02:13 +00:00
RDB's Unicode patch. Fonts are now used in Unicode mode where possible and we have a single unified means of trying to display any Unicode code point. Instead of the various ad-hoc translation modes we had before, we now have a single `codepage' option which allows us to treat the incoming (and outgoing) text as any given character set, and locally we map that to Unicode and back. [originally from svn r1110]
2001-05-10 08:34:20 +00:00
for (i = 0; i < 3; i++) {
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
if (wgs->fonts[i]) {
if (SelectObject(hdc, wgs->fonts[i]) && GetTextMetrics(hdc, &tm))
windows/window.c: move more variables into WinGuiSeat. In commit f9e572595bb8cb6 I claimed that I'd removed very nearly all the global and static variables from windows/window.c. It turns out that this was wildly overoptimistic - I missed quite a few of them! I'm not quite sure how I managed that; my best guess is that I used an underpowered 'nm' command that failed to find some classes of variable. Some of the remaining function-scope statics were removed completely by commit afb3dab1e97a09f just now. In this commit, I've swept up some more and turn them into fields of WinGuiSeat, where they should have been moved last September. The (hopefully complete this time) list of remaining variables, generated by running this rune in the Windows build directory: nm windows/CMakeFiles/putty.dir/window.c.obj | grep -E '^([^ ]+)? *[bBcCdDgGsS] [^\.]' consists of the following variables which are legitimately global across the whole process and not related to a particular window: - 'hinst' and 'hprev', instance handles for Windows loadable modules - 'classname' in the terminal_window_class_a() and terminal_window_class_w() functions, which allocate a window class reusably - some pointers to Windows API functions retrieved via the DECL_WINDOWS_FUNCTION / GET_WINDOWS_FUNCTION system, such as p_AdjustWindowRectExForDpi and p_FlashWindowEx - some pointers to Windows API functions set up by assigning them at startup to the right one of the ANSI or Unicode version depending on the Windows version, e.g. sw_DefWindowProc and sw_DispatchMessage - 'unicode_window', a boolean flag set at the same time as those sw_Foo function pointers - 'sesslist', storing the last-retrieved version of the saved sessions menu - 'cursor_visible' in show_mouseptr() and 'forced_visible' in update_mouse_pointer(), each of which tracks the cumulative number of times that function has shown or hidden the mouse pointer, so as to manage its effect on the global state updated by ShowCursor - 'trust_icon', loaded from the executable's resources - 'wgslisthead', the list of all active WinGuiSeats - 'wm_mousewheel', the window-message id we use for mouse wheel events and the following which are nothing to do with our code: - '_OptionsStorage' in __local_stdio_printf_options() and __local_stdio_scanf_options(), which I'd never noticed before, but apparently are internal to a standard library header.
2023-05-27 13:59:20 +00:00
fontsize[i] = (get_font_width(wgs, hdc, &tm) +
256 * tm.tmHeight);
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
else
fontsize[i] = -i;
} else
fontsize[i] = -i;
Initial checkin: beta 0.43 [originally from svn r11]
1999-01-08 13:02:13 +00:00
}
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
ReleaseDC(wgs->term_hwnd, hdc);
Initial checkin: beta 0.43 [originally from svn r11]
1999-01-08 13:02:13 +00:00
Don't call DestroyIcon(INVALID_HANDLE_VALUE). The Windows API documentation doesn't explicitly say this is safe, and ea32967044 didn't take care over it.
2019-03-31 22:47:03 +00:00
if (trust_icon != INVALID_HANDLE_VALUE) {
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
DestroyIcon(trust_icon);
Don't call DestroyIcon(INVALID_HANDLE_VALUE). The Windows API documentation doesn't explicitly say this is safe, and ea32967044 didn't take care over it.
2019-03-31 22:47:03 +00:00
}
Slightly nicer trust sigil on Windows. Re-consider the icon in light of the font size, so that we pick the icon whose size mostly closely matches the terminal font, rather than always scaling the default icon.
2019-03-30 15:44:01 +00:00
trust_icon = LoadImage(hinst, MAKEINTRESOURCE(IDI_MAINICON),
windows/window.c: move more variables into WinGuiSeat. In commit f9e572595bb8cb6 I claimed that I'd removed very nearly all the global and static variables from windows/window.c. It turns out that this was wildly overoptimistic - I missed quite a few of them! I'm not quite sure how I managed that; my best guess is that I used an underpowered 'nm' command that failed to find some classes of variable. Some of the remaining function-scope statics were removed completely by commit afb3dab1e97a09f just now. In this commit, I've swept up some more and turn them into fields of WinGuiSeat, where they should have been moved last September. The (hopefully complete this time) list of remaining variables, generated by running this rune in the Windows build directory: nm windows/CMakeFiles/putty.dir/window.c.obj | grep -E '^([^ ]+)? *[bBcCdDgGsS] [^\.]' consists of the following variables which are legitimately global across the whole process and not related to a particular window: - 'hinst' and 'hprev', instance handles for Windows loadable modules - 'classname' in the terminal_window_class_a() and terminal_window_class_w() functions, which allocate a window class reusably - some pointers to Windows API functions retrieved via the DECL_WINDOWS_FUNCTION / GET_WINDOWS_FUNCTION system, such as p_AdjustWindowRectExForDpi and p_FlashWindowEx - some pointers to Windows API functions set up by assigning them at startup to the right one of the ANSI or Unicode version depending on the Windows version, e.g. sw_DefWindowProc and sw_DispatchMessage - 'unicode_window', a boolean flag set at the same time as those sw_Foo function pointers - 'sesslist', storing the last-retrieved version of the saved sessions menu - 'cursor_visible' in show_mouseptr() and 'forced_visible' in update_mouse_pointer(), each of which tracks the cumulative number of times that function has shown or hidden the mouse pointer, so as to manage its effect on the global state updated by ShowCursor - 'trust_icon', loaded from the executable's resources - 'wgslisthead', the list of all active WinGuiSeats - 'wm_mousewheel', the window-message id we use for mouse wheel events and the following which are nothing to do with our code: - '_OptionsStorage' in __local_stdio_printf_options() and __local_stdio_scanf_options(), which I'd never noticed before, but apparently are internal to a standard library header.
2023-05-27 13:59:20 +00:00
IMAGE_ICON, wgs->font_width*2, wgs->font_height,
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
LR_DEFAULTCOLOR);
Slightly nicer trust sigil on Windows. Re-consider the icon in light of the font size, so that we pick the icon whose size mostly closely matches the terminal font, rather than always scaling the default icon.
2019-03-30 15:44:01 +00:00
RDB's Unicode patch. Fonts are now used in Unicode mode where possible and we have a single unified means of trying to display any Unicode code point. Instead of the various ad-hoc translation modes we had before, we now have a single `codepage' option which allows us to treat the incoming (and outgoing) text as any given character set, and locally we map that to Unicode and back. [originally from svn r1110]
2001-05-10 08:34:20 +00:00
if (fontsize[FONT_UNDERLINE] != fontsize[FONT_NORMAL]) {
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
wgs->und_mode = UND_LINE;
DeleteObject(wgs->fonts[FONT_UNDERLINE]);
wgs->fonts[FONT_UNDERLINE] = 0;
Initial checkin: beta 0.43 [originally from svn r11]
1999-01-08 13:02:13 +00:00
}
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
if (wgs->bold_font_mode == BOLD_FONT &&
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
fontsize[FONT_BOLD] != fontsize[FONT_NORMAL]) {
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
wgs->bold_font_mode = BOLD_SHADOW;
DeleteObject(wgs->fonts[FONT_BOLD]);
wgs->fonts[FONT_BOLD] = 0;
Initial checkin: beta 0.43 [originally from svn r11]
1999-01-08 13:02:13 +00:00
}
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
wgs->fontflag[0] = true;
wgs->fontflag[1] = true;
wgs->fontflag[2] = true;
RDB's Unicode patch. Fonts are now used in Unicode mode where possible and we have a single unified means of trying to display any Unicode code point. Instead of the various ad-hoc translation modes we had before, we now have a single `codepage' option which allows us to treat the incoming (and outgoing) text as any given character set, and locally we map that to Unicode and back. [originally from svn r1110]
2001-05-10 08:34:20 +00:00
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
init_ucs(wgs->conf, &wgs->ucsdata);
RDB's Unicode patch. Fonts are now used in Unicode mode where possible and we have a single unified means of trying to display any Unicode code point. Instead of the various ad-hoc translation modes we had before, we now have a single `codepage' option which allows us to treat the incoming (and outgoing) text as any given character set, and locally we map that to Unicode and back. [originally from svn r1110]
2001-05-10 08:34:20 +00:00
}
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
static void another_font(WinGuiSeat *wgs, int fontno)
RDB's Unicode patch. Fonts are now used in Unicode mode where possible and we have a single unified means of trying to display any Unicode code point. Instead of the various ad-hoc translation modes we had before, we now have a single `codepage' option which allows us to treat the incoming (and outgoing) text as any given character set, and locally we map that to Unicode and back. [originally from svn r1110]
2001-05-10 08:34:20 +00:00
{
int basefont;
Post-release destabilisation! Completely remove the struct type 'Config' in putty.h, which stores all PuTTY's settings and includes an arbitrary length limit on every single one of those settings which is stored in string form. In place of it is 'Conf', an opaque data type everywhere outside the new file conf.c, which stores a list of (key, value) pairs in which every key contains an integer identifying a configuration setting, and for some of those integers the key also contains extra parts (so that, for instance, CONF_environmt is a string-to-string mapping). Everywhere that a Config was previously used, a Conf is now; everywhere there was a Config structure copy, conf_copy() is called; every lookup, adjustment, load and save operation on a Config has been rewritten; and there's a mechanism for serialising a Conf into a binary blob and back for use with Duplicate Session. User-visible effects of this change _should_ be minimal, though I don't doubt I've introduced one or two bugs here and there which will eventually be found. The _intended_ visible effects of this change are that all arbitrary limits on configuration strings and lists (e.g. limit on number of port forwardings) should now disappear; that list boxes in the configuration will now be displayed in a sorted order rather than the arbitrary order in which they were added to the list (since the underlying data structure is now a sorted tree234 rather than an ad-hoc comma-separated string); and one more specific change, which is that local and dynamic port forwardings on the same port number are now mutually exclusive in the configuration (putting 'D' in the key rather than the value was a mistake in the first place). One other reorganisation as a result of this is that I've moved all the dialog.c standard handlers (dlg_stdeditbox_handler and friends) out into config.c, because I can't really justify calling them generic any more. When they took a pointer to an arbitrary structure type and the offset of a field within that structure, they were independent of whether that structure was a Config or something completely different, but now they really do expect to talk to a Conf, which can _only_ be used for PuTTY configuration, so I've renamed them all things like conf_editbox_handler and moved them out of the nominally independent dialog-box management module into the PuTTY-specific config.c. [originally from svn r9214]
2011-07-14 18:52:21 +00:00
int fw_dontcare, fw_bold, quality;
Convert a lot of 'int' variables to 'bool'. My normal habit these days, in new code, is to treat int and bool as _almost_ completely separate types. I'm still willing to use C's implicit test for zero on an integer (e.g. 'if (!blob.len)' is fine, no need to spell it out as blob.len != 0), but generally, if a variable is going to be conceptually a boolean, I like to declare it bool and assign to it using 'true' or 'false' rather than 0 or 1. PuTTY is an exception, because it predates the C99 bool, and I've stuck to its existing coding style even when adding new code to it. But it's been annoying me more and more, so now that I've decided C99 bool is an acceptable thing to require from our toolchain in the first place, here's a quite thorough trawl through the source doing 'boolification'. Many variables and function parameters are now typed as bool rather than int; many assignments of 0 or 1 to those variables are now spelled 'true' or 'false'. I managed this thorough conversion with the help of a custom clang plugin that I wrote to trawl the AST and apply heuristics to point out where things might want changing. So I've even managed to do a decent job on parts of the code I haven't looked at in years! To make the plugin's work easier, I pushed platform front ends generally in the direction of using standard 'bool' in preference to platform-specific boolean types like Windows BOOL or GTK's gboolean; I've left the platform booleans in places they _have_ to be for the platform APIs to work right, but variables only used by my own code have been converted wherever I found them. In a few places there are int values that look very like booleans in _most_ of the places they're used, but have a rarely-used third value, or a distinction between different nonzero values that most users don't care about. In these cases, I've _removed_ uses of 'true' and 'false' for the return values, to emphasise that there's something more subtle going on than a simple boolean answer: - the 'multisel' field in dialog.h's list box structure, for which the GTK front end in particular recognises a difference between 1 and 2 but nearly everything else treats as boolean - the 'urgent' parameter to plug_receive, where 1 vs 2 tells you something about the specific location of the urgent pointer, but most clients only care about 0 vs 'something nonzero' - the return value of wc_match, where -1 indicates a syntax error in the wildcard. - the return values from SSH-1 RSA-key loading functions, which use -1 for 'wrong passphrase' and 0 for all other failures (so any caller which already knows it's not loading an _encrypted private_ key can treat them as boolean) - term->esc_query, and the 'query' parameter in toggle_mode in terminal.c, which _usually_ hold 0 for ESC[123h or 1 for ESC[?123h, but can also hold -1 for some other intervening character that we don't support. In a few places there's an integer that I haven't turned into a bool even though it really _can_ only take values 0 or 1 (and, as above, tried to make the call sites consistent in not calling those values true and false), on the grounds that I thought it would make it more confusing to imply that the 0 value was in some sense 'negative' or bad and the 1 positive or good: - the return value of plug_accepting uses the POSIXish convention of 0=success and nonzero=error; I think if I made it bool then I'd also want to reverse its sense, and that's a job for a separate piece of work. - the 'screen' parameter to lineptr() in terminal.c, where 0 and 1 represent the default and alternate screens. There's no obvious reason why one of those should be considered 'true' or 'positive' or 'success' - they're just indices - so I've left it as int. ssh_scp_recv had particularly confusing semantics for its previous int return value: its call sites used '<= 0' to check for error, but it never actually returned a negative number, just 0 or 1. Now the function and its call sites agree that it's a bool. In a couple of places I've renamed variables called 'ret', because I don't like that name any more - it's unclear whether it means the return value (in preparation) for the _containing_ function or the return value received from a subroutine call, and occasionally I've accidentally used the same variable for both and introduced a bug. So where one of those got in my way, I've renamed it to 'toret' or 'retd' (the latter short for 'returned') in line with my usual modern practice, but I haven't done a thorough job of finding all of them. Finally, one amusing side effect of doing this is that I've had to separate quite a few chained assignments. It used to be perfectly fine to write 'a = b = c = TRUE' when a,b,c were int and TRUE was just a the 'true' defined by stdbool.h, that idiom provokes a warning from gcc: 'suggest parentheses around assignment used as truth value'!
2018-11-02 19:23:19 +00:00
int c, w, x;
bool u;
RDB's Unicode patch. Fonts are now used in Unicode mode where possible and we have a single unified means of trying to display any Unicode code point. Instead of the various ad-hoc translation modes we had before, we now have a single `codepage' option which allows us to treat the incoming (and outgoing) text as any given character set, and locally we map that to Unicode and back. [originally from svn r1110]
2001-05-10 08:34:20 +00:00
char *s;
Post-release destabilisation! Completely remove the struct type 'Config' in putty.h, which stores all PuTTY's settings and includes an arbitrary length limit on every single one of those settings which is stored in string form. In place of it is 'Conf', an opaque data type everywhere outside the new file conf.c, which stores a list of (key, value) pairs in which every key contains an integer identifying a configuration setting, and for some of those integers the key also contains extra parts (so that, for instance, CONF_environmt is a string-to-string mapping). Everywhere that a Config was previously used, a Conf is now; everywhere there was a Config structure copy, conf_copy() is called; every lookup, adjustment, load and save operation on a Config has been rewritten; and there's a mechanism for serialising a Conf into a binary blob and back for use with Duplicate Session. User-visible effects of this change _should_ be minimal, though I don't doubt I've introduced one or two bugs here and there which will eventually be found. The _intended_ visible effects of this change are that all arbitrary limits on configuration strings and lists (e.g. limit on number of port forwardings) should now disappear; that list boxes in the configuration will now be displayed in a sorted order rather than the arbitrary order in which they were added to the list (since the underlying data structure is now a sorted tree234 rather than an ad-hoc comma-separated string); and one more specific change, which is that local and dynamic port forwardings on the same port number are now mutually exclusive in the configuration (putting 'D' in the key rather than the value was a mistake in the first place). One other reorganisation as a result of this is that I've moved all the dialog.c standard handlers (dlg_stdeditbox_handler and friends) out into config.c, because I can't really justify calling them generic any more. When they took a pointer to an arbitrary structure type and the offset of a field within that structure, they were independent of whether that structure was a Config or something completely different, but now they really do expect to talk to a Conf, which can _only_ be used for PuTTY configuration, so I've renamed them all things like conf_editbox_handler and moved them out of the nominally independent dialog-box management module into the PuTTY-specific config.c. [originally from svn r9214]
2011-07-14 18:52:21 +00:00
FontSpec *font;
RDB's Unicode patch. Fonts are now used in Unicode mode where possible and we have a single unified means of trying to display any Unicode code point. Instead of the various ad-hoc translation modes we had before, we now have a single `codepage' option which allows us to treat the incoming (and outgoing) text as any given character set, and locally we map that to Unicode and back. [originally from svn r1110]
2001-05-10 08:34:20 +00:00
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
if (fontno < 0 || fontno >= FONT_MAXNO || wgs->fontflag[fontno])
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
return;
RDB's Unicode patch. Fonts are now used in Unicode mode where possible and we have a single unified means of trying to display any Unicode code point. Instead of the various ad-hoc translation modes we had before, we now have a single `codepage' option which allows us to treat the incoming (and outgoing) text as any given character set, and locally we map that to Unicode and back. [originally from svn r1110]
2001-05-10 08:34:20 +00:00
basefont = (fontno & ~(FONT_BOLDUND));
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
if (basefont != fontno && !wgs->fontflag[basefont])
another_font(wgs, basefont);
Robert de Bath's patch: be much more careful about font heights and widths, including underline mode and OEM/ANSI size mismatch. [originally from svn r405]
2000-03-11 14:15:24 +00:00
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
font = conf_get_fontspec(wgs->conf, CONF_font);
Post-release destabilisation! Completely remove the struct type 'Config' in putty.h, which stores all PuTTY's settings and includes an arbitrary length limit on every single one of those settings which is stored in string form. In place of it is 'Conf', an opaque data type everywhere outside the new file conf.c, which stores a list of (key, value) pairs in which every key contains an integer identifying a configuration setting, and for some of those integers the key also contains extra parts (so that, for instance, CONF_environmt is a string-to-string mapping). Everywhere that a Config was previously used, a Conf is now; everywhere there was a Config structure copy, conf_copy() is called; every lookup, adjustment, load and save operation on a Config has been rewritten; and there's a mechanism for serialising a Conf into a binary blob and back for use with Duplicate Session. User-visible effects of this change _should_ be minimal, though I don't doubt I've introduced one or two bugs here and there which will eventually be found. The _intended_ visible effects of this change are that all arbitrary limits on configuration strings and lists (e.g. limit on number of port forwardings) should now disappear; that list boxes in the configuration will now be displayed in a sorted order rather than the arbitrary order in which they were added to the list (since the underlying data structure is now a sorted tree234 rather than an ad-hoc comma-separated string); and one more specific change, which is that local and dynamic port forwardings on the same port number are now mutually exclusive in the configuration (putting 'D' in the key rather than the value was a mistake in the first place). One other reorganisation as a result of this is that I've moved all the dialog.c standard handlers (dlg_stdeditbox_handler and friends) out into config.c, because I can't really justify calling them generic any more. When they took a pointer to an arbitrary structure type and the offset of a field within that structure, they were independent of whether that structure was a Config or something completely different, but now they really do expect to talk to a Conf, which can _only_ be used for PuTTY configuration, so I've renamed them all things like conf_editbox_handler and moved them out of the nominally independent dialog-box management module into the PuTTY-specific config.c. [originally from svn r9214]
2011-07-14 18:52:21 +00:00
if (font->isbold) {
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
fw_dontcare = FW_BOLD;
fw_bold = FW_HEAVY;
RDB's Unicode patch. Fonts are now used in Unicode mode where possible and we have a single unified means of trying to display any Unicode code point. Instead of the various ad-hoc translation modes we had before, we now have a single `codepage' option which allows us to treat the incoming (and outgoing) text as any given character set, and locally we map that to Unicode and back. [originally from svn r1110]
2001-05-10 08:34:20 +00:00
} else {
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
fw_dontcare = FW_DONTCARE;
fw_bold = FW_BOLD;
RDB's Unicode patch. Fonts are now used in Unicode mode where possible and we have a single unified means of trying to display any Unicode code point. Instead of the various ad-hoc translation modes we had before, we now have a single `codepage' option which allows us to treat the incoming (and outgoing) text as any given character set, and locally we map that to Unicode and back. [originally from svn r1110]
2001-05-10 08:34:20 +00:00
}
Post-release destabilisation! Completely remove the struct type 'Config' in putty.h, which stores all PuTTY's settings and includes an arbitrary length limit on every single one of those settings which is stored in string form. In place of it is 'Conf', an opaque data type everywhere outside the new file conf.c, which stores a list of (key, value) pairs in which every key contains an integer identifying a configuration setting, and for some of those integers the key also contains extra parts (so that, for instance, CONF_environmt is a string-to-string mapping). Everywhere that a Config was previously used, a Conf is now; everywhere there was a Config structure copy, conf_copy() is called; every lookup, adjustment, load and save operation on a Config has been rewritten; and there's a mechanism for serialising a Conf into a binary blob and back for use with Duplicate Session. User-visible effects of this change _should_ be minimal, though I don't doubt I've introduced one or two bugs here and there which will eventually be found. The _intended_ visible effects of this change are that all arbitrary limits on configuration strings and lists (e.g. limit on number of port forwardings) should now disappear; that list boxes in the configuration will now be displayed in a sorted order rather than the arbitrary order in which they were added to the list (since the underlying data structure is now a sorted tree234 rather than an ad-hoc comma-separated string); and one more specific change, which is that local and dynamic port forwardings on the same port number are now mutually exclusive in the configuration (putting 'D' in the key rather than the value was a mistake in the first place). One other reorganisation as a result of this is that I've moved all the dialog.c standard handlers (dlg_stdeditbox_handler and friends) out into config.c, because I can't really justify calling them generic any more. When they took a pointer to an arbitrary structure type and the offset of a field within that structure, they were independent of whether that structure was a Config or something completely different, but now they really do expect to talk to a Conf, which can _only_ be used for PuTTY configuration, so I've renamed them all things like conf_editbox_handler and moved them out of the nominally independent dialog-box management module into the PuTTY-specific config.c. [originally from svn r9214]
2011-07-14 18:52:21 +00:00
c = font->charset;
RDB's Unicode patch. Fonts are now used in Unicode mode where possible and we have a single unified means of trying to display any Unicode code point. Instead of the various ad-hoc translation modes we had before, we now have a single `codepage' option which allows us to treat the incoming (and outgoing) text as any given character set, and locally we map that to Unicode and back. [originally from svn r1110]
2001-05-10 08:34:20 +00:00
w = fw_dontcare;
Adopt C99 <stdbool.h>'s true/false. This commit includes <stdbool.h> from defs.h and deletes my traditional definitions of TRUE and FALSE, but other than that, it's a 100% mechanical search-and-replace transforming all uses of TRUE and FALSE into the C99-standardised lowercase spellings. No actual types are changed in this commit; that will come next. This is just getting the noise out of the way, so that subsequent commits can have a higher proportion of signal.
2018-10-29 19:50:29 +00:00
u = false;
Post-release destabilisation! Completely remove the struct type 'Config' in putty.h, which stores all PuTTY's settings and includes an arbitrary length limit on every single one of those settings which is stored in string form. In place of it is 'Conf', an opaque data type everywhere outside the new file conf.c, which stores a list of (key, value) pairs in which every key contains an integer identifying a configuration setting, and for some of those integers the key also contains extra parts (so that, for instance, CONF_environmt is a string-to-string mapping). Everywhere that a Config was previously used, a Conf is now; everywhere there was a Config structure copy, conf_copy() is called; every lookup, adjustment, load and save operation on a Config has been rewritten; and there's a mechanism for serialising a Conf into a binary blob and back for use with Duplicate Session. User-visible effects of this change _should_ be minimal, though I don't doubt I've introduced one or two bugs here and there which will eventually be found. The _intended_ visible effects of this change are that all arbitrary limits on configuration strings and lists (e.g. limit on number of port forwardings) should now disappear; that list boxes in the configuration will now be displayed in a sorted order rather than the arbitrary order in which they were added to the list (since the underlying data structure is now a sorted tree234 rather than an ad-hoc comma-separated string); and one more specific change, which is that local and dynamic port forwardings on the same port number are now mutually exclusive in the configuration (putting 'D' in the key rather than the value was a mistake in the first place). One other reorganisation as a result of this is that I've moved all the dialog.c standard handlers (dlg_stdeditbox_handler and friends) out into config.c, because I can't really justify calling them generic any more. When they took a pointer to an arbitrary structure type and the offset of a field within that structure, they were independent of whether that structure was a Config or something completely different, but now they really do expect to talk to a Conf, which can _only_ be used for PuTTY configuration, so I've renamed them all things like conf_editbox_handler and moved them out of the nominally independent dialog-box management module into the PuTTY-specific config.c. [originally from svn r9214]
2011-07-14 18:52:21 +00:00
s = font->name;
windows/window.c: move more variables into WinGuiSeat. In commit f9e572595bb8cb6 I claimed that I'd removed very nearly all the global and static variables from windows/window.c. It turns out that this was wildly overoptimistic - I missed quite a few of them! I'm not quite sure how I managed that; my best guess is that I used an underpowered 'nm' command that failed to find some classes of variable. Some of the remaining function-scope statics were removed completely by commit afb3dab1e97a09f just now. In this commit, I've swept up some more and turn them into fields of WinGuiSeat, where they should have been moved last September. The (hopefully complete this time) list of remaining variables, generated by running this rune in the Windows build directory: nm windows/CMakeFiles/putty.dir/window.c.obj | grep -E '^([^ ]+)? *[bBcCdDgGsS] [^\.]' consists of the following variables which are legitimately global across the whole process and not related to a particular window: - 'hinst' and 'hprev', instance handles for Windows loadable modules - 'classname' in the terminal_window_class_a() and terminal_window_class_w() functions, which allocate a window class reusably - some pointers to Windows API functions retrieved via the DECL_WINDOWS_FUNCTION / GET_WINDOWS_FUNCTION system, such as p_AdjustWindowRectExForDpi and p_FlashWindowEx - some pointers to Windows API functions set up by assigning them at startup to the right one of the ANSI or Unicode version depending on the Windows version, e.g. sw_DefWindowProc and sw_DispatchMessage - 'unicode_window', a boolean flag set at the same time as those sw_Foo function pointers - 'sesslist', storing the last-retrieved version of the saved sessions menu - 'cursor_visible' in show_mouseptr() and 'forced_visible' in update_mouse_pointer(), each of which tracks the cumulative number of times that function has shown or hidden the mouse pointer, so as to manage its effect on the global state updated by ShowCursor - 'trust_icon', loaded from the executable's resources - 'wgslisthead', the list of all active WinGuiSeats - 'wm_mousewheel', the window-message id we use for mouse wheel events and the following which are nothing to do with our code: - '_OptionsStorage' in __local_stdio_printf_options() and __local_stdio_scanf_options(), which I'd never noticed before, but apparently are internal to a standard library header.
2023-05-27 13:59:20 +00:00
x = wgs->font_width;
RDB's Unicode patch. Fonts are now used in Unicode mode where possible and we have a single unified means of trying to display any Unicode code point. Instead of the various ad-hoc translation modes we had before, we now have a single `codepage' option which allows us to treat the incoming (and outgoing) text as any given character set, and locally we map that to Unicode and back. [originally from svn r1110]
2001-05-10 08:34:20 +00:00
if (fontno & FONT_WIDE)
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
x *= 2;
RDB's Unicode patch. Fonts are now used in Unicode mode where possible and we have a single unified means of trying to display any Unicode code point. Instead of the various ad-hoc translation modes we had before, we now have a single `codepage' option which allows us to treat the incoming (and outgoing) text as any given character set, and locally we map that to Unicode and back. [originally from svn r1110]
2001-05-10 08:34:20 +00:00
if (fontno & FONT_NARROW)
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
x = (x+1)/2;
RDB's Unicode patch. Fonts are now used in Unicode mode where possible and we have a single unified means of trying to display any Unicode code point. Instead of the various ad-hoc translation modes we had before, we now have a single `codepage' option which allows us to treat the incoming (and outgoing) text as any given character set, and locally we map that to Unicode and back. [originally from svn r1110]
2001-05-10 08:34:20 +00:00
if (fontno & FONT_OEM)
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
c = OEM_CHARSET;
RDB's Unicode patch. Fonts are now used in Unicode mode where possible and we have a single unified means of trying to display any Unicode code point. Instead of the various ad-hoc translation modes we had before, we now have a single `codepage' option which allows us to treat the incoming (and outgoing) text as any given character set, and locally we map that to Unicode and back. [originally from svn r1110]
2001-05-10 08:34:20 +00:00
if (fontno & FONT_BOLD)
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
w = fw_bold;
RDB's Unicode patch. Fonts are now used in Unicode mode where possible and we have a single unified means of trying to display any Unicode code point. Instead of the various ad-hoc translation modes we had before, we now have a single `codepage' option which allows us to treat the incoming (and outgoing) text as any given character set, and locally we map that to Unicode and back. [originally from svn r1110]
2001-05-10 08:34:20 +00:00
if (fontno & FONT_UNDERLINE)
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
u = true;
RDB's Unicode patch. Fonts are now used in Unicode mode where possible and we have a single unified means of trying to display any Unicode code point. Instead of the various ad-hoc translation modes we had before, we now have a single `codepage' option which allows us to treat the incoming (and outgoing) text as any given character set, and locally we map that to Unicode and back. [originally from svn r1110]
2001-05-10 08:34:20 +00:00
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
quality = conf_get_int(wgs->conf, CONF_font_quality);
Post-release destabilisation! Completely remove the struct type 'Config' in putty.h, which stores all PuTTY's settings and includes an arbitrary length limit on every single one of those settings which is stored in string form. In place of it is 'Conf', an opaque data type everywhere outside the new file conf.c, which stores a list of (key, value) pairs in which every key contains an integer identifying a configuration setting, and for some of those integers the key also contains extra parts (so that, for instance, CONF_environmt is a string-to-string mapping). Everywhere that a Config was previously used, a Conf is now; everywhere there was a Config structure copy, conf_copy() is called; every lookup, adjustment, load and save operation on a Config has been rewritten; and there's a mechanism for serialising a Conf into a binary blob and back for use with Duplicate Session. User-visible effects of this change _should_ be minimal, though I don't doubt I've introduced one or two bugs here and there which will eventually be found. The _intended_ visible effects of this change are that all arbitrary limits on configuration strings and lists (e.g. limit on number of port forwardings) should now disappear; that list boxes in the configuration will now be displayed in a sorted order rather than the arbitrary order in which they were added to the list (since the underlying data structure is now a sorted tree234 rather than an ad-hoc comma-separated string); and one more specific change, which is that local and dynamic port forwardings on the same port number are now mutually exclusive in the configuration (putting 'D' in the key rather than the value was a mistake in the first place). One other reorganisation as a result of this is that I've moved all the dialog.c standard handlers (dlg_stdeditbox_handler and friends) out into config.c, because I can't really justify calling them generic any more. When they took a pointer to an arbitrary structure type and the offset of a field within that structure, they were independent of whether that structure was a Config or something completely different, but now they really do expect to talk to a Conf, which can _only_ be used for PuTTY configuration, so I've renamed them all things like conf_editbox_handler and moved them out of the nominally independent dialog-box management module into the PuTTY-specific config.c. [originally from svn r9214]
2011-07-14 18:52:21 +00:00
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
wgs->fonts[fontno] =
windows/window.c: move more variables into WinGuiSeat. In commit f9e572595bb8cb6 I claimed that I'd removed very nearly all the global and static variables from windows/window.c. It turns out that this was wildly overoptimistic - I missed quite a few of them! I'm not quite sure how I managed that; my best guess is that I used an underpowered 'nm' command that failed to find some classes of variable. Some of the remaining function-scope statics were removed completely by commit afb3dab1e97a09f just now. In this commit, I've swept up some more and turn them into fields of WinGuiSeat, where they should have been moved last September. The (hopefully complete this time) list of remaining variables, generated by running this rune in the Windows build directory: nm windows/CMakeFiles/putty.dir/window.c.obj | grep -E '^([^ ]+)? *[bBcCdDgGsS] [^\.]' consists of the following variables which are legitimately global across the whole process and not related to a particular window: - 'hinst' and 'hprev', instance handles for Windows loadable modules - 'classname' in the terminal_window_class_a() and terminal_window_class_w() functions, which allocate a window class reusably - some pointers to Windows API functions retrieved via the DECL_WINDOWS_FUNCTION / GET_WINDOWS_FUNCTION system, such as p_AdjustWindowRectExForDpi and p_FlashWindowEx - some pointers to Windows API functions set up by assigning them at startup to the right one of the ANSI or Unicode version depending on the Windows version, e.g. sw_DefWindowProc and sw_DispatchMessage - 'unicode_window', a boolean flag set at the same time as those sw_Foo function pointers - 'sesslist', storing the last-retrieved version of the saved sessions menu - 'cursor_visible' in show_mouseptr() and 'forced_visible' in update_mouse_pointer(), each of which tracks the cumulative number of times that function has shown or hidden the mouse pointer, so as to manage its effect on the global state updated by ShowCursor - 'trust_icon', loaded from the executable's resources - 'wgslisthead', the list of all active WinGuiSeats - 'wm_mousewheel', the window-message id we use for mouse wheel events and the following which are nothing to do with our code: - '_OptionsStorage' in __local_stdio_printf_options() and __local_stdio_scanf_options(), which I'd never noticed before, but apparently are internal to a standard library header.
2023-05-27 13:59:20 +00:00
CreateFont(wgs->font_height * (1 + !!(fontno & FONT_HIGH)), x, 0, 0, w,
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
false, u, false, c, OUT_DEFAULT_PRECIS,
CLIP_DEFAULT_PRECIS, FONT_QUALITY(quality),
DEFAULT_PITCH | FF_DONTCARE, s);
RDB's Unicode patch. Fonts are now used in Unicode mode where possible and we have a single unified means of trying to display any Unicode code point. Instead of the various ad-hoc translation modes we had before, we now have a single `codepage' option which allows us to treat the incoming (and outgoing) text as any given character set, and locally we map that to Unicode and back. [originally from svn r1110]
2001-05-10 08:34:20 +00:00
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
wgs->fontflag[fontno] = true;
RDB's Unicode patch. Fonts are now used in Unicode mode where possible and we have a single unified means of trying to display any Unicode code point. Instead of the various ad-hoc translation modes we had before, we now have a single `codepage' option which allows us to treat the incoming (and outgoing) text as any given character set, and locally we map that to Unicode and back. [originally from svn r1110]
2001-05-10 08:34:20 +00:00
}
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
static void deinit_fonts(WinGuiSeat *wgs)
RDB's Unicode patch. Fonts are now used in Unicode mode where possible and we have a single unified means of trying to display any Unicode code point. Instead of the various ad-hoc translation modes we had before, we now have a single `codepage' option which allows us to treat the incoming (and outgoing) text as any given character set, and locally we map that to Unicode and back. [originally from svn r1110]
2001-05-10 08:34:20 +00:00
{
int i;
for (i = 0; i < FONT_MAXNO; i++) {
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
if (wgs->fonts[i])
DeleteObject(wgs->fonts[i]);
wgs->fonts[i] = 0;
wgs->fontflag[i] = false;
Initial checkin: beta 0.43 [originally from svn r11]
1999-01-08 13:02:13 +00:00
}
Slightly nicer trust sigil on Windows. Re-consider the icon in light of the font size, so that we pick the icon whose size mostly closely matches the terminal font, rather than always scaling the default icon.
2019-03-30 15:44:01 +00:00
Don't call DestroyIcon(INVALID_HANDLE_VALUE). The Windows API documentation doesn't explicitly say this is safe, and ea32967044 didn't take care over it.
2019-03-31 22:47:03 +00:00
if (trust_icon != INVALID_HANDLE_VALUE) {
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
DestroyIcon(trust_icon);
Don't call DestroyIcon(INVALID_HANDLE_VALUE). The Windows API documentation doesn't explicitly say this is safe, and ea32967044 didn't take care over it.
2019-03-31 22:47:03 +00:00
}
Slightly nicer trust sigil on Windows. Re-consider the icon in light of the font size, so that we pick the icon whose size mostly closely matches the terminal font, rather than always scaling the default icon.
2019-03-30 15:44:01 +00:00
trust_icon = INVALID_HANDLE_VALUE;
Initial checkin: beta 0.43 [originally from svn r11]
1999-01-08 13:02:13 +00:00
}
Remove the 'Frontend' type and replace it with a vtable. After the recent Seat and LogContext revamps, _nearly_ all the remaining uses of the type 'Frontend' were in terminal.c, which needs all sorts of interactions with the GUI window the terminal lives in, from the obvious (actually drawing text on the window, reading and writing the clipboard) to the obscure (minimising, maximising and moving the window in response to particular escape sequences). All of those functions are now provided by an abstraction called TermWin. The few remaining uses of Frontend after _that_ are internal to a particular platform directory, so as to spread the implementation of that particular kind of Frontend between multiple source files; so I've renamed all of those so that they take a more specifically named type that refers to the particular implementation rather than the general abstraction. So now the name 'Frontend' no longer exists in the code base at all, and everywhere one used to be used, it's completely clear whether it was operating in one of Frontend's three abstract roles (and if so, which), or whether it was specific to a particular implementation. Another type that's disappeared is 'Context', which used to be a typedef defined to something different on each platform, describing whatever short-lived resources were necessary to draw on the terminal window: the front end would provide a ready-made one when calling term_paint, and the terminal could request one with get_ctx/free_ctx if it wanted to do proactive window updates. Now that drawing context lives inside the TermWin itself, because there was never any need to have two of those contexts live at the same time. (Another minor API change is that the window-title functions - both reading and writing - have had a missing 'const' added to their char * parameters / return values.) I don't expect this change to enable any particularly interesting new functionality (in particular, I have no plans that need more than one implementation of TermWin in the same application). But it completes the tidying-up that began with the Seat and LogContext rework.
2018-10-25 17:44:04 +00:00
static void wintw_request_resize(TermWin *tw, int w, int h)
Run entire source base through GNU indent to tidy up the varying coding styles of the various contributors! Woohoo! [originally from svn r1098]
2001-05-06 14:35:20 +00:00
{
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
WinGuiSeat *wgs = container_of(tw, WinGuiSeat, termwin);
New backend function to disable resizing. Some protocols such as SUPDUP does not support resizing the terminal.
2020-02-14 12:49:56 +00:00
const struct BackendVtable *vt;
RDB's patch: - use WM_TIMER for various things (blinking cursor; updates while moving/sizing; coping with overloading influx of netevents) - clip text output to avoid underlines outside character cell - even more careful font selection (we can now do OEMANSI by default) - a few extra keyboard mappings from the VTxxx terminals [originally from svn r418]
2000-03-17 10:34:41 +00:00
int width, height;
Windows: fix terminal hang with resize forbidden. A server attempt to resize the window (for instance via DECCOLM) when "When window is resized" was set to "Forbid resizing completely" would cause all terminal output to be suspended, due to the resize attempt never being acknowledged. (There are other code paths like this, which I've fixed for completeness, but I don't think they have any effect: the terminal filters out resize attempts to the current size before this point, and even if a server can get such a request through the SUPDUP protocol, the test for that is wrong and will never fire -- this needs fixing separately.)
2022-11-02 23:51:57 +00:00
int resize_action = conf_get_int(wgs->conf, CONF_resize_action);
bool deny_resize = false;
/* Suppress server-originated resizing attempts if local resizing
* is disabled entirely, or if it's supposed to change
* rows/columns but the window is maximised. */
if (resize_action == RESIZE_DISABLED
|| (resize_action == RESIZE_TERM && IsZoomed(wgs->term_hwnd))) {
deny_resize = true;
Three more patches from RDB: one to make Atomica work right, one to fiddle with the widths of characters in DBCS screen fonts, and (the big one) one to enable a mode in which resizing the window locks the terminal size and lets the font change, instead of vice versa. That should shut up a few feature requests! [originally from svn r1269]
2001-09-15 15:54:24 +00:00
}
Run entire source base through GNU indent to tidy up the varying coding styles of the various contributors! Woohoo! [originally from svn r1098]
2001-05-06 14:35:20 +00:00
New backend function to disable resizing. Some protocols such as SUPDUP does not support resizing the terminal.
2020-02-14 12:49:56 +00:00
vt = backend_vt_from_proto(be_default_protocol);
if (vt && vt->flags & BACKEND_RESIZE_FORBIDDEN)
Windows: fix terminal hang with resize forbidden. A server attempt to resize the window (for instance via DECCOLM) when "When window is resized" was set to "Forbid resizing completely" would cause all terminal output to be suspended, due to the resize attempt never being acknowledged. (There are other code paths like this, which I've fixed for completeness, but I don't think they have any effect: the terminal filters out resize attempts to the current size before this point, and even if a server can get such a request through the SUPDUP protocol, the test for that is wrong and will never fire -- this needs fixing separately.)
2022-11-02 23:51:57 +00:00
deny_resize = true;
if (h == wgs->term->rows && w == wgs->term->cols) deny_resize = true;
/* We still need to acknowledge a suppressed resize attempt. */
if (deny_resize) {
term_resize_request_completed(wgs->term);
New backend function to disable resizing. Some protocols such as SUPDUP does not support resizing the terminal.
2020-02-14 12:49:56 +00:00
return;
Windows: fix terminal hang with resize forbidden. A server attempt to resize the window (for instance via DECCOLM) when "When window is resized" was set to "Forbid resizing completely" would cause all terminal output to be suspended, due to the resize attempt never being acknowledged. (There are other code paths like this, which I've fixed for completeness, but I don't think they have any effect: the terminal filters out resize attempts to the current size before this point, and even if a server can get such a request through the SUPDUP protocol, the test for that is wrong and will never fire -- this needs fixing separately.)
2022-11-02 23:51:57 +00:00
}
Three more patches from RDB: one to make Atomica work right, one to fiddle with the widths of characters in DBCS screen fonts, and (the big one) one to enable a mode in which resizing the window locks the terminal size and lets the font change, instead of vice versa. That should shut up a few feature requests! [originally from svn r1269]
2001-09-15 15:54:24 +00:00
/* Sanity checks ... */
{
Windows: remove static variables in wintw_request_resize. Those have been there since around 2001. They're in a piece of code that calls get_fullscreen_rect to find the overall screen size, and then prevents attempts to resize the window larger than that. The static variables were arranging that we don't have to call get_fullscreen_rect more than once. But, firstly, computers are faster 20 years on; secondly, remote window-resize requests are intentionally rate-limited (as of commit d74308e90e3813a), so this shouldn't be the limiting factor anyway; and thirdly, multi-monitor support has appeared since then, which means that if the window has been dragged from one monitor to another then get_fullscreen_rect might _legitimately_ return a different bounding rectangle when called a second time. So we should just do the full check every time unconditionally.
2022-09-13 10:11:59 +00:00
RECT ss;
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
if (get_fullscreen_rect(wgs, &ss)) {
Windows: remove static variables in wintw_request_resize. Those have been there since around 2001. They're in a piece of code that calls get_fullscreen_rect to find the overall screen size, and then prevents attempts to resize the window larger than that. The static variables were arranging that we don't have to call get_fullscreen_rect more than once. But, firstly, computers are faster 20 years on; secondly, remote window-resize requests are intentionally rate-limited (as of commit d74308e90e3813a), so this shouldn't be the limiting factor anyway; and thirdly, multi-monitor support has appeared since then, which means that if the window has been dragged from one monitor to another then get_fullscreen_rect might _legitimately_ return a different bounding rectangle when called a second time. So we should just do the full check every time unconditionally.
2022-09-13 10:11:59 +00:00
/* Make sure the values aren't too big */
windows/window.c: move more variables into WinGuiSeat. In commit f9e572595bb8cb6 I claimed that I'd removed very nearly all the global and static variables from windows/window.c. It turns out that this was wildly overoptimistic - I missed quite a few of them! I'm not quite sure how I managed that; my best guess is that I used an underpowered 'nm' command that failed to find some classes of variable. Some of the remaining function-scope statics were removed completely by commit afb3dab1e97a09f just now. In this commit, I've swept up some more and turn them into fields of WinGuiSeat, where they should have been moved last September. The (hopefully complete this time) list of remaining variables, generated by running this rune in the Windows build directory: nm windows/CMakeFiles/putty.dir/window.c.obj | grep -E '^([^ ]+)? *[bBcCdDgGsS] [^\.]' consists of the following variables which are legitimately global across the whole process and not related to a particular window: - 'hinst' and 'hprev', instance handles for Windows loadable modules - 'classname' in the terminal_window_class_a() and terminal_window_class_w() functions, which allocate a window class reusably - some pointers to Windows API functions retrieved via the DECL_WINDOWS_FUNCTION / GET_WINDOWS_FUNCTION system, such as p_AdjustWindowRectExForDpi and p_FlashWindowEx - some pointers to Windows API functions set up by assigning them at startup to the right one of the ANSI or Unicode version depending on the Windows version, e.g. sw_DefWindowProc and sw_DispatchMessage - 'unicode_window', a boolean flag set at the same time as those sw_Foo function pointers - 'sesslist', storing the last-retrieved version of the saved sessions menu - 'cursor_visible' in show_mouseptr() and 'forced_visible' in update_mouse_pointer(), each of which tracks the cumulative number of times that function has shown or hidden the mouse pointer, so as to manage its effect on the global state updated by ShowCursor - 'trust_icon', loaded from the executable's resources - 'wgslisthead', the list of all active WinGuiSeats - 'wm_mousewheel', the window-message id we use for mouse wheel events and the following which are nothing to do with our code: - '_OptionsStorage' in __local_stdio_printf_options() and __local_stdio_scanf_options(), which I'd never noticed before, but apparently are internal to a standard library header.
2023-05-27 13:59:20 +00:00
width = (ss.right - ss.left - wgs->extra_width) / 4;
height = (ss.bottom - ss.top - wgs->extra_height) / 6;
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
wintw_request_resize: add missing NACKs. In cases where we refuse a resize request, either because it's too large or because the window is not currently resizable due to being maximised, we were failing to communicate that back to the Terminal so that it could stop waiting for the resize and resume processing input.
2022-09-13 11:30:42 +00:00
if (w > width || h > height) {
Merge resizing NACK fix from 'pre-0.78'.
2022-09-13 11:34:02 +00:00
term_resize_request_completed(wgs->term);
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
return;
wintw_request_resize: add missing NACKs. In cases where we refuse a resize request, either because it's too large or because the window is not currently resizable due to being maximised, we were failing to communicate that back to the Terminal so that it could stop waiting for the resize and resume processing input.
2022-09-13 11:30:42 +00:00
}
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
if (w < 15)
w = 15;
if (h < 1)
h = 1;
}
Robert de Bath's Big Patch, part 1 [originally from svn r516]
2000-07-26 12:13:51 +00:00
}
RDB's patch: - use WM_TIMER for various things (blinking cursor; updates while moving/sizing; coping with overloading influx of netevents) - clip text output to avoid underlines outside character cell - even more careful font selection (we can now do OEMANSI by default) - a few extra keyboard mappings from the VTxxx terminals [originally from svn r418]
2000-03-17 10:34:41 +00:00
Windows: fix terminal hang with resize forbidden. A server attempt to resize the window (for instance via DECCOLM) when "When window is resized" was set to "Forbid resizing completely" would cause all terminal output to be suspended, due to the resize attempt never being acknowledged. (There are other code paths like this, which I've fixed for completeness, but I don't think they have any effect: the terminal filters out resize attempts to the current size before this point, and even if a server can get such a request through the SUPDUP protocol, the test for that is wrong and will never fire -- this needs fixing separately.)
2022-11-02 23:51:57 +00:00
if (resize_action != RESIZE_FONT && !IsZoomed(wgs->term_hwnd)) {
windows/window.c: move more variables into WinGuiSeat. In commit f9e572595bb8cb6 I claimed that I'd removed very nearly all the global and static variables from windows/window.c. It turns out that this was wildly overoptimistic - I missed quite a few of them! I'm not quite sure how I managed that; my best guess is that I used an underpowered 'nm' command that failed to find some classes of variable. Some of the remaining function-scope statics were removed completely by commit afb3dab1e97a09f just now. In this commit, I've swept up some more and turn them into fields of WinGuiSeat, where they should have been moved last September. The (hopefully complete this time) list of remaining variables, generated by running this rune in the Windows build directory: nm windows/CMakeFiles/putty.dir/window.c.obj | grep -E '^([^ ]+)? *[bBcCdDgGsS] [^\.]' consists of the following variables which are legitimately global across the whole process and not related to a particular window: - 'hinst' and 'hprev', instance handles for Windows loadable modules - 'classname' in the terminal_window_class_a() and terminal_window_class_w() functions, which allocate a window class reusably - some pointers to Windows API functions retrieved via the DECL_WINDOWS_FUNCTION / GET_WINDOWS_FUNCTION system, such as p_AdjustWindowRectExForDpi and p_FlashWindowEx - some pointers to Windows API functions set up by assigning them at startup to the right one of the ANSI or Unicode version depending on the Windows version, e.g. sw_DefWindowProc and sw_DispatchMessage - 'unicode_window', a boolean flag set at the same time as those sw_Foo function pointers - 'sesslist', storing the last-retrieved version of the saved sessions menu - 'cursor_visible' in show_mouseptr() and 'forced_visible' in update_mouse_pointer(), each of which tracks the cumulative number of times that function has shown or hidden the mouse pointer, so as to manage its effect on the global state updated by ShowCursor - 'trust_icon', loaded from the executable's resources - 'wgslisthead', the list of all active WinGuiSeats - 'wm_mousewheel', the window-message id we use for mouse wheel events and the following which are nothing to do with our code: - '_OptionsStorage' in __local_stdio_printf_options() and __local_stdio_scanf_options(), which I'd never noticed before, but apparently are internal to a standard library header.
2023-05-27 13:59:20 +00:00
width = wgs->extra_width + wgs->font_width * w;
height = wgs->extra_height + wgs->font_height * h;
Initial checkin: beta 0.43 [originally from svn r11]
1999-01-08 13:02:13 +00:00
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
SetWindowPos(wgs->term_hwnd, NULL, 0, 0, width, height,
Formatting: realign run-on parenthesised stuff. My bulk indentation check also turned up a lot of cases where a run-on function call or if statement didn't have its later lines aligned correctly relative to the open paren. I think this is quite easy to do by getting things out of sync (editing the first line of the function call and forgetting to update the rest, perhaps even because you never _saw_ the rest during a search-replace). But a few didn't quite fit into that pattern, in particular an outright misleading case in unix/askpass.c where the second line of a call was aligned neatly below the _wrong_ one of the open parens on the opening line. Restored as many alignments as I could easily find.
2022-08-03 19:48:46 +00:00
SWP_NOACTIVATE | SWP_NOCOPYBITS |
SWP_NOMOVE | SWP_NOZORDER);
Windows: make 'resize by changing font' work again. It looks as if I broke this some time around commit cfc902361633915, when I stopped proactively calling term_size() in advance of resizing the window. A side effect was that I also stopped calling it at all in the case where we're _not_ resizing the window (because changing the size of the terminal means adapting the font size to fit a different amount of stuff in the existing window). Fixed by moving all the new machinery inside the 'actually resize the window' branch of the if statement, and restoring the previous behaviour in the other branch, this time with a comment that will hopefully stop me making the same mistake again.
2022-01-08 13:48:41 +00:00
} else {
/*
* If we're resizing by changing the font, we must tell the
* terminal the new size immediately, so that reset_window
* will know what to do.
*/
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
term_size(wgs->term, h, w, conf_get_int(wgs->conf, CONF_savelines));
reset_window(wgs, 0);
Windows: make 'resize by changing font' work again. It looks as if I broke this some time around commit cfc902361633915, when I stopped proactively calling term_size() in advance of resizing the window. A side effect was that I also stopped calling it at all in the case where we're _not_ resizing the window (because changing the size of the terminal means adapting the font size to fit a different amount of stuff in the existing window). Fixed by moving all the new machinery inside the 'actually resize the window' branch of the if statement, and restoring the previous behaviour in the other branch, this time with a comment that will hopefully stop me making the same mistake again.
2022-01-08 13:48:41 +00:00
}
Windows: try to send only one term_size on request_resize. Previously, the Windows implementation of win_request_resize would call term_size() to tell the terminal about its new size, _before_ calling SetWindowPos to actually change the window size. If SetWindowPos ends up not getting the exact window size it asks for, Windows notifies the application by sending back a WM_SIZE message - synchronously, by calling back to the window procedure from within SetWindowPos. So after the first over-optimistic term_size(), the WM_SIZE handler would trigger a second one, resetting the terminal again to the _actual_ size. This was more or less harmless, since current handling of terminal resizes is such that no terminal data gets too confused: any lines pushed into the scrollback by the first term_size will be pulled back out by the second one if needed (or vice versa), and since commit 271de3e4ec5682e, individual termlines are not eagerly truncated by resizing them twice. However, it's more work than we really wanted to be doing, and it seems presumptuous to send term_size() before we know it's right! So now we send term_size() after SetWindowPos returns, unless it already got sent by a re-entrant call to the WM_SIZE handler _before_ SetWindowPos returned. That way, the terminal should get exactly one term_size() call in response to win_request_resize(), whether it got the size it was expecting or not.
2021-12-13 06:54:49 +00:00
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
term_resize_request_completed(wgs->term);
InvalidateRect(wgs->term_hwnd, NULL, true);
Three more patches from RDB: one to make Atomica work right, one to fiddle with the widths of characters in DBCS screen fonts, and (the big one) one to enable a mode in which resizing the window locks the terminal size and lets the font change, instead of vice versa. That should shut up a few feature requests! [originally from svn r1269]
2001-09-15 15:54:24 +00:00
}
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
static void recompute_window_offset(WinGuiSeat *wgs)
Fix missing recalculation of window border. If you open a Windows PuTTY session and press Win+Right, Windows auto-sizes the terminal window to cover the right-hand half of the screen. Then if you press Win+Up it will be auto-sized again, this time to the top right quadrant. In the second resize (if you don't have font-based resize handling turned on), the WM_SIZE handler code will find a path through the twisty maze of ifs on which the border between the text and the client-area edges is not recomputed, or invalidated, or redrawn. So you can end up with half a line of text from the previous window size still visible at the bottom of the new window. Fixed by factoring out the offset-recomputation code from the large and complicated reset_window(), so that I can call just that snippet on the dangerous code path.
2021-02-12 17:50:47 +00:00
{
RECT cr;
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
GetClientRect(wgs->term_hwnd, &cr);
Fix missing recalculation of window border. If you open a Windows PuTTY session and press Win+Right, Windows auto-sizes the terminal window to cover the right-hand half of the screen. Then if you press Win+Up it will be auto-sized again, this time to the top right quadrant. In the second resize (if you don't have font-based resize handling turned on), the WM_SIZE handler code will find a path through the twisty maze of ifs on which the border between the text and the client-area edges is not recomputed, or invalidated, or redrawn. So you can end up with half a line of text from the previous window size still visible at the bottom of the new window. Fixed by factoring out the offset-recomputation code from the large and complicated reset_window(), so that I can call just that snippet on the dangerous code path.
2021-02-12 17:50:47 +00:00
int win_width = cr.right - cr.left;
int win_height = cr.bottom - cr.top;
windows/window.c: move more variables into WinGuiSeat. In commit f9e572595bb8cb6 I claimed that I'd removed very nearly all the global and static variables from windows/window.c. It turns out that this was wildly overoptimistic - I missed quite a few of them! I'm not quite sure how I managed that; my best guess is that I used an underpowered 'nm' command that failed to find some classes of variable. Some of the remaining function-scope statics were removed completely by commit afb3dab1e97a09f just now. In this commit, I've swept up some more and turn them into fields of WinGuiSeat, where they should have been moved last September. The (hopefully complete this time) list of remaining variables, generated by running this rune in the Windows build directory: nm windows/CMakeFiles/putty.dir/window.c.obj | grep -E '^([^ ]+)? *[bBcCdDgGsS] [^\.]' consists of the following variables which are legitimately global across the whole process and not related to a particular window: - 'hinst' and 'hprev', instance handles for Windows loadable modules - 'classname' in the terminal_window_class_a() and terminal_window_class_w() functions, which allocate a window class reusably - some pointers to Windows API functions retrieved via the DECL_WINDOWS_FUNCTION / GET_WINDOWS_FUNCTION system, such as p_AdjustWindowRectExForDpi and p_FlashWindowEx - some pointers to Windows API functions set up by assigning them at startup to the right one of the ANSI or Unicode version depending on the Windows version, e.g. sw_DefWindowProc and sw_DispatchMessage - 'unicode_window', a boolean flag set at the same time as those sw_Foo function pointers - 'sesslist', storing the last-retrieved version of the saved sessions menu - 'cursor_visible' in show_mouseptr() and 'forced_visible' in update_mouse_pointer(), each of which tracks the cumulative number of times that function has shown or hidden the mouse pointer, so as to manage its effect on the global state updated by ShowCursor - 'trust_icon', loaded from the executable's resources - 'wgslisthead', the list of all active WinGuiSeats - 'wm_mousewheel', the window-message id we use for mouse wheel events and the following which are nothing to do with our code: - '_OptionsStorage' in __local_stdio_printf_options() and __local_stdio_scanf_options(), which I'd never noticed before, but apparently are internal to a standard library header.
2023-05-27 13:59:20 +00:00
int new_offset_width = (win_width-wgs->font_width*wgs->term->cols)/2;
int new_offset_height = (win_height-wgs->font_height*wgs->term->rows)/2;
Fix missing recalculation of window border. If you open a Windows PuTTY session and press Win+Right, Windows auto-sizes the terminal window to cover the right-hand half of the screen. Then if you press Win+Up it will be auto-sized again, this time to the top right quadrant. In the second resize (if you don't have font-based resize handling turned on), the WM_SIZE handler code will find a path through the twisty maze of ifs on which the border between the text and the client-area edges is not recomputed, or invalidated, or redrawn. So you can end up with half a line of text from the previous window size still visible at the bottom of the new window. Fixed by factoring out the offset-recomputation code from the large and complicated reset_window(), so that I can call just that snippet on the dangerous code path.
2021-02-12 17:50:47 +00:00
windows/window.c: move more variables into WinGuiSeat. In commit f9e572595bb8cb6 I claimed that I'd removed very nearly all the global and static variables from windows/window.c. It turns out that this was wildly overoptimistic - I missed quite a few of them! I'm not quite sure how I managed that; my best guess is that I used an underpowered 'nm' command that failed to find some classes of variable. Some of the remaining function-scope statics were removed completely by commit afb3dab1e97a09f just now. In this commit, I've swept up some more and turn them into fields of WinGuiSeat, where they should have been moved last September. The (hopefully complete this time) list of remaining variables, generated by running this rune in the Windows build directory: nm windows/CMakeFiles/putty.dir/window.c.obj | grep -E '^([^ ]+)? *[bBcCdDgGsS] [^\.]' consists of the following variables which are legitimately global across the whole process and not related to a particular window: - 'hinst' and 'hprev', instance handles for Windows loadable modules - 'classname' in the terminal_window_class_a() and terminal_window_class_w() functions, which allocate a window class reusably - some pointers to Windows API functions retrieved via the DECL_WINDOWS_FUNCTION / GET_WINDOWS_FUNCTION system, such as p_AdjustWindowRectExForDpi and p_FlashWindowEx - some pointers to Windows API functions set up by assigning them at startup to the right one of the ANSI or Unicode version depending on the Windows version, e.g. sw_DefWindowProc and sw_DispatchMessage - 'unicode_window', a boolean flag set at the same time as those sw_Foo function pointers - 'sesslist', storing the last-retrieved version of the saved sessions menu - 'cursor_visible' in show_mouseptr() and 'forced_visible' in update_mouse_pointer(), each of which tracks the cumulative number of times that function has shown or hidden the mouse pointer, so as to manage its effect on the global state updated by ShowCursor - 'trust_icon', loaded from the executable's resources - 'wgslisthead', the list of all active WinGuiSeats - 'wm_mousewheel', the window-message id we use for mouse wheel events and the following which are nothing to do with our code: - '_OptionsStorage' in __local_stdio_printf_options() and __local_stdio_scanf_options(), which I'd never noticed before, but apparently are internal to a standard library header.
2023-05-27 13:59:20 +00:00
if (wgs->offset_width != new_offset_width ||
wgs->offset_height != new_offset_height) {
wgs->offset_width = new_offset_width;
wgs->offset_height = new_offset_height;
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
InvalidateRect(wgs->term_hwnd, NULL, true);
Fix missing recalculation of window border. If you open a Windows PuTTY session and press Win+Right, Windows auto-sizes the terminal window to cover the right-hand half of the screen. Then if you press Win+Up it will be auto-sized again, this time to the top right quadrant. In the second resize (if you don't have font-based resize handling turned on), the WM_SIZE handler code will find a path through the twisty maze of ifs on which the border between the text and the client-area edges is not recomputed, or invalidated, or redrawn. So you can end up with half a line of text from the previous window size still visible at the bottom of the new window. Fixed by factoring out the offset-recomputation code from the large and complicated reset_window(), so that I can call just that snippet on the dangerous code path.
2021-02-12 17:50:47 +00:00
}
}
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
static void reset_window(WinGuiSeat *wgs, int reinit)
{
Three more patches from RDB: one to make Atomica work right, one to fiddle with the widths of characters in DBCS screen fonts, and (the big one) one to enable a mode in which resizing the window locks the terminal size and lets the font change, instead of vice versa. That should shut up a few feature requests! [originally from svn r1269]
2001-09-15 15:54:24 +00:00
/*
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
* This function decides how to resize or redraw when the
* user changes something.
Three more patches from RDB: one to make Atomica work right, one to fiddle with the widths of characters in DBCS screen fonts, and (the big one) one to enable a mode in which resizing the window locks the terminal size and lets the font change, instead of vice versa. That should shut up a few feature requests! [originally from svn r1269]
2001-09-15 15:54:24 +00:00
*
* This function doesn't like to change the terminal size but if the
* font size is locked that may be it's only soluion.
*/
Post-release destabilisation! Completely remove the struct type 'Config' in putty.h, which stores all PuTTY's settings and includes an arbitrary length limit on every single one of those settings which is stored in string form. In place of it is 'Conf', an opaque data type everywhere outside the new file conf.c, which stores a list of (key, value) pairs in which every key contains an integer identifying a configuration setting, and for some of those integers the key also contains extra parts (so that, for instance, CONF_environmt is a string-to-string mapping). Everywhere that a Config was previously used, a Conf is now; everywhere there was a Config structure copy, conf_copy() is called; every lookup, adjustment, load and save operation on a Config has been rewritten; and there's a mechanism for serialising a Conf into a binary blob and back for use with Duplicate Session. User-visible effects of this change _should_ be minimal, though I don't doubt I've introduced one or two bugs here and there which will eventually be found. The _intended_ visible effects of this change are that all arbitrary limits on configuration strings and lists (e.g. limit on number of port forwardings) should now disappear; that list boxes in the configuration will now be displayed in a sorted order rather than the arbitrary order in which they were added to the list (since the underlying data structure is now a sorted tree234 rather than an ad-hoc comma-separated string); and one more specific change, which is that local and dynamic port forwardings on the same port number are now mutually exclusive in the configuration (putting 'D' in the key rather than the value was a mistake in the first place). One other reorganisation as a result of this is that I've moved all the dialog.c standard handlers (dlg_stdeditbox_handler and friends) out into config.c, because I can't really justify calling them generic any more. When they took a pointer to an arbitrary structure type and the offset of a field within that structure, they were independent of whether that structure was a Config or something completely different, but now they really do expect to talk to a Conf, which can _only_ be used for PuTTY configuration, so I've renamed them all things like conf_editbox_handler and moved them out of the nominally independent dialog-box management module into the PuTTY-specific config.c. [originally from svn r9214]
2011-07-14 18:52:21 +00:00
int win_width, win_height, resize_action, window_border;
Three more patches from RDB: one to make Atomica work right, one to fiddle with the widths of characters in DBCS screen fonts, and (the big one) one to enable a mode in which resizing the window locks the terminal size and lets the font change, instead of vice versa. That should shut up a few feature requests! [originally from svn r1269]
2001-09-15 15:54:24 +00:00
RECT cr, wr;
/* Current window sizes ... */
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
GetWindowRect(wgs->term_hwnd, &wr);
GetClientRect(wgs->term_hwnd, &cr);
Three more patches from RDB: one to make Atomica work right, one to fiddle with the widths of characters in DBCS screen fonts, and (the big one) one to enable a mode in which resizing the window locks the terminal size and lets the font change, instead of vice versa. That should shut up a few feature requests! [originally from svn r1269]
2001-09-15 15:54:24 +00:00
win_width = cr.right - cr.left;
win_height = cr.bottom - cr.top;
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
resize_action = conf_get_int(wgs->conf, CONF_resize_action);
window_border = conf_get_int(wgs->conf, CONF_window_border);
Post-release destabilisation! Completely remove the struct type 'Config' in putty.h, which stores all PuTTY's settings and includes an arbitrary length limit on every single one of those settings which is stored in string form. In place of it is 'Conf', an opaque data type everywhere outside the new file conf.c, which stores a list of (key, value) pairs in which every key contains an integer identifying a configuration setting, and for some of those integers the key also contains extra parts (so that, for instance, CONF_environmt is a string-to-string mapping). Everywhere that a Config was previously used, a Conf is now; everywhere there was a Config structure copy, conf_copy() is called; every lookup, adjustment, load and save operation on a Config has been rewritten; and there's a mechanism for serialising a Conf into a binary blob and back for use with Duplicate Session. User-visible effects of this change _should_ be minimal, though I don't doubt I've introduced one or two bugs here and there which will eventually be found. The _intended_ visible effects of this change are that all arbitrary limits on configuration strings and lists (e.g. limit on number of port forwardings) should now disappear; that list boxes in the configuration will now be displayed in a sorted order rather than the arbitrary order in which they were added to the list (since the underlying data structure is now a sorted tree234 rather than an ad-hoc comma-separated string); and one more specific change, which is that local and dynamic port forwardings on the same port number are now mutually exclusive in the configuration (putting 'D' in the key rather than the value was a mistake in the first place). One other reorganisation as a result of this is that I've moved all the dialog.c standard handlers (dlg_stdeditbox_handler and friends) out into config.c, because I can't really justify calling them generic any more. When they took a pointer to an arbitrary structure type and the offset of a field within that structure, they were independent of whether that structure was a Config or something completely different, but now they really do expect to talk to a Conf, which can _only_ be used for PuTTY configuration, so I've renamed them all things like conf_editbox_handler and moved them out of the nominally independent dialog-box management module into the PuTTY-specific config.c. [originally from svn r9214]
2011-07-14 18:52:21 +00:00
if (resize_action == RESIZE_DISABLED)
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
reinit = 2;
RDB's general resizing cleanup. He's put his favourite resize mode back in again, but as long as it's not the default it doesn't bother me too much :-) [originally from svn r1421]
2001-11-25 18:39:57 +00:00
Three more patches from RDB: one to make Atomica work right, one to fiddle with the widths of characters in DBCS screen fonts, and (the big one) one to enable a mode in which resizing the window locks the terminal size and lets the font change, instead of vice versa. That should shut up a few feature requests! [originally from svn r1269]
2001-09-15 15:54:24 +00:00
/* Are we being forced to reload the fonts ? */
if (reinit>1) {
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
deinit_fonts(wgs);
init_fonts(wgs, 0, 0);
Three more patches from RDB: one to make Atomica work right, one to fiddle with the widths of characters in DBCS screen fonts, and (the big one) one to enable a mode in which resizing the window locks the terminal size and lets the font change, instead of vice versa. That should shut up a few feature requests! [originally from svn r1269]
2001-09-15 15:54:24 +00:00
}
/* Oh, looks like we're minimised */
if (win_width == 0 || win_height == 0)
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
return;
Three more patches from RDB: one to make Atomica work right, one to fiddle with the widths of characters in DBCS screen fonts, and (the big one) one to enable a mode in which resizing the window locks the terminal size and lets the font change, instead of vice versa. That should shut up a few feature requests! [originally from svn r1269]
2001-09-15 15:54:24 +00:00
/* Is the window out of position ? */
Fix missing recalculation of window border. If you open a Windows PuTTY session and press Win+Right, Windows auto-sizes the terminal window to cover the right-hand half of the screen. Then if you press Win+Up it will be auto-sized again, this time to the top right quadrant. In the second resize (if you don't have font-based resize handling turned on), the WM_SIZE handler code will find a path through the twisty maze of ifs on which the border between the text and the client-area edges is not recomputed, or invalidated, or redrawn. So you can end up with half a line of text from the previous window size still visible at the bottom of the new window. Fixed by factoring out the offset-recomputation code from the large and complicated reset_window(), so that I can call just that snippet on the dangerous code path.
2021-02-12 17:50:47 +00:00
if (!reinit) {
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
recompute_window_offset(wgs);
Three more patches from RDB: one to make Atomica work right, one to fiddle with the widths of characters in DBCS screen fonts, and (the big one) one to enable a mode in which resizing the window locks the terminal size and lets the font change, instead of vice versa. That should shut up a few feature requests! [originally from svn r1269]
2001-09-15 15:54:24 +00:00
}
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
if (IsZoomed(wgs->term_hwnd)) {
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
/* We're fullscreen, this means we must not change the size of
* the window so it's the font size or the terminal itself.
*/
windows/window.c: move more variables into WinGuiSeat. In commit f9e572595bb8cb6 I claimed that I'd removed very nearly all the global and static variables from windows/window.c. It turns out that this was wildly overoptimistic - I missed quite a few of them! I'm not quite sure how I managed that; my best guess is that I used an underpowered 'nm' command that failed to find some classes of variable. Some of the remaining function-scope statics were removed completely by commit afb3dab1e97a09f just now. In this commit, I've swept up some more and turn them into fields of WinGuiSeat, where they should have been moved last September. The (hopefully complete this time) list of remaining variables, generated by running this rune in the Windows build directory: nm windows/CMakeFiles/putty.dir/window.c.obj | grep -E '^([^ ]+)? *[bBcCdDgGsS] [^\.]' consists of the following variables which are legitimately global across the whole process and not related to a particular window: - 'hinst' and 'hprev', instance handles for Windows loadable modules - 'classname' in the terminal_window_class_a() and terminal_window_class_w() functions, which allocate a window class reusably - some pointers to Windows API functions retrieved via the DECL_WINDOWS_FUNCTION / GET_WINDOWS_FUNCTION system, such as p_AdjustWindowRectExForDpi and p_FlashWindowEx - some pointers to Windows API functions set up by assigning them at startup to the right one of the ANSI or Unicode version depending on the Windows version, e.g. sw_DefWindowProc and sw_DispatchMessage - 'unicode_window', a boolean flag set at the same time as those sw_Foo function pointers - 'sesslist', storing the last-retrieved version of the saved sessions menu - 'cursor_visible' in show_mouseptr() and 'forced_visible' in update_mouse_pointer(), each of which tracks the cumulative number of times that function has shown or hidden the mouse pointer, so as to manage its effect on the global state updated by ShowCursor - 'trust_icon', loaded from the executable's resources - 'wgslisthead', the list of all active WinGuiSeats - 'wm_mousewheel', the window-message id we use for mouse wheel events and the following which are nothing to do with our code: - '_OptionsStorage' in __local_stdio_printf_options() and __local_stdio_scanf_options(), which I'd never noticed before, but apparently are internal to a standard library header.
2023-05-27 13:59:20 +00:00
wgs->extra_width = wr.right - wr.left - cr.right + cr.left;
wgs->extra_height = wr.bottom - wr.top - cr.bottom + cr.top;
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
if (resize_action != RESIZE_TERM) {
windows/window.c: move more variables into WinGuiSeat. In commit f9e572595bb8cb6 I claimed that I'd removed very nearly all the global and static variables from windows/window.c. It turns out that this was wildly overoptimistic - I missed quite a few of them! I'm not quite sure how I managed that; my best guess is that I used an underpowered 'nm' command that failed to find some classes of variable. Some of the remaining function-scope statics were removed completely by commit afb3dab1e97a09f just now. In this commit, I've swept up some more and turn them into fields of WinGuiSeat, where they should have been moved last September. The (hopefully complete this time) list of remaining variables, generated by running this rune in the Windows build directory: nm windows/CMakeFiles/putty.dir/window.c.obj | grep -E '^([^ ]+)? *[bBcCdDgGsS] [^\.]' consists of the following variables which are legitimately global across the whole process and not related to a particular window: - 'hinst' and 'hprev', instance handles for Windows loadable modules - 'classname' in the terminal_window_class_a() and terminal_window_class_w() functions, which allocate a window class reusably - some pointers to Windows API functions retrieved via the DECL_WINDOWS_FUNCTION / GET_WINDOWS_FUNCTION system, such as p_AdjustWindowRectExForDpi and p_FlashWindowEx - some pointers to Windows API functions set up by assigning them at startup to the right one of the ANSI or Unicode version depending on the Windows version, e.g. sw_DefWindowProc and sw_DispatchMessage - 'unicode_window', a boolean flag set at the same time as those sw_Foo function pointers - 'sesslist', storing the last-retrieved version of the saved sessions menu - 'cursor_visible' in show_mouseptr() and 'forced_visible' in update_mouse_pointer(), each of which tracks the cumulative number of times that function has shown or hidden the mouse pointer, so as to manage its effect on the global state updated by ShowCursor - 'trust_icon', loaded from the executable's resources - 'wgslisthead', the list of all active WinGuiSeats - 'wm_mousewheel', the window-message id we use for mouse wheel events and the following which are nothing to do with our code: - '_OptionsStorage' in __local_stdio_printf_options() and __local_stdio_scanf_options(), which I'd never noticed before, but apparently are internal to a standard library header.
2023-05-27 13:59:20 +00:00
if (wgs->font_width != win_width/wgs->term->cols ||
wgs->font_height != win_height/wgs->term->rows) {
Windows: respect CONF_window_border when maximised. The code in the 'if (IsZoomed)' statement in reset_window() was failing to take account of the user-configured gap between the text and the window edge, so that the requested border was lost. Now it does take that into account. In this commit, this change of behaviour applies to both a normally maximised window (with the window frame still visible round the edge) and to a full-screen window (nothing visible on the whole monitor except PuTTY). I'm not 100% sure whether that's the right behaviour: perhaps the purpose of this configurable border is to space the text away from the window furniture, so that there's no need for it if there isn't any furniture? But on the other hand, one thing _I_ use this border for is to make space round the edge of a terminal window for the green border Zoom superimposes when sharing the window. And that's a use case that would still make sense when the window is full-screened.
2024-09-23 10:02:44 +00:00
int fw = (win_width - 2*window_border) / wgs->term->cols;
int fh = (win_height - 2*window_border) / wgs->term->rows;
/* In case that subtraction made the font size go
* negative in an edge case, bound it below by 1 */
if (fw < 1) fw = 1;
if (fh < 1) fh = 1;
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
deinit_fonts(wgs);
Windows: respect CONF_window_border when maximised. The code in the 'if (IsZoomed)' statement in reset_window() was failing to take account of the user-configured gap between the text and the window edge, so that the requested border was lost. Now it does take that into account. In this commit, this change of behaviour applies to both a normally maximised window (with the window frame still visible round the edge) and to a full-screen window (nothing visible on the whole monitor except PuTTY). I'm not 100% sure whether that's the right behaviour: perhaps the purpose of this configurable border is to space the text away from the window furniture, so that there's no need for it if there isn't any furniture? But on the other hand, one thing _I_ use this border for is to make space round the edge of a terminal window for the green border Zoom superimposes when sharing the window. And that's a use case that would still make sense when the window is full-screened.
2024-09-23 10:02:44 +00:00
init_fonts(wgs, fw, fh);
windows/window.c: move more variables into WinGuiSeat. In commit f9e572595bb8cb6 I claimed that I'd removed very nearly all the global and static variables from windows/window.c. It turns out that this was wildly overoptimistic - I missed quite a few of them! I'm not quite sure how I managed that; my best guess is that I used an underpowered 'nm' command that failed to find some classes of variable. Some of the remaining function-scope statics were removed completely by commit afb3dab1e97a09f just now. In this commit, I've swept up some more and turn them into fields of WinGuiSeat, where they should have been moved last September. The (hopefully complete this time) list of remaining variables, generated by running this rune in the Windows build directory: nm windows/CMakeFiles/putty.dir/window.c.obj | grep -E '^([^ ]+)? *[bBcCdDgGsS] [^\.]' consists of the following variables which are legitimately global across the whole process and not related to a particular window: - 'hinst' and 'hprev', instance handles for Windows loadable modules - 'classname' in the terminal_window_class_a() and terminal_window_class_w() functions, which allocate a window class reusably - some pointers to Windows API functions retrieved via the DECL_WINDOWS_FUNCTION / GET_WINDOWS_FUNCTION system, such as p_AdjustWindowRectExForDpi and p_FlashWindowEx - some pointers to Windows API functions set up by assigning them at startup to the right one of the ANSI or Unicode version depending on the Windows version, e.g. sw_DefWindowProc and sw_DispatchMessage - 'unicode_window', a boolean flag set at the same time as those sw_Foo function pointers - 'sesslist', storing the last-retrieved version of the saved sessions menu - 'cursor_visible' in show_mouseptr() and 'forced_visible' in update_mouse_pointer(), each of which tracks the cumulative number of times that function has shown or hidden the mouse pointer, so as to manage its effect on the global state updated by ShowCursor - 'trust_icon', loaded from the executable's resources - 'wgslisthead', the list of all active WinGuiSeats - 'wm_mousewheel', the window-message id we use for mouse wheel events and the following which are nothing to do with our code: - '_OptionsStorage' in __local_stdio_printf_options() and __local_stdio_scanf_options(), which I'd never noticed before, but apparently are internal to a standard library header.
2023-05-27 13:59:20 +00:00
wgs->offset_width =
(win_width - wgs->font_width*wgs->term->cols) / 2;
wgs->offset_height =
(win_height - wgs->font_height*wgs->term->rows) / 2;
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
InvalidateRect(wgs->term_hwnd, NULL, true);
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
}
} else {
windows/window.c: move more variables into WinGuiSeat. In commit f9e572595bb8cb6 I claimed that I'd removed very nearly all the global and static variables from windows/window.c. It turns out that this was wildly overoptimistic - I missed quite a few of them! I'm not quite sure how I managed that; my best guess is that I used an underpowered 'nm' command that failed to find some classes of variable. Some of the remaining function-scope statics were removed completely by commit afb3dab1e97a09f just now. In this commit, I've swept up some more and turn them into fields of WinGuiSeat, where they should have been moved last September. The (hopefully complete this time) list of remaining variables, generated by running this rune in the Windows build directory: nm windows/CMakeFiles/putty.dir/window.c.obj | grep -E '^([^ ]+)? *[bBcCdDgGsS] [^\.]' consists of the following variables which are legitimately global across the whole process and not related to a particular window: - 'hinst' and 'hprev', instance handles for Windows loadable modules - 'classname' in the terminal_window_class_a() and terminal_window_class_w() functions, which allocate a window class reusably - some pointers to Windows API functions retrieved via the DECL_WINDOWS_FUNCTION / GET_WINDOWS_FUNCTION system, such as p_AdjustWindowRectExForDpi and p_FlashWindowEx - some pointers to Windows API functions set up by assigning them at startup to the right one of the ANSI or Unicode version depending on the Windows version, e.g. sw_DefWindowProc and sw_DispatchMessage - 'unicode_window', a boolean flag set at the same time as those sw_Foo function pointers - 'sesslist', storing the last-retrieved version of the saved sessions menu - 'cursor_visible' in show_mouseptr() and 'forced_visible' in update_mouse_pointer(), each of which tracks the cumulative number of times that function has shown or hidden the mouse pointer, so as to manage its effect on the global state updated by ShowCursor - 'trust_icon', loaded from the executable's resources - 'wgslisthead', the list of all active WinGuiSeats - 'wm_mousewheel', the window-message id we use for mouse wheel events and the following which are nothing to do with our code: - '_OptionsStorage' in __local_stdio_printf_options() and __local_stdio_scanf_options(), which I'd never noticed before, but apparently are internal to a standard library header.
2023-05-27 13:59:20 +00:00
if (wgs->font_width * wgs->term->cols != win_width ||
wgs->font_height * wgs->term->rows != win_height) {
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
/* Our only choice at this point is to change the
* size of the terminal; Oh well.
*/
Windows: respect CONF_window_border when maximised. The code in the 'if (IsZoomed)' statement in reset_window() was failing to take account of the user-configured gap between the text and the window edge, so that the requested border was lost. Now it does take that into account. In this commit, this change of behaviour applies to both a normally maximised window (with the window frame still visible round the edge) and to a full-screen window (nothing visible on the whole monitor except PuTTY). I'm not 100% sure whether that's the right behaviour: perhaps the purpose of this configurable border is to space the text away from the window furniture, so that there's no need for it if there isn't any furniture? But on the other hand, one thing _I_ use this border for is to make space round the edge of a terminal window for the green border Zoom superimposes when sharing the window. And that's a use case that would still make sense when the window is full-screened.
2024-09-23 10:02:44 +00:00
term_size(wgs->term,
(win_height - 2*window_border) / wgs->font_height,
(win_width - 2*window_border) / wgs->font_width,
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
conf_get_int(wgs->conf, CONF_savelines));
windows/window.c: move more variables into WinGuiSeat. In commit f9e572595bb8cb6 I claimed that I'd removed very nearly all the global and static variables from windows/window.c. It turns out that this was wildly overoptimistic - I missed quite a few of them! I'm not quite sure how I managed that; my best guess is that I used an underpowered 'nm' command that failed to find some classes of variable. Some of the remaining function-scope statics were removed completely by commit afb3dab1e97a09f just now. In this commit, I've swept up some more and turn them into fields of WinGuiSeat, where they should have been moved last September. The (hopefully complete this time) list of remaining variables, generated by running this rune in the Windows build directory: nm windows/CMakeFiles/putty.dir/window.c.obj | grep -E '^([^ ]+)? *[bBcCdDgGsS] [^\.]' consists of the following variables which are legitimately global across the whole process and not related to a particular window: - 'hinst' and 'hprev', instance handles for Windows loadable modules - 'classname' in the terminal_window_class_a() and terminal_window_class_w() functions, which allocate a window class reusably - some pointers to Windows API functions retrieved via the DECL_WINDOWS_FUNCTION / GET_WINDOWS_FUNCTION system, such as p_AdjustWindowRectExForDpi and p_FlashWindowEx - some pointers to Windows API functions set up by assigning them at startup to the right one of the ANSI or Unicode version depending on the Windows version, e.g. sw_DefWindowProc and sw_DispatchMessage - 'unicode_window', a boolean flag set at the same time as those sw_Foo function pointers - 'sesslist', storing the last-retrieved version of the saved sessions menu - 'cursor_visible' in show_mouseptr() and 'forced_visible' in update_mouse_pointer(), each of which tracks the cumulative number of times that function has shown or hidden the mouse pointer, so as to manage its effect on the global state updated by ShowCursor - 'trust_icon', loaded from the executable's resources - 'wgslisthead', the list of all active WinGuiSeats - 'wm_mousewheel', the window-message id we use for mouse wheel events and the following which are nothing to do with our code: - '_OptionsStorage' in __local_stdio_printf_options() and __local_stdio_scanf_options(), which I'd never noticed before, but apparently are internal to a standard library header.
2023-05-27 13:59:20 +00:00
wgs->offset_width =
Windows: respect CONF_window_border when maximised. The code in the 'if (IsZoomed)' statement in reset_window() was failing to take account of the user-configured gap between the text and the window edge, so that the requested border was lost. Now it does take that into account. In this commit, this change of behaviour applies to both a normally maximised window (with the window frame still visible round the edge) and to a full-screen window (nothing visible on the whole monitor except PuTTY). I'm not 100% sure whether that's the right behaviour: perhaps the purpose of this configurable border is to space the text away from the window furniture, so that there's no need for it if there isn't any furniture? But on the other hand, one thing _I_ use this border for is to make space round the edge of a terminal window for the green border Zoom superimposes when sharing the window. And that's a use case that would still make sense when the window is full-screened.
2024-09-23 10:02:44 +00:00
(win_width - window_border - wgs->font_width*wgs->term->cols) / 2;
windows/window.c: move more variables into WinGuiSeat. In commit f9e572595bb8cb6 I claimed that I'd removed very nearly all the global and static variables from windows/window.c. It turns out that this was wildly overoptimistic - I missed quite a few of them! I'm not quite sure how I managed that; my best guess is that I used an underpowered 'nm' command that failed to find some classes of variable. Some of the remaining function-scope statics were removed completely by commit afb3dab1e97a09f just now. In this commit, I've swept up some more and turn them into fields of WinGuiSeat, where they should have been moved last September. The (hopefully complete this time) list of remaining variables, generated by running this rune in the Windows build directory: nm windows/CMakeFiles/putty.dir/window.c.obj | grep -E '^([^ ]+)? *[bBcCdDgGsS] [^\.]' consists of the following variables which are legitimately global across the whole process and not related to a particular window: - 'hinst' and 'hprev', instance handles for Windows loadable modules - 'classname' in the terminal_window_class_a() and terminal_window_class_w() functions, which allocate a window class reusably - some pointers to Windows API functions retrieved via the DECL_WINDOWS_FUNCTION / GET_WINDOWS_FUNCTION system, such as p_AdjustWindowRectExForDpi and p_FlashWindowEx - some pointers to Windows API functions set up by assigning them at startup to the right one of the ANSI or Unicode version depending on the Windows version, e.g. sw_DefWindowProc and sw_DispatchMessage - 'unicode_window', a boolean flag set at the same time as those sw_Foo function pointers - 'sesslist', storing the last-retrieved version of the saved sessions menu - 'cursor_visible' in show_mouseptr() and 'forced_visible' in update_mouse_pointer(), each of which tracks the cumulative number of times that function has shown or hidden the mouse pointer, so as to manage its effect on the global state updated by ShowCursor - 'trust_icon', loaded from the executable's resources - 'wgslisthead', the list of all active WinGuiSeats - 'wm_mousewheel', the window-message id we use for mouse wheel events and the following which are nothing to do with our code: - '_OptionsStorage' in __local_stdio_printf_options() and __local_stdio_scanf_options(), which I'd never noticed before, but apparently are internal to a standard library header.
2023-05-27 13:59:20 +00:00
wgs->offset_height =
Windows: respect CONF_window_border when maximised. The code in the 'if (IsZoomed)' statement in reset_window() was failing to take account of the user-configured gap between the text and the window edge, so that the requested border was lost. Now it does take that into account. In this commit, this change of behaviour applies to both a normally maximised window (with the window frame still visible round the edge) and to a full-screen window (nothing visible on the whole monitor except PuTTY). I'm not 100% sure whether that's the right behaviour: perhaps the purpose of this configurable border is to space the text away from the window furniture, so that there's no need for it if there isn't any furniture? But on the other hand, one thing _I_ use this border for is to make space round the edge of a terminal window for the green border Zoom superimposes when sharing the window. And that's a use case that would still make sense when the window is full-screened.
2024-09-23 10:02:44 +00:00
(win_height - window_border - wgs->font_height*wgs->term->rows) / 2;
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
InvalidateRect(wgs->term_hwnd, NULL, true);
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
}
}
return;
Three more patches from RDB: one to make Atomica work right, one to fiddle with the widths of characters in DBCS screen fonts, and (the big one) one to enable a mode in which resizing the window locks the terminal size and lets the font change, instead of vice versa. That should shut up a few feature requests! [originally from svn r1269]
2001-09-15 15:54:24 +00:00
}
Windows 10: add per monitor DPI awareness support. On a system with 2 or more displays with different DPI settings, moving the PuTTY window from one display to another will make Windows resize the window using its "bitmap" strategy, stretching/compressing the text, making it fuzzy and harder to read. This change makes PuTTY resize its window and font size to accurately fit the DPI of the display it is on. We process the WM_DPICHANGED message, saving the new DPI, window size and position. We proceed to then reset the window, recreating the fonts using the new DPI and calculate the new window size and position based on the new font size, user display options (ie. with/without scrollbar) and the suggested window position provided by Windows. The suggested window size is usually not a perfect fit, therefore we must add a small offset to the new window position in order to avoid issues with repeated DPI changes while dragging the window from one display to another.
2021-03-29 15:31:13 +00:00
/* Resize window after DPI change */
if (reinit == 3 && p_GetSystemMetricsForDpi && p_AdjustWindowRectExForDpi) {
RECT rect;
rect.left = rect.top = 0;
windows/window.c: move more variables into WinGuiSeat. In commit f9e572595bb8cb6 I claimed that I'd removed very nearly all the global and static variables from windows/window.c. It turns out that this was wildly overoptimistic - I missed quite a few of them! I'm not quite sure how I managed that; my best guess is that I used an underpowered 'nm' command that failed to find some classes of variable. Some of the remaining function-scope statics were removed completely by commit afb3dab1e97a09f just now. In this commit, I've swept up some more and turn them into fields of WinGuiSeat, where they should have been moved last September. The (hopefully complete this time) list of remaining variables, generated by running this rune in the Windows build directory: nm windows/CMakeFiles/putty.dir/window.c.obj | grep -E '^([^ ]+)? *[bBcCdDgGsS] [^\.]' consists of the following variables which are legitimately global across the whole process and not related to a particular window: - 'hinst' and 'hprev', instance handles for Windows loadable modules - 'classname' in the terminal_window_class_a() and terminal_window_class_w() functions, which allocate a window class reusably - some pointers to Windows API functions retrieved via the DECL_WINDOWS_FUNCTION / GET_WINDOWS_FUNCTION system, such as p_AdjustWindowRectExForDpi and p_FlashWindowEx - some pointers to Windows API functions set up by assigning them at startup to the right one of the ANSI or Unicode version depending on the Windows version, e.g. sw_DefWindowProc and sw_DispatchMessage - 'unicode_window', a boolean flag set at the same time as those sw_Foo function pointers - 'sesslist', storing the last-retrieved version of the saved sessions menu - 'cursor_visible' in show_mouseptr() and 'forced_visible' in update_mouse_pointer(), each of which tracks the cumulative number of times that function has shown or hidden the mouse pointer, so as to manage its effect on the global state updated by ShowCursor - 'trust_icon', loaded from the executable's resources - 'wgslisthead', the list of all active WinGuiSeats - 'wm_mousewheel', the window-message id we use for mouse wheel events and the following which are nothing to do with our code: - '_OptionsStorage' in __local_stdio_printf_options() and __local_stdio_scanf_options(), which I'd never noticed before, but apparently are internal to a standard library header.
2023-05-27 13:59:20 +00:00
rect.right = (wgs->font_width * wgs->term->cols);
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
if (conf_get_bool(wgs->conf, CONF_scrollbar))
Windows 10: add per monitor DPI awareness support. On a system with 2 or more displays with different DPI settings, moving the PuTTY window from one display to another will make Windows resize the window using its "bitmap" strategy, stretching/compressing the text, making it fuzzy and harder to read. This change makes PuTTY resize its window and font size to accurately fit the DPI of the display it is on. We process the WM_DPICHANGED message, saving the new DPI, window size and position. We proceed to then reset the window, recreating the fonts using the new DPI and calculate the new window size and position based on the new font size, user display options (ie. with/without scrollbar) and the suggested window position provided by Windows. The suggested window size is usually not a perfect fit, therefore we must add a small offset to the new window position in order to avoid issues with repeated DPI changes while dragging the window from one display to another.
2021-03-29 15:31:13 +00:00
rect.right += p_GetSystemMetricsForDpi(SM_CXVSCROLL,
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
wgs->dpi_info.cur_dpi.x);
windows/window.c: move more variables into WinGuiSeat. In commit f9e572595bb8cb6 I claimed that I'd removed very nearly all the global and static variables from windows/window.c. It turns out that this was wildly overoptimistic - I missed quite a few of them! I'm not quite sure how I managed that; my best guess is that I used an underpowered 'nm' command that failed to find some classes of variable. Some of the remaining function-scope statics were removed completely by commit afb3dab1e97a09f just now. In this commit, I've swept up some more and turn them into fields of WinGuiSeat, where they should have been moved last September. The (hopefully complete this time) list of remaining variables, generated by running this rune in the Windows build directory: nm windows/CMakeFiles/putty.dir/window.c.obj | grep -E '^([^ ]+)? *[bBcCdDgGsS] [^\.]' consists of the following variables which are legitimately global across the whole process and not related to a particular window: - 'hinst' and 'hprev', instance handles for Windows loadable modules - 'classname' in the terminal_window_class_a() and terminal_window_class_w() functions, which allocate a window class reusably - some pointers to Windows API functions retrieved via the DECL_WINDOWS_FUNCTION / GET_WINDOWS_FUNCTION system, such as p_AdjustWindowRectExForDpi and p_FlashWindowEx - some pointers to Windows API functions set up by assigning them at startup to the right one of the ANSI or Unicode version depending on the Windows version, e.g. sw_DefWindowProc and sw_DispatchMessage - 'unicode_window', a boolean flag set at the same time as those sw_Foo function pointers - 'sesslist', storing the last-retrieved version of the saved sessions menu - 'cursor_visible' in show_mouseptr() and 'forced_visible' in update_mouse_pointer(), each of which tracks the cumulative number of times that function has shown or hidden the mouse pointer, so as to manage its effect on the global state updated by ShowCursor - 'trust_icon', loaded from the executable's resources - 'wgslisthead', the list of all active WinGuiSeats - 'wm_mousewheel', the window-message id we use for mouse wheel events and the following which are nothing to do with our code: - '_OptionsStorage' in __local_stdio_printf_options() and __local_stdio_scanf_options(), which I'd never noticed before, but apparently are internal to a standard library header.
2023-05-27 13:59:20 +00:00
rect.bottom = (wgs->font_height * wgs->term->rows);
Windows 10: add per monitor DPI awareness support. On a system with 2 or more displays with different DPI settings, moving the PuTTY window from one display to another will make Windows resize the window using its "bitmap" strategy, stretching/compressing the text, making it fuzzy and harder to read. This change makes PuTTY resize its window and font size to accurately fit the DPI of the display it is on. We process the WM_DPICHANGED message, saving the new DPI, window size and position. We proceed to then reset the window, recreating the fonts using the new DPI and calculate the new window size and position based on the new font size, user display options (ie. with/without scrollbar) and the suggested window position provided by Windows. The suggested window size is usually not a perfect fit, therefore we must add a small offset to the new window position in order to avoid issues with repeated DPI changes while dragging the window from one display to another.
2021-03-29 15:31:13 +00:00
p_AdjustWindowRectExForDpi(
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
&rect, GetWindowLongPtr(wgs->term_hwnd, GWL_STYLE),
FALSE, GetWindowLongPtr(wgs->term_hwnd, GWL_EXSTYLE),
wgs->dpi_info.cur_dpi.x);
Windows 10: add per monitor DPI awareness support. On a system with 2 or more displays with different DPI settings, moving the PuTTY window from one display to another will make Windows resize the window using its "bitmap" strategy, stretching/compressing the text, making it fuzzy and harder to read. This change makes PuTTY resize its window and font size to accurately fit the DPI of the display it is on. We process the WM_DPICHANGED message, saving the new DPI, window size and position. We proceed to then reset the window, recreating the fonts using the new DPI and calculate the new window size and position based on the new font size, user display options (ie. with/without scrollbar) and the suggested window position provided by Windows. The suggested window size is usually not a perfect fit, therefore we must add a small offset to the new window position in order to avoid issues with repeated DPI changes while dragging the window from one display to another.
2021-03-29 15:31:13 +00:00
rect.right += (window_border * 2);
rect.bottom += (window_border * 2);
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
OffsetRect(&wgs->dpi_info.new_wnd_rect,
((wgs->dpi_info.new_wnd_rect.right -
wgs->dpi_info.new_wnd_rect.left) -
Formatting: realign run-on parenthesised stuff. My bulk indentation check also turned up a lot of cases where a run-on function call or if statement didn't have its later lines aligned correctly relative to the open paren. I think this is quite easy to do by getting things out of sync (editing the first line of the function call and forgetting to update the rest, perhaps even because you never _saw_ the rest during a search-replace). But a few didn't quite fit into that pattern, in particular an outright misleading case in unix/askpass.c where the second line of a call was aligned neatly below the _wrong_ one of the open parens on the opening line. Restored as many alignments as I could easily find.
2022-08-03 19:48:46 +00:00
(rect.right - rect.left)) / 2,
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
((wgs->dpi_info.new_wnd_rect.bottom -
wgs->dpi_info.new_wnd_rect.top) -
Formatting: realign run-on parenthesised stuff. My bulk indentation check also turned up a lot of cases where a run-on function call or if statement didn't have its later lines aligned correctly relative to the open paren. I think this is quite easy to do by getting things out of sync (editing the first line of the function call and forgetting to update the rest, perhaps even because you never _saw_ the rest during a search-replace). But a few didn't quite fit into that pattern, in particular an outright misleading case in unix/askpass.c where the second line of a call was aligned neatly below the _wrong_ one of the open parens on the opening line. Restored as many alignments as I could easily find.
2022-08-03 19:48:46 +00:00
(rect.bottom - rect.top)) / 2);
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
SetWindowPos(wgs->term_hwnd, NULL,
wgs->dpi_info.new_wnd_rect.left,
wgs->dpi_info.new_wnd_rect.top,
Windows 10: add per monitor DPI awareness support. On a system with 2 or more displays with different DPI settings, moving the PuTTY window from one display to another will make Windows resize the window using its "bitmap" strategy, stretching/compressing the text, making it fuzzy and harder to read. This change makes PuTTY resize its window and font size to accurately fit the DPI of the display it is on. We process the WM_DPICHANGED message, saving the new DPI, window size and position. We proceed to then reset the window, recreating the fonts using the new DPI and calculate the new window size and position based on the new font size, user display options (ie. with/without scrollbar) and the suggested window position provided by Windows. The suggested window size is usually not a perfect fit, therefore we must add a small offset to the new window position in order to avoid issues with repeated DPI changes while dragging the window from one display to another.
2021-03-29 15:31:13 +00:00
rect.right - rect.left, rect.bottom - rect.top,
SWP_NOZORDER);
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
InvalidateRect(wgs->term_hwnd, NULL, true);
Windows 10: add per monitor DPI awareness support. On a system with 2 or more displays with different DPI settings, moving the PuTTY window from one display to another will make Windows resize the window using its "bitmap" strategy, stretching/compressing the text, making it fuzzy and harder to read. This change makes PuTTY resize its window and font size to accurately fit the DPI of the display it is on. We process the WM_DPICHANGED message, saving the new DPI, window size and position. We proceed to then reset the window, recreating the fonts using the new DPI and calculate the new window size and position based on the new font size, user display options (ie. with/without scrollbar) and the suggested window position provided by Windows. The suggested window size is usually not a perfect fit, therefore we must add a small offset to the new window position in order to avoid issues with repeated DPI changes while dragging the window from one display to another.
2021-03-29 15:31:13 +00:00
return;
}
Three more patches from RDB: one to make Atomica work right, one to fiddle with the widths of characters in DBCS screen fonts, and (the big one) one to enable a mode in which resizing the window locks the terminal size and lets the font change, instead of vice versa. That should shut up a few feature requests! [originally from svn r1269]
2001-09-15 15:54:24 +00:00
/* Hmm, a force re-init means we should ignore the current window
* so we resize to the default font size.
*/
if (reinit>0) {
windows/window.c: move more variables into WinGuiSeat. In commit f9e572595bb8cb6 I claimed that I'd removed very nearly all the global and static variables from windows/window.c. It turns out that this was wildly overoptimistic - I missed quite a few of them! I'm not quite sure how I managed that; my best guess is that I used an underpowered 'nm' command that failed to find some classes of variable. Some of the remaining function-scope statics were removed completely by commit afb3dab1e97a09f just now. In this commit, I've swept up some more and turn them into fields of WinGuiSeat, where they should have been moved last September. The (hopefully complete this time) list of remaining variables, generated by running this rune in the Windows build directory: nm windows/CMakeFiles/putty.dir/window.c.obj | grep -E '^([^ ]+)? *[bBcCdDgGsS] [^\.]' consists of the following variables which are legitimately global across the whole process and not related to a particular window: - 'hinst' and 'hprev', instance handles for Windows loadable modules - 'classname' in the terminal_window_class_a() and terminal_window_class_w() functions, which allocate a window class reusably - some pointers to Windows API functions retrieved via the DECL_WINDOWS_FUNCTION / GET_WINDOWS_FUNCTION system, such as p_AdjustWindowRectExForDpi and p_FlashWindowEx - some pointers to Windows API functions set up by assigning them at startup to the right one of the ANSI or Unicode version depending on the Windows version, e.g. sw_DefWindowProc and sw_DispatchMessage - 'unicode_window', a boolean flag set at the same time as those sw_Foo function pointers - 'sesslist', storing the last-retrieved version of the saved sessions menu - 'cursor_visible' in show_mouseptr() and 'forced_visible' in update_mouse_pointer(), each of which tracks the cumulative number of times that function has shown or hidden the mouse pointer, so as to manage its effect on the global state updated by ShowCursor - 'trust_icon', loaded from the executable's resources - 'wgslisthead', the list of all active WinGuiSeats - 'wm_mousewheel', the window-message id we use for mouse wheel events and the following which are nothing to do with our code: - '_OptionsStorage' in __local_stdio_printf_options() and __local_stdio_scanf_options(), which I'd never noticed before, but apparently are internal to a standard library header.
2023-05-27 13:59:20 +00:00
wgs->offset_width = wgs->offset_height = window_border;
wgs->extra_width =
wr.right - wr.left - cr.right + cr.left + wgs->offset_width*2;
wgs->extra_height =
wr.bottom - wr.top - cr.bottom + cr.top + wgs->offset_height*2;
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
windows/window.c: move more variables into WinGuiSeat. In commit f9e572595bb8cb6 I claimed that I'd removed very nearly all the global and static variables from windows/window.c. It turns out that this was wildly overoptimistic - I missed quite a few of them! I'm not quite sure how I managed that; my best guess is that I used an underpowered 'nm' command that failed to find some classes of variable. Some of the remaining function-scope statics were removed completely by commit afb3dab1e97a09f just now. In this commit, I've swept up some more and turn them into fields of WinGuiSeat, where they should have been moved last September. The (hopefully complete this time) list of remaining variables, generated by running this rune in the Windows build directory: nm windows/CMakeFiles/putty.dir/window.c.obj | grep -E '^([^ ]+)? *[bBcCdDgGsS] [^\.]' consists of the following variables which are legitimately global across the whole process and not related to a particular window: - 'hinst' and 'hprev', instance handles for Windows loadable modules - 'classname' in the terminal_window_class_a() and terminal_window_class_w() functions, which allocate a window class reusably - some pointers to Windows API functions retrieved via the DECL_WINDOWS_FUNCTION / GET_WINDOWS_FUNCTION system, such as p_AdjustWindowRectExForDpi and p_FlashWindowEx - some pointers to Windows API functions set up by assigning them at startup to the right one of the ANSI or Unicode version depending on the Windows version, e.g. sw_DefWindowProc and sw_DispatchMessage - 'unicode_window', a boolean flag set at the same time as those sw_Foo function pointers - 'sesslist', storing the last-retrieved version of the saved sessions menu - 'cursor_visible' in show_mouseptr() and 'forced_visible' in update_mouse_pointer(), each of which tracks the cumulative number of times that function has shown or hidden the mouse pointer, so as to manage its effect on the global state updated by ShowCursor - 'trust_icon', loaded from the executable's resources - 'wgslisthead', the list of all active WinGuiSeats - 'wm_mousewheel', the window-message id we use for mouse wheel events and the following which are nothing to do with our code: - '_OptionsStorage' in __local_stdio_printf_options() and __local_stdio_scanf_options(), which I'd never noticed before, but apparently are internal to a standard library header.
2023-05-27 13:59:20 +00:00
if (win_width != (wgs->font_width*wgs->term->cols +
wgs->offset_width*2) ||
win_height != (wgs->font_height*wgs->term->rows +
wgs->offset_height*2)) {
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
/* If this is too large windows will resize it to the maximum
* allowed window size, we will then be back in here and resize
* the font or terminal to fit.
*/
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
SetWindowPos(wgs->term_hwnd, NULL, 0, 0,
windows/window.c: move more variables into WinGuiSeat. In commit f9e572595bb8cb6 I claimed that I'd removed very nearly all the global and static variables from windows/window.c. It turns out that this was wildly overoptimistic - I missed quite a few of them! I'm not quite sure how I managed that; my best guess is that I used an underpowered 'nm' command that failed to find some classes of variable. Some of the remaining function-scope statics were removed completely by commit afb3dab1e97a09f just now. In this commit, I've swept up some more and turn them into fields of WinGuiSeat, where they should have been moved last September. The (hopefully complete this time) list of remaining variables, generated by running this rune in the Windows build directory: nm windows/CMakeFiles/putty.dir/window.c.obj | grep -E '^([^ ]+)? *[bBcCdDgGsS] [^\.]' consists of the following variables which are legitimately global across the whole process and not related to a particular window: - 'hinst' and 'hprev', instance handles for Windows loadable modules - 'classname' in the terminal_window_class_a() and terminal_window_class_w() functions, which allocate a window class reusably - some pointers to Windows API functions retrieved via the DECL_WINDOWS_FUNCTION / GET_WINDOWS_FUNCTION system, such as p_AdjustWindowRectExForDpi and p_FlashWindowEx - some pointers to Windows API functions set up by assigning them at startup to the right one of the ANSI or Unicode version depending on the Windows version, e.g. sw_DefWindowProc and sw_DispatchMessage - 'unicode_window', a boolean flag set at the same time as those sw_Foo function pointers - 'sesslist', storing the last-retrieved version of the saved sessions menu - 'cursor_visible' in show_mouseptr() and 'forced_visible' in update_mouse_pointer(), each of which tracks the cumulative number of times that function has shown or hidden the mouse pointer, so as to manage its effect on the global state updated by ShowCursor - 'trust_icon', loaded from the executable's resources - 'wgslisthead', the list of all active WinGuiSeats - 'wm_mousewheel', the window-message id we use for mouse wheel events and the following which are nothing to do with our code: - '_OptionsStorage' in __local_stdio_printf_options() and __local_stdio_scanf_options(), which I'd never noticed before, but apparently are internal to a standard library header.
2023-05-27 13:59:20 +00:00
wgs->font_width*wgs->term->cols + wgs->extra_width,
wgs->font_height*wgs->term->rows + wgs->extra_height,
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
SWP_NOMOVE | SWP_NOZORDER);
}
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
InvalidateRect(wgs->term_hwnd, NULL, true);
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
return;
Three more patches from RDB: one to make Atomica work right, one to fiddle with the widths of characters in DBCS screen fonts, and (the big one) one to enable a mode in which resizing the window locks the terminal size and lets the font change, instead of vice versa. That should shut up a few feature requests! [originally from svn r1269]
2001-09-15 15:54:24 +00:00
}
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
/* Okay the user doesn't want us to change the font so we try the
Three more patches from RDB: one to make Atomica work right, one to fiddle with the widths of characters in DBCS screen fonts, and (the big one) one to enable a mode in which resizing the window locks the terminal size and lets the font change, instead of vice versa. That should shut up a few feature requests! [originally from svn r1269]
2001-09-15 15:54:24 +00:00
* window. But that may be too big for the screen which forces us
* to change the terminal.
*/
Post-release destabilisation! Completely remove the struct type 'Config' in putty.h, which stores all PuTTY's settings and includes an arbitrary length limit on every single one of those settings which is stored in string form. In place of it is 'Conf', an opaque data type everywhere outside the new file conf.c, which stores a list of (key, value) pairs in which every key contains an integer identifying a configuration setting, and for some of those integers the key also contains extra parts (so that, for instance, CONF_environmt is a string-to-string mapping). Everywhere that a Config was previously used, a Conf is now; everywhere there was a Config structure copy, conf_copy() is called; every lookup, adjustment, load and save operation on a Config has been rewritten; and there's a mechanism for serialising a Conf into a binary blob and back for use with Duplicate Session. User-visible effects of this change _should_ be minimal, though I don't doubt I've introduced one or two bugs here and there which will eventually be found. The _intended_ visible effects of this change are that all arbitrary limits on configuration strings and lists (e.g. limit on number of port forwardings) should now disappear; that list boxes in the configuration will now be displayed in a sorted order rather than the arbitrary order in which they were added to the list (since the underlying data structure is now a sorted tree234 rather than an ad-hoc comma-separated string); and one more specific change, which is that local and dynamic port forwardings on the same port number are now mutually exclusive in the configuration (putting 'D' in the key rather than the value was a mistake in the first place). One other reorganisation as a result of this is that I've moved all the dialog.c standard handlers (dlg_stdeditbox_handler and friends) out into config.c, because I can't really justify calling them generic any more. When they took a pointer to an arbitrary structure type and the offset of a field within that structure, they were independent of whether that structure was a Config or something completely different, but now they really do expect to talk to a Conf, which can _only_ be used for PuTTY configuration, so I've renamed them all things like conf_editbox_handler and moved them out of the nominally independent dialog-box management module into the PuTTY-specific config.c. [originally from svn r9214]
2011-07-14 18:52:21 +00:00
if ((resize_action == RESIZE_TERM && reinit<=0) ||
(resize_action == RESIZE_EITHER && reinit<0) ||
Formatting: realign run-on parenthesised stuff. My bulk indentation check also turned up a lot of cases where a run-on function call or if statement didn't have its later lines aligned correctly relative to the open paren. I think this is quite easy to do by getting things out of sync (editing the first line of the function call and forgetting to update the rest, perhaps even because you never _saw_ the rest during a search-replace). But a few didn't quite fit into that pattern, in particular an outright misleading case in unix/askpass.c where the second line of a call was aligned neatly below the _wrong_ one of the open parens on the opening line. Restored as many alignments as I could easily find.
2022-08-03 19:48:46 +00:00
reinit>0) {
windows/window.c: move more variables into WinGuiSeat. In commit f9e572595bb8cb6 I claimed that I'd removed very nearly all the global and static variables from windows/window.c. It turns out that this was wildly overoptimistic - I missed quite a few of them! I'm not quite sure how I managed that; my best guess is that I used an underpowered 'nm' command that failed to find some classes of variable. Some of the remaining function-scope statics were removed completely by commit afb3dab1e97a09f just now. In this commit, I've swept up some more and turn them into fields of WinGuiSeat, where they should have been moved last September. The (hopefully complete this time) list of remaining variables, generated by running this rune in the Windows build directory: nm windows/CMakeFiles/putty.dir/window.c.obj | grep -E '^([^ ]+)? *[bBcCdDgGsS] [^\.]' consists of the following variables which are legitimately global across the whole process and not related to a particular window: - 'hinst' and 'hprev', instance handles for Windows loadable modules - 'classname' in the terminal_window_class_a() and terminal_window_class_w() functions, which allocate a window class reusably - some pointers to Windows API functions retrieved via the DECL_WINDOWS_FUNCTION / GET_WINDOWS_FUNCTION system, such as p_AdjustWindowRectExForDpi and p_FlashWindowEx - some pointers to Windows API functions set up by assigning them at startup to the right one of the ANSI or Unicode version depending on the Windows version, e.g. sw_DefWindowProc and sw_DispatchMessage - 'unicode_window', a boolean flag set at the same time as those sw_Foo function pointers - 'sesslist', storing the last-retrieved version of the saved sessions menu - 'cursor_visible' in show_mouseptr() and 'forced_visible' in update_mouse_pointer(), each of which tracks the cumulative number of times that function has shown or hidden the mouse pointer, so as to manage its effect on the global state updated by ShowCursor - 'trust_icon', loaded from the executable's resources - 'wgslisthead', the list of all active WinGuiSeats - 'wm_mousewheel', the window-message id we use for mouse wheel events and the following which are nothing to do with our code: - '_OptionsStorage' in __local_stdio_printf_options() and __local_stdio_scanf_options(), which I'd never noticed before, but apparently are internal to a standard library header.
2023-05-27 13:59:20 +00:00
wgs->offset_width = wgs->offset_height = window_border;
wgs->extra_width =
wr.right - wr.left - cr.right + cr.left + wgs->offset_width*2;
wgs->extra_height =
wr.bottom - wr.top - cr.bottom + cr.top + wgs->offset_height*2;
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
windows/window.c: move more variables into WinGuiSeat. In commit f9e572595bb8cb6 I claimed that I'd removed very nearly all the global and static variables from windows/window.c. It turns out that this was wildly overoptimistic - I missed quite a few of them! I'm not quite sure how I managed that; my best guess is that I used an underpowered 'nm' command that failed to find some classes of variable. Some of the remaining function-scope statics were removed completely by commit afb3dab1e97a09f just now. In this commit, I've swept up some more and turn them into fields of WinGuiSeat, where they should have been moved last September. The (hopefully complete this time) list of remaining variables, generated by running this rune in the Windows build directory: nm windows/CMakeFiles/putty.dir/window.c.obj | grep -E '^([^ ]+)? *[bBcCdDgGsS] [^\.]' consists of the following variables which are legitimately global across the whole process and not related to a particular window: - 'hinst' and 'hprev', instance handles for Windows loadable modules - 'classname' in the terminal_window_class_a() and terminal_window_class_w() functions, which allocate a window class reusably - some pointers to Windows API functions retrieved via the DECL_WINDOWS_FUNCTION / GET_WINDOWS_FUNCTION system, such as p_AdjustWindowRectExForDpi and p_FlashWindowEx - some pointers to Windows API functions set up by assigning them at startup to the right one of the ANSI or Unicode version depending on the Windows version, e.g. sw_DefWindowProc and sw_DispatchMessage - 'unicode_window', a boolean flag set at the same time as those sw_Foo function pointers - 'sesslist', storing the last-retrieved version of the saved sessions menu - 'cursor_visible' in show_mouseptr() and 'forced_visible' in update_mouse_pointer(), each of which tracks the cumulative number of times that function has shown or hidden the mouse pointer, so as to manage its effect on the global state updated by ShowCursor - 'trust_icon', loaded from the executable's resources - 'wgslisthead', the list of all active WinGuiSeats - 'wm_mousewheel', the window-message id we use for mouse wheel events and the following which are nothing to do with our code: - '_OptionsStorage' in __local_stdio_printf_options() and __local_stdio_scanf_options(), which I'd never noticed before, but apparently are internal to a standard library header.
2023-05-27 13:59:20 +00:00
if (win_width != (wgs->font_width*wgs->term->cols +
wgs->offset_width*2) ||
win_height != (wgs->font_height*wgs->term->rows +
wgs->offset_height*2)) {
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
Remove some pointless 'static' qualifiers. In windows/window.c, a few variables inside functions were declared as static, with no particular purpose that I can see: they don't seem to have any reason to persist between calls to the function. So it makes more sense to have them be ordinary stack-allocated automatic variables. Static variables removed by this commit: - 'RECT ss' in reset_window. - 'WORD keys[3]' and 'BYTE keysb[3]' in TranslateKey. - several (buffer, length) pairs in do_text_internal. - keys_unicode[] in TranslateKey. All of these variables were originally introduced in patches credited to Robert de Bath, which means I can't even try to reconstruct my original thought processes, because they weren't _my_ thoughts anyway. The arrays in do_text_internal are the easiest to understand: they're reallocated larger as necessary, and making them static means the allocation from a previous call can be reused, saving a malloc (though I don't think that's a good enough reason to bother, these days). The fixed-size static arrays and RECT are harder to explain. I suspect they might originally have been that way because of 1990s attitudes to performance: in x86-32 it's probably marginally faster to give your variables constant addresses than sp-relative ones, and in the 1990s computers were much slower, so there's an argument for making things static if you have no _need_ to make them automatic. These days, the difference is negligible, and persistent state is much more widely recognised as a risk! But keys_unicode[] is by far the strangest, because there was code that clearly _did_ expect it to persist between calls, namely three assignments to keys_unicode[0] near the end of the function after it's finished being used for any other purpose, and a conditioned-out set of debug() calls at the top of the function that print its contents before anything has yet written to it. But as far as I can see, the persistent data in the array is otherwise completely unused. In any call to the function, if keys_unicode is used at all, then it's either written directly by a call to ToAsciiEx, or else (for pre-NT platforms) converted from ToAsciiEx's output via MultiByteToWideChar. In both cases, the integer variable 'r' indicates how many array elements were written, and subsequent accesses only ever read those elements. So the assignments to keys_unicode[0] at the end of the previous call will be overwritten before anything at all can depend on them - with the exception of those debug statements. I don't really understand what was going on here. It's tempting to guess that those final assignments must have once done something useful, and the code that used them was later removed. But the source control history doesn't bear that out: a static array of three elements (under its original name 'keys') was introduced in commit 0d5d39064a0d078, and then commits 953b7775b321a60 and 26f1085038d7cd9 added the other two assignments. And as far as I can see, even as of the original commit 0d5d39064a0d078, the code already had the property that there was a final assignment to keys[0] which would inevitably be overwritten in the next call before it could affect anything. So I'm totally confused about what those assignments were _ever_ useful for. But an email thread from the time suggests that some of those patches were being rebased repeatedly past other work (or rather, the much less reliable CVS analogue of rebasing), so my best guess is that that's where the confusion crept in - perhaps in RDB's original version of the code they did do something useful. Regardless of that, I'm pretty convinced that persistent array can't be doing anything useful _now_. So I'm taking it out. But if anyone reports a bug resulting from this change, then I'll eat my words - and with any luck the details of the bug report will give us a clue what's going on, and then we can put back some equivalent functionality with much better comments!
2023-05-27 13:56:31 +00:00
RECT ss;
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
int width, height;
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
get_fullscreen_rect(wgs, &ss);
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
windows/window.c: move more variables into WinGuiSeat. In commit f9e572595bb8cb6 I claimed that I'd removed very nearly all the global and static variables from windows/window.c. It turns out that this was wildly overoptimistic - I missed quite a few of them! I'm not quite sure how I managed that; my best guess is that I used an underpowered 'nm' command that failed to find some classes of variable. Some of the remaining function-scope statics were removed completely by commit afb3dab1e97a09f just now. In this commit, I've swept up some more and turn them into fields of WinGuiSeat, where they should have been moved last September. The (hopefully complete this time) list of remaining variables, generated by running this rune in the Windows build directory: nm windows/CMakeFiles/putty.dir/window.c.obj | grep -E '^([^ ]+)? *[bBcCdDgGsS] [^\.]' consists of the following variables which are legitimately global across the whole process and not related to a particular window: - 'hinst' and 'hprev', instance handles for Windows loadable modules - 'classname' in the terminal_window_class_a() and terminal_window_class_w() functions, which allocate a window class reusably - some pointers to Windows API functions retrieved via the DECL_WINDOWS_FUNCTION / GET_WINDOWS_FUNCTION system, such as p_AdjustWindowRectExForDpi and p_FlashWindowEx - some pointers to Windows API functions set up by assigning them at startup to the right one of the ANSI or Unicode version depending on the Windows version, e.g. sw_DefWindowProc and sw_DispatchMessage - 'unicode_window', a boolean flag set at the same time as those sw_Foo function pointers - 'sesslist', storing the last-retrieved version of the saved sessions menu - 'cursor_visible' in show_mouseptr() and 'forced_visible' in update_mouse_pointer(), each of which tracks the cumulative number of times that function has shown or hidden the mouse pointer, so as to manage its effect on the global state updated by ShowCursor - 'trust_icon', loaded from the executable's resources - 'wgslisthead', the list of all active WinGuiSeats - 'wm_mousewheel', the window-message id we use for mouse wheel events and the following which are nothing to do with our code: - '_OptionsStorage' in __local_stdio_printf_options() and __local_stdio_scanf_options(), which I'd never noticed before, but apparently are internal to a standard library header.
2023-05-27 13:59:20 +00:00
width = (ss.right - ss.left - wgs->extra_width) / wgs->font_width;
height = (ss.bottom - ss.top - wgs->extra_height)/wgs->font_height;
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
/* Grrr too big */
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
if ( wgs->term->rows > height || wgs->term->cols > width ) {
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
if (resize_action == RESIZE_EITHER) {
/* Make the font the biggest we can */
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
if (wgs->term->cols > width)
windows/window.c: move more variables into WinGuiSeat. In commit f9e572595bb8cb6 I claimed that I'd removed very nearly all the global and static variables from windows/window.c. It turns out that this was wildly overoptimistic - I missed quite a few of them! I'm not quite sure how I managed that; my best guess is that I used an underpowered 'nm' command that failed to find some classes of variable. Some of the remaining function-scope statics were removed completely by commit afb3dab1e97a09f just now. In this commit, I've swept up some more and turn them into fields of WinGuiSeat, where they should have been moved last September. The (hopefully complete this time) list of remaining variables, generated by running this rune in the Windows build directory: nm windows/CMakeFiles/putty.dir/window.c.obj | grep -E '^([^ ]+)? *[bBcCdDgGsS] [^\.]' consists of the following variables which are legitimately global across the whole process and not related to a particular window: - 'hinst' and 'hprev', instance handles for Windows loadable modules - 'classname' in the terminal_window_class_a() and terminal_window_class_w() functions, which allocate a window class reusably - some pointers to Windows API functions retrieved via the DECL_WINDOWS_FUNCTION / GET_WINDOWS_FUNCTION system, such as p_AdjustWindowRectExForDpi and p_FlashWindowEx - some pointers to Windows API functions set up by assigning them at startup to the right one of the ANSI or Unicode version depending on the Windows version, e.g. sw_DefWindowProc and sw_DispatchMessage - 'unicode_window', a boolean flag set at the same time as those sw_Foo function pointers - 'sesslist', storing the last-retrieved version of the saved sessions menu - 'cursor_visible' in show_mouseptr() and 'forced_visible' in update_mouse_pointer(), each of which tracks the cumulative number of times that function has shown or hidden the mouse pointer, so as to manage its effect on the global state updated by ShowCursor - 'trust_icon', loaded from the executable's resources - 'wgslisthead', the list of all active WinGuiSeats - 'wm_mousewheel', the window-message id we use for mouse wheel events and the following which are nothing to do with our code: - '_OptionsStorage' in __local_stdio_printf_options() and __local_stdio_scanf_options(), which I'd never noticed before, but apparently are internal to a standard library header.
2023-05-27 13:59:20 +00:00
wgs->font_width =
(ss.right - ss.left - wgs->extra_width) /
wgs->term->cols;
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
if (wgs->term->rows > height)
windows/window.c: move more variables into WinGuiSeat. In commit f9e572595bb8cb6 I claimed that I'd removed very nearly all the global and static variables from windows/window.c. It turns out that this was wildly overoptimistic - I missed quite a few of them! I'm not quite sure how I managed that; my best guess is that I used an underpowered 'nm' command that failed to find some classes of variable. Some of the remaining function-scope statics were removed completely by commit afb3dab1e97a09f just now. In this commit, I've swept up some more and turn them into fields of WinGuiSeat, where they should have been moved last September. The (hopefully complete this time) list of remaining variables, generated by running this rune in the Windows build directory: nm windows/CMakeFiles/putty.dir/window.c.obj | grep -E '^([^ ]+)? *[bBcCdDgGsS] [^\.]' consists of the following variables which are legitimately global across the whole process and not related to a particular window: - 'hinst' and 'hprev', instance handles for Windows loadable modules - 'classname' in the terminal_window_class_a() and terminal_window_class_w() functions, which allocate a window class reusably - some pointers to Windows API functions retrieved via the DECL_WINDOWS_FUNCTION / GET_WINDOWS_FUNCTION system, such as p_AdjustWindowRectExForDpi and p_FlashWindowEx - some pointers to Windows API functions set up by assigning them at startup to the right one of the ANSI or Unicode version depending on the Windows version, e.g. sw_DefWindowProc and sw_DispatchMessage - 'unicode_window', a boolean flag set at the same time as those sw_Foo function pointers - 'sesslist', storing the last-retrieved version of the saved sessions menu - 'cursor_visible' in show_mouseptr() and 'forced_visible' in update_mouse_pointer(), each of which tracks the cumulative number of times that function has shown or hidden the mouse pointer, so as to manage its effect on the global state updated by ShowCursor - 'trust_icon', loaded from the executable's resources - 'wgslisthead', the list of all active WinGuiSeats - 'wm_mousewheel', the window-message id we use for mouse wheel events and the following which are nothing to do with our code: - '_OptionsStorage' in __local_stdio_printf_options() and __local_stdio_scanf_options(), which I'd never noticed before, but apparently are internal to a standard library header.
2023-05-27 13:59:20 +00:00
wgs->font_height =
(ss.bottom - ss.top - wgs->extra_height) /
wgs->term->rows;
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
deinit_fonts(wgs);
windows/window.c: move more variables into WinGuiSeat. In commit f9e572595bb8cb6 I claimed that I'd removed very nearly all the global and static variables from windows/window.c. It turns out that this was wildly overoptimistic - I missed quite a few of them! I'm not quite sure how I managed that; my best guess is that I used an underpowered 'nm' command that failed to find some classes of variable. Some of the remaining function-scope statics were removed completely by commit afb3dab1e97a09f just now. In this commit, I've swept up some more and turn them into fields of WinGuiSeat, where they should have been moved last September. The (hopefully complete this time) list of remaining variables, generated by running this rune in the Windows build directory: nm windows/CMakeFiles/putty.dir/window.c.obj | grep -E '^([^ ]+)? *[bBcCdDgGsS] [^\.]' consists of the following variables which are legitimately global across the whole process and not related to a particular window: - 'hinst' and 'hprev', instance handles for Windows loadable modules - 'classname' in the terminal_window_class_a() and terminal_window_class_w() functions, which allocate a window class reusably - some pointers to Windows API functions retrieved via the DECL_WINDOWS_FUNCTION / GET_WINDOWS_FUNCTION system, such as p_AdjustWindowRectExForDpi and p_FlashWindowEx - some pointers to Windows API functions set up by assigning them at startup to the right one of the ANSI or Unicode version depending on the Windows version, e.g. sw_DefWindowProc and sw_DispatchMessage - 'unicode_window', a boolean flag set at the same time as those sw_Foo function pointers - 'sesslist', storing the last-retrieved version of the saved sessions menu - 'cursor_visible' in show_mouseptr() and 'forced_visible' in update_mouse_pointer(), each of which tracks the cumulative number of times that function has shown or hidden the mouse pointer, so as to manage its effect on the global state updated by ShowCursor - 'trust_icon', loaded from the executable's resources - 'wgslisthead', the list of all active WinGuiSeats - 'wm_mousewheel', the window-message id we use for mouse wheel events and the following which are nothing to do with our code: - '_OptionsStorage' in __local_stdio_printf_options() and __local_stdio_scanf_options(), which I'd never noticed before, but apparently are internal to a standard library header.
2023-05-27 13:59:20 +00:00
init_fonts(wgs, wgs->font_width, wgs->font_height);
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
windows/window.c: move more variables into WinGuiSeat. In commit f9e572595bb8cb6 I claimed that I'd removed very nearly all the global and static variables from windows/window.c. It turns out that this was wildly overoptimistic - I missed quite a few of them! I'm not quite sure how I managed that; my best guess is that I used an underpowered 'nm' command that failed to find some classes of variable. Some of the remaining function-scope statics were removed completely by commit afb3dab1e97a09f just now. In this commit, I've swept up some more and turn them into fields of WinGuiSeat, where they should have been moved last September. The (hopefully complete this time) list of remaining variables, generated by running this rune in the Windows build directory: nm windows/CMakeFiles/putty.dir/window.c.obj | grep -E '^([^ ]+)? *[bBcCdDgGsS] [^\.]' consists of the following variables which are legitimately global across the whole process and not related to a particular window: - 'hinst' and 'hprev', instance handles for Windows loadable modules - 'classname' in the terminal_window_class_a() and terminal_window_class_w() functions, which allocate a window class reusably - some pointers to Windows API functions retrieved via the DECL_WINDOWS_FUNCTION / GET_WINDOWS_FUNCTION system, such as p_AdjustWindowRectExForDpi and p_FlashWindowEx - some pointers to Windows API functions set up by assigning them at startup to the right one of the ANSI or Unicode version depending on the Windows version, e.g. sw_DefWindowProc and sw_DispatchMessage - 'unicode_window', a boolean flag set at the same time as those sw_Foo function pointers - 'sesslist', storing the last-retrieved version of the saved sessions menu - 'cursor_visible' in show_mouseptr() and 'forced_visible' in update_mouse_pointer(), each of which tracks the cumulative number of times that function has shown or hidden the mouse pointer, so as to manage its effect on the global state updated by ShowCursor - 'trust_icon', loaded from the executable's resources - 'wgslisthead', the list of all active WinGuiSeats - 'wm_mousewheel', the window-message id we use for mouse wheel events and the following which are nothing to do with our code: - '_OptionsStorage' in __local_stdio_printf_options() and __local_stdio_scanf_options(), which I'd never noticed before, but apparently are internal to a standard library header.
2023-05-27 13:59:20 +00:00
width = (ss.right - ss.left - wgs->extra_width) /
wgs->font_width;
height = (ss.bottom - ss.top - wgs->extra_height) /
wgs->font_height;
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
} else {
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
if ( height > wgs->term->rows ) height = wgs->term->rows;
if ( width > wgs->term->cols ) width = wgs->term->cols;
term_size(wgs->term, height, width,
conf_get_int(wgs->conf, CONF_savelines));
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
}
}
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
SetWindowPos(wgs->term_hwnd, NULL, 0, 0,
windows/window.c: move more variables into WinGuiSeat. In commit f9e572595bb8cb6 I claimed that I'd removed very nearly all the global and static variables from windows/window.c. It turns out that this was wildly overoptimistic - I missed quite a few of them! I'm not quite sure how I managed that; my best guess is that I used an underpowered 'nm' command that failed to find some classes of variable. Some of the remaining function-scope statics were removed completely by commit afb3dab1e97a09f just now. In this commit, I've swept up some more and turn them into fields of WinGuiSeat, where they should have been moved last September. The (hopefully complete this time) list of remaining variables, generated by running this rune in the Windows build directory: nm windows/CMakeFiles/putty.dir/window.c.obj | grep -E '^([^ ]+)? *[bBcCdDgGsS] [^\.]' consists of the following variables which are legitimately global across the whole process and not related to a particular window: - 'hinst' and 'hprev', instance handles for Windows loadable modules - 'classname' in the terminal_window_class_a() and terminal_window_class_w() functions, which allocate a window class reusably - some pointers to Windows API functions retrieved via the DECL_WINDOWS_FUNCTION / GET_WINDOWS_FUNCTION system, such as p_AdjustWindowRectExForDpi and p_FlashWindowEx - some pointers to Windows API functions set up by assigning them at startup to the right one of the ANSI or Unicode version depending on the Windows version, e.g. sw_DefWindowProc and sw_DispatchMessage - 'unicode_window', a boolean flag set at the same time as those sw_Foo function pointers - 'sesslist', storing the last-retrieved version of the saved sessions menu - 'cursor_visible' in show_mouseptr() and 'forced_visible' in update_mouse_pointer(), each of which tracks the cumulative number of times that function has shown or hidden the mouse pointer, so as to manage its effect on the global state updated by ShowCursor - 'trust_icon', loaded from the executable's resources - 'wgslisthead', the list of all active WinGuiSeats - 'wm_mousewheel', the window-message id we use for mouse wheel events and the following which are nothing to do with our code: - '_OptionsStorage' in __local_stdio_printf_options() and __local_stdio_scanf_options(), which I'd never noticed before, but apparently are internal to a standard library header.
2023-05-27 13:59:20 +00:00
wgs->font_width*wgs->term->cols + wgs->extra_width,
wgs->font_height*wgs->term->rows + wgs->extra_height,
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
SWP_NOMOVE | SWP_NOZORDER);
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
InvalidateRect(wgs->term_hwnd, NULL, true);
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
}
return;
Three more patches from RDB: one to make Atomica work right, one to fiddle with the widths of characters in DBCS screen fonts, and (the big one) one to enable a mode in which resizing the window locks the terminal size and lets the font change, instead of vice versa. That should shut up a few feature requests! [originally from svn r1269]
2001-09-15 15:54:24 +00:00
}
/* We're allowed to or must change the font but do we want to ? */
windows/window.c: move more variables into WinGuiSeat. In commit f9e572595bb8cb6 I claimed that I'd removed very nearly all the global and static variables from windows/window.c. It turns out that this was wildly overoptimistic - I missed quite a few of them! I'm not quite sure how I managed that; my best guess is that I used an underpowered 'nm' command that failed to find some classes of variable. Some of the remaining function-scope statics were removed completely by commit afb3dab1e97a09f just now. In this commit, I've swept up some more and turn them into fields of WinGuiSeat, where they should have been moved last September. The (hopefully complete this time) list of remaining variables, generated by running this rune in the Windows build directory: nm windows/CMakeFiles/putty.dir/window.c.obj | grep -E '^([^ ]+)? *[bBcCdDgGsS] [^\.]' consists of the following variables which are legitimately global across the whole process and not related to a particular window: - 'hinst' and 'hprev', instance handles for Windows loadable modules - 'classname' in the terminal_window_class_a() and terminal_window_class_w() functions, which allocate a window class reusably - some pointers to Windows API functions retrieved via the DECL_WINDOWS_FUNCTION / GET_WINDOWS_FUNCTION system, such as p_AdjustWindowRectExForDpi and p_FlashWindowEx - some pointers to Windows API functions set up by assigning them at startup to the right one of the ANSI or Unicode version depending on the Windows version, e.g. sw_DefWindowProc and sw_DispatchMessage - 'unicode_window', a boolean flag set at the same time as those sw_Foo function pointers - 'sesslist', storing the last-retrieved version of the saved sessions menu - 'cursor_visible' in show_mouseptr() and 'forced_visible' in update_mouse_pointer(), each of which tracks the cumulative number of times that function has shown or hidden the mouse pointer, so as to manage its effect on the global state updated by ShowCursor - 'trust_icon', loaded from the executable's resources - 'wgslisthead', the list of all active WinGuiSeats - 'wm_mousewheel', the window-message id we use for mouse wheel events and the following which are nothing to do with our code: - '_OptionsStorage' in __local_stdio_printf_options() and __local_stdio_scanf_options(), which I'd never noticed before, but apparently are internal to a standard library header.
2023-05-27 13:59:20 +00:00
if (wgs->font_width != (win_width-window_border*2)/wgs->term->cols ||
wgs->font_height != (win_height-window_border*2)/wgs->term->rows) {
Three more patches from RDB: one to make Atomica work right, one to fiddle with the widths of characters in DBCS screen fonts, and (the big one) one to enable a mode in which resizing the window locks the terminal size and lets the font change, instead of vice versa. That should shut up a few feature requests! [originally from svn r1269]
2001-09-15 15:54:24 +00:00
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
deinit_fonts(wgs);
init_fonts(wgs, (win_width-window_border*2)/wgs->term->cols,
(win_height-window_border*2)/wgs->term->rows);
windows/window.c: move more variables into WinGuiSeat. In commit f9e572595bb8cb6 I claimed that I'd removed very nearly all the global and static variables from windows/window.c. It turns out that this was wildly overoptimistic - I missed quite a few of them! I'm not quite sure how I managed that; my best guess is that I used an underpowered 'nm' command that failed to find some classes of variable. Some of the remaining function-scope statics were removed completely by commit afb3dab1e97a09f just now. In this commit, I've swept up some more and turn them into fields of WinGuiSeat, where they should have been moved last September. The (hopefully complete this time) list of remaining variables, generated by running this rune in the Windows build directory: nm windows/CMakeFiles/putty.dir/window.c.obj | grep -E '^([^ ]+)? *[bBcCdDgGsS] [^\.]' consists of the following variables which are legitimately global across the whole process and not related to a particular window: - 'hinst' and 'hprev', instance handles for Windows loadable modules - 'classname' in the terminal_window_class_a() and terminal_window_class_w() functions, which allocate a window class reusably - some pointers to Windows API functions retrieved via the DECL_WINDOWS_FUNCTION / GET_WINDOWS_FUNCTION system, such as p_AdjustWindowRectExForDpi and p_FlashWindowEx - some pointers to Windows API functions set up by assigning them at startup to the right one of the ANSI or Unicode version depending on the Windows version, e.g. sw_DefWindowProc and sw_DispatchMessage - 'unicode_window', a boolean flag set at the same time as those sw_Foo function pointers - 'sesslist', storing the last-retrieved version of the saved sessions menu - 'cursor_visible' in show_mouseptr() and 'forced_visible' in update_mouse_pointer(), each of which tracks the cumulative number of times that function has shown or hidden the mouse pointer, so as to manage its effect on the global state updated by ShowCursor - 'trust_icon', loaded from the executable's resources - 'wgslisthead', the list of all active WinGuiSeats - 'wm_mousewheel', the window-message id we use for mouse wheel events and the following which are nothing to do with our code: - '_OptionsStorage' in __local_stdio_printf_options() and __local_stdio_scanf_options(), which I'd never noticed before, but apparently are internal to a standard library header.
2023-05-27 13:59:20 +00:00
wgs->offset_width = (win_width-wgs->font_width*wgs->term->cols)/2;
wgs->offset_height = (win_height-wgs->font_height*wgs->term->rows)/2;
Three more patches from RDB: one to make Atomica work right, one to fiddle with the widths of characters in DBCS screen fonts, and (the big one) one to enable a mode in which resizing the window locks the terminal size and lets the font change, instead of vice versa. That should shut up a few feature requests! [originally from svn r1269]
2001-09-15 15:54:24 +00:00
windows/window.c: move more variables into WinGuiSeat. In commit f9e572595bb8cb6 I claimed that I'd removed very nearly all the global and static variables from windows/window.c. It turns out that this was wildly overoptimistic - I missed quite a few of them! I'm not quite sure how I managed that; my best guess is that I used an underpowered 'nm' command that failed to find some classes of variable. Some of the remaining function-scope statics were removed completely by commit afb3dab1e97a09f just now. In this commit, I've swept up some more and turn them into fields of WinGuiSeat, where they should have been moved last September. The (hopefully complete this time) list of remaining variables, generated by running this rune in the Windows build directory: nm windows/CMakeFiles/putty.dir/window.c.obj | grep -E '^([^ ]+)? *[bBcCdDgGsS] [^\.]' consists of the following variables which are legitimately global across the whole process and not related to a particular window: - 'hinst' and 'hprev', instance handles for Windows loadable modules - 'classname' in the terminal_window_class_a() and terminal_window_class_w() functions, which allocate a window class reusably - some pointers to Windows API functions retrieved via the DECL_WINDOWS_FUNCTION / GET_WINDOWS_FUNCTION system, such as p_AdjustWindowRectExForDpi and p_FlashWindowEx - some pointers to Windows API functions set up by assigning them at startup to the right one of the ANSI or Unicode version depending on the Windows version, e.g. sw_DefWindowProc and sw_DispatchMessage - 'unicode_window', a boolean flag set at the same time as those sw_Foo function pointers - 'sesslist', storing the last-retrieved version of the saved sessions menu - 'cursor_visible' in show_mouseptr() and 'forced_visible' in update_mouse_pointer(), each of which tracks the cumulative number of times that function has shown or hidden the mouse pointer, so as to manage its effect on the global state updated by ShowCursor - 'trust_icon', loaded from the executable's resources - 'wgslisthead', the list of all active WinGuiSeats - 'wm_mousewheel', the window-message id we use for mouse wheel events and the following which are nothing to do with our code: - '_OptionsStorage' in __local_stdio_printf_options() and __local_stdio_scanf_options(), which I'd never noticed before, but apparently are internal to a standard library header.
2023-05-27 13:59:20 +00:00
wgs->extra_width =
wr.right - wr.left - cr.right + cr.left + wgs->offset_width*2;
wgs->extra_height =
wr.bottom - wr.top - cr.bottom + cr.top + wgs->offset_height*2;
Three more patches from RDB: one to make Atomica work right, one to fiddle with the widths of characters in DBCS screen fonts, and (the big one) one to enable a mode in which resizing the window locks the terminal size and lets the font change, instead of vice versa. That should shut up a few feature requests! [originally from svn r1269]
2001-09-15 15:54:24 +00:00
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
InvalidateRect(wgs->term_hwnd, NULL, true);
Three more patches from RDB: one to make Atomica work right, one to fiddle with the widths of characters in DBCS screen fonts, and (the big one) one to enable a mode in which resizing the window locks the terminal size and lets the font change, instead of vice versa. That should shut up a few feature requests! [originally from svn r1269]
2001-09-15 15:54:24 +00:00
}
Initial checkin: beta 0.43 [originally from svn r11]
1999-01-08 13:02:13 +00:00
}
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
static void set_input_locale(WinGuiSeat *wgs, HKL kl)
Set up kbd_codepage at the start of the program, as well as when the input locale changes. With any luck this should sort out the Polish Unicode problems. [originally from svn r1427]
2001-11-29 21:30:59 +00:00
{
char lbuf[20];
GetLocaleInfo(LOWORD(kl), LOCALE_IDEFAULTANSICODEPAGE,
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
lbuf, sizeof(lbuf));
Set up kbd_codepage at the start of the program, as well as when the input locale changes. With any luck this should sort out the Polish Unicode problems. [originally from svn r1427]
2001-11-29 21:30:59 +00:00
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
wgs->kbd_codepage = atoi(lbuf);
Set up kbd_codepage at the start of the program, as well as when the input locale changes. With any luck this should sort out the Polish Unicode problems. [originally from svn r1427]
2001-11-29 21:30:59 +00:00
}
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
static void click(WinGuiSeat *wgs, Mouse_Button b, int x, int y,
Convert a lot of 'int' variables to 'bool'. My normal habit these days, in new code, is to treat int and bool as _almost_ completely separate types. I'm still willing to use C's implicit test for zero on an integer (e.g. 'if (!blob.len)' is fine, no need to spell it out as blob.len != 0), but generally, if a variable is going to be conceptually a boolean, I like to declare it bool and assign to it using 'true' or 'false' rather than 0 or 1. PuTTY is an exception, because it predates the C99 bool, and I've stuck to its existing coding style even when adding new code to it. But it's been annoying me more and more, so now that I've decided C99 bool is an acceptable thing to require from our toolchain in the first place, here's a quite thorough trawl through the source doing 'boolification'. Many variables and function parameters are now typed as bool rather than int; many assignments of 0 or 1 to those variables are now spelled 'true' or 'false'. I managed this thorough conversion with the help of a custom clang plugin that I wrote to trawl the AST and apply heuristics to point out where things might want changing. So I've even managed to do a decent job on parts of the code I haven't looked at in years! To make the plugin's work easier, I pushed platform front ends generally in the direction of using standard 'bool' in preference to platform-specific boolean types like Windows BOOL or GTK's gboolean; I've left the platform booleans in places they _have_ to be for the platform APIs to work right, but variables only used by my own code have been converted wherever I found them. In a few places there are int values that look very like booleans in _most_ of the places they're used, but have a rarely-used third value, or a distinction between different nonzero values that most users don't care about. In these cases, I've _removed_ uses of 'true' and 'false' for the return values, to emphasise that there's something more subtle going on than a simple boolean answer: - the 'multisel' field in dialog.h's list box structure, for which the GTK front end in particular recognises a difference between 1 and 2 but nearly everything else treats as boolean - the 'urgent' parameter to plug_receive, where 1 vs 2 tells you something about the specific location of the urgent pointer, but most clients only care about 0 vs 'something nonzero' - the return value of wc_match, where -1 indicates a syntax error in the wildcard. - the return values from SSH-1 RSA-key loading functions, which use -1 for 'wrong passphrase' and 0 for all other failures (so any caller which already knows it's not loading an _encrypted private_ key can treat them as boolean) - term->esc_query, and the 'query' parameter in toggle_mode in terminal.c, which _usually_ hold 0 for ESC[123h or 1 for ESC[?123h, but can also hold -1 for some other intervening character that we don't support. In a few places there's an integer that I haven't turned into a bool even though it really _can_ only take values 0 or 1 (and, as above, tried to make the call sites consistent in not calling those values true and false), on the grounds that I thought it would make it more confusing to imply that the 0 value was in some sense 'negative' or bad and the 1 positive or good: - the return value of plug_accepting uses the POSIXish convention of 0=success and nonzero=error; I think if I made it bool then I'd also want to reverse its sense, and that's a job for a separate piece of work. - the 'screen' parameter to lineptr() in terminal.c, where 0 and 1 represent the default and alternate screens. There's no obvious reason why one of those should be considered 'true' or 'positive' or 'success' - they're just indices - so I've left it as int. ssh_scp_recv had particularly confusing semantics for its previous int return value: its call sites used '<= 0' to check for error, but it never actually returned a negative number, just 0 or 1. Now the function and its call sites agree that it's a bool. In a couple of places I've renamed variables called 'ret', because I don't like that name any more - it's unclear whether it means the return value (in preparation) for the _containing_ function or the return value received from a subroutine call, and occasionally I've accidentally used the same variable for both and introduced a bug. So where one of those got in my way, I've renamed it to 'toret' or 'retd' (the latter short for 'returned') in line with my usual modern practice, but I haven't done a thorough job of finding all of them. Finally, one amusing side effect of doing this is that I've had to separate quite a few chained assignments. It used to be perfectly fine to write 'a = b = c = TRUE' when a,b,c were int and TRUE was just a the 'true' defined by stdbool.h, that idiom provokes a warning from gcc: 'suggest parentheses around assignment used as truth value'!
2018-11-02 19:23:19 +00:00
bool shift, bool ctrl, bool alt)
Run entire source base through GNU indent to tidy up the varying coding styles of the various contributors! Woohoo! [originally from svn r1098]
2001-05-06 14:35:20 +00:00
{
Fix double/triple click, and improve drag select [originally from svn r19]
1999-01-22 09:35:08 +00:00
int thistime = GetMessageTime();
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
if (wgs->send_raw_mouse &&
!(shift && conf_get_bool(wgs->conf, CONF_mouse_override))) {
wgs->lastbtn = MBT_NOTHING;
term_mouse(wgs->term, b, translate_button(wgs, b), MA_CLICK,
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
x, y, shift, ctrl, alt);
return;
Wez Furlong's patch to add xterm mouse reporting and proper mouse wheel support. [originally from svn r1097]
2001-05-06 14:20:41 +00:00
}
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
if (wgs->lastbtn == b && thistime - wgs->lasttime < wgs->dbltime) {
wgs->lastact = (wgs->lastact == MA_CLICK ? MA_2CLK :
wgs->lastact == MA_2CLK ? MA_3CLK :
wgs->lastact == MA_3CLK ? MA_CLICK : MA_NOTHING);
Initial checkin: beta 0.43 [originally from svn r11]
1999-01-08 13:02:13 +00:00
} else {
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
wgs->lastbtn = b;
wgs->lastact = MA_CLICK;
Initial checkin: beta 0.43 [originally from svn r11]
1999-01-08 13:02:13 +00:00
}
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
if (wgs->lastact != MA_NOTHING)
term_mouse(wgs->term, b, translate_button(wgs, b), wgs->lastact,
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
x, y, shift, ctrl, alt);
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
wgs->lasttime = thistime;
Initial checkin: beta 0.43 [originally from svn r11]
1999-01-08 13:02:13 +00:00
}
Wez Furlong's patch to add xterm mouse reporting and proper mouse wheel support. [originally from svn r1097]
2001-05-06 14:20:41 +00:00
/*
* Translate a raw mouse button designation (LEFT, MIDDLE, RIGHT)
* into a cooked one (SELECT, EXTEND, PASTE).
*/
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
static Mouse_Button translate_button(WinGuiSeat *wgs, Mouse_Button button)
Run entire source base through GNU indent to tidy up the varying coding styles of the various contributors! Woohoo! [originally from svn r1098]
2001-05-06 14:35:20 +00:00
{
Wez Furlong's patch to add xterm mouse reporting and proper mouse wheel support. [originally from svn r1097]
2001-05-06 14:20:41 +00:00
if (button == MBT_LEFT)
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
return MBT_SELECT;
Wez Furlong's patch to add xterm mouse reporting and proper mouse wheel support. [originally from svn r1097]
2001-05-06 14:20:41 +00:00
if (button == MBT_MIDDLE)
Cleanup: make an enum for the values of CONF_mouse_is_xterm. Again, there's no sensible reason why these should be written at the point of use as bare integers.
2023-05-29 14:52:32 +00:00
return conf_get_int(wgs->conf, CONF_mouse_is_xterm) == MOUSE_XTERM ?
Formatting: miscellaneous. This patch fixes a few other whitespace and formatting issues which were pointed out by the bulk-reindent or which I spotted in passing, some involving manual editing to break lines more nicely. I think the weirdest hunk in here is the one in windows/window.c TranslateKey() where _half_ of an assignment statement inside an 'if' was on the same line as the trailing paren of the if condition. No idea at all how that one managed to happen!
2022-08-03 19:48:46 +00:00
MBT_PASTE : MBT_EXTEND;
Wez Furlong's patch to add xterm mouse reporting and proper mouse wheel support. [originally from svn r1097]
2001-05-06 14:20:41 +00:00
if (button == MBT_RIGHT)
Cleanup: make an enum for the values of CONF_mouse_is_xterm. Again, there's no sensible reason why these should be written at the point of use as bare integers.
2023-05-29 14:52:32 +00:00
return conf_get_int(wgs->conf, CONF_mouse_is_xterm) == MOUSE_XTERM ?
Formatting: miscellaneous. This patch fixes a few other whitespace and formatting issues which were pointed out by the bulk-reindent or which I spotted in passing, some involving manual editing to break lines more nicely. I think the weirdest hunk in here is the one in windows/window.c TranslateKey() where _half_ of an assignment statement inside an 'if' was on the same line as the trailing paren of the if condition. No idea at all how that one managed to happen!
2022-08-03 19:48:46 +00:00
MBT_EXTEND : MBT_PASTE;
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
return 0; /* shouldn't happen */
Wez Furlong's patch to add xterm mouse reporting and proper mouse wheel support. [originally from svn r1097]
2001-05-06 14:20:41 +00:00
}
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
static void show_mouseptr(WinGuiSeat *wgs, bool show)
Run entire source base through GNU indent to tidy up the varying coding styles of the various contributors! Woohoo! [originally from svn r1098]
2001-05-06 14:35:20 +00:00
{
The terminal window can now indicate that PuTTY is busy in various ways, by changing its mouse pointer. Currently this is only used in the (slightly- arbitrarily-defined) "heavy" bits of SSH-2 key exchange. We override pointer hiding while PuTTY is busy, but preserve pointer-hiding state. Not yet implemented on the Mac. Also switch to frobbing window-class cursor in Windows rather than relying on SetCursor(). [originally from svn r5303]
2005-02-15 17:05:58 +00:00
/* NB that the counter in ShowCursor() is also frobbed by
* update_mouse_pointer() */
Convert a lot of 'int' variables to 'bool'. My normal habit these days, in new code, is to treat int and bool as _almost_ completely separate types. I'm still willing to use C's implicit test for zero on an integer (e.g. 'if (!blob.len)' is fine, no need to spell it out as blob.len != 0), but generally, if a variable is going to be conceptually a boolean, I like to declare it bool and assign to it using 'true' or 'false' rather than 0 or 1. PuTTY is an exception, because it predates the C99 bool, and I've stuck to its existing coding style even when adding new code to it. But it's been annoying me more and more, so now that I've decided C99 bool is an acceptable thing to require from our toolchain in the first place, here's a quite thorough trawl through the source doing 'boolification'. Many variables and function parameters are now typed as bool rather than int; many assignments of 0 or 1 to those variables are now spelled 'true' or 'false'. I managed this thorough conversion with the help of a custom clang plugin that I wrote to trawl the AST and apply heuristics to point out where things might want changing. So I've even managed to do a decent job on parts of the code I haven't looked at in years! To make the plugin's work easier, I pushed platform front ends generally in the direction of using standard 'bool' in preference to platform-specific boolean types like Windows BOOL or GTK's gboolean; I've left the platform booleans in places they _have_ to be for the platform APIs to work right, but variables only used by my own code have been converted wherever I found them. In a few places there are int values that look very like booleans in _most_ of the places they're used, but have a rarely-used third value, or a distinction between different nonzero values that most users don't care about. In these cases, I've _removed_ uses of 'true' and 'false' for the return values, to emphasise that there's something more subtle going on than a simple boolean answer: - the 'multisel' field in dialog.h's list box structure, for which the GTK front end in particular recognises a difference between 1 and 2 but nearly everything else treats as boolean - the 'urgent' parameter to plug_receive, where 1 vs 2 tells you something about the specific location of the urgent pointer, but most clients only care about 0 vs 'something nonzero' - the return value of wc_match, where -1 indicates a syntax error in the wildcard. - the return values from SSH-1 RSA-key loading functions, which use -1 for 'wrong passphrase' and 0 for all other failures (so any caller which already knows it's not loading an _encrypted private_ key can treat them as boolean) - term->esc_query, and the 'query' parameter in toggle_mode in terminal.c, which _usually_ hold 0 for ESC[123h or 1 for ESC[?123h, but can also hold -1 for some other intervening character that we don't support. In a few places there's an integer that I haven't turned into a bool even though it really _can_ only take values 0 or 1 (and, as above, tried to make the call sites consistent in not calling those values true and false), on the grounds that I thought it would make it more confusing to imply that the 0 value was in some sense 'negative' or bad and the 1 positive or good: - the return value of plug_accepting uses the POSIXish convention of 0=success and nonzero=error; I think if I made it bool then I'd also want to reverse its sense, and that's a job for a separate piece of work. - the 'screen' parameter to lineptr() in terminal.c, where 0 and 1 represent the default and alternate screens. There's no obvious reason why one of those should be considered 'true' or 'positive' or 'success' - they're just indices - so I've left it as int. ssh_scp_recv had particularly confusing semantics for its previous int return value: its call sites used '<= 0' to check for error, but it never actually returned a negative number, just 0 or 1. Now the function and its call sites agree that it's a bool. In a couple of places I've renamed variables called 'ret', because I don't like that name any more - it's unclear whether it means the return value (in preparation) for the _containing_ function or the return value received from a subroutine call, and occasionally I've accidentally used the same variable for both and introduced a bug. So where one of those got in my way, I've renamed it to 'toret' or 'retd' (the latter short for 'returned') in line with my usual modern practice, but I haven't done a thorough job of finding all of them. Finally, one amusing side effect of doing this is that I've had to separate quite a few chained assignments. It used to be perfectly fine to write 'a = b = c = TRUE' when a,b,c were int and TRUE was just a the 'true' defined by stdbool.h, that idiom provokes a warning from gcc: 'suggest parentheses around assignment used as truth value'!
2018-11-02 19:23:19 +00:00
static bool cursor_visible = true;
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
if (wgs) {
if (!conf_get_bool(wgs->conf, CONF_hide_mouseptr))
show = true; /* hiding mouse pointer disabled in Conf */
} else {
/*
* You can pass wgs==NULL if you want to _show_ the pointer
* rather than hiding it, because that's never disallowed.
*/
assert(show);
}
Ability to hide the mouse pointer on a keypress a la Word [originally from svn r883]
2001-01-22 16:38:43 +00:00
if (cursor_visible && !show)
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
ShowCursor(false);
Ability to hide the mouse pointer on a keypress a la Word [originally from svn r883]
2001-01-22 16:38:43 +00:00
else if (!cursor_visible && show)
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
ShowCursor(true);
Ability to hide the mouse pointer on a keypress a la Word [originally from svn r883]
2001-01-22 16:38:43 +00:00
cursor_visible = show;
}
Convert a lot of 'int' variables to 'bool'. My normal habit these days, in new code, is to treat int and bool as _almost_ completely separate types. I'm still willing to use C's implicit test for zero on an integer (e.g. 'if (!blob.len)' is fine, no need to spell it out as blob.len != 0), but generally, if a variable is going to be conceptually a boolean, I like to declare it bool and assign to it using 'true' or 'false' rather than 0 or 1. PuTTY is an exception, because it predates the C99 bool, and I've stuck to its existing coding style even when adding new code to it. But it's been annoying me more and more, so now that I've decided C99 bool is an acceptable thing to require from our toolchain in the first place, here's a quite thorough trawl through the source doing 'boolification'. Many variables and function parameters are now typed as bool rather than int; many assignments of 0 or 1 to those variables are now spelled 'true' or 'false'. I managed this thorough conversion with the help of a custom clang plugin that I wrote to trawl the AST and apply heuristics to point out where things might want changing. So I've even managed to do a decent job on parts of the code I haven't looked at in years! To make the plugin's work easier, I pushed platform front ends generally in the direction of using standard 'bool' in preference to platform-specific boolean types like Windows BOOL or GTK's gboolean; I've left the platform booleans in places they _have_ to be for the platform APIs to work right, but variables only used by my own code have been converted wherever I found them. In a few places there are int values that look very like booleans in _most_ of the places they're used, but have a rarely-used third value, or a distinction between different nonzero values that most users don't care about. In these cases, I've _removed_ uses of 'true' and 'false' for the return values, to emphasise that there's something more subtle going on than a simple boolean answer: - the 'multisel' field in dialog.h's list box structure, for which the GTK front end in particular recognises a difference between 1 and 2 but nearly everything else treats as boolean - the 'urgent' parameter to plug_receive, where 1 vs 2 tells you something about the specific location of the urgent pointer, but most clients only care about 0 vs 'something nonzero' - the return value of wc_match, where -1 indicates a syntax error in the wildcard. - the return values from SSH-1 RSA-key loading functions, which use -1 for 'wrong passphrase' and 0 for all other failures (so any caller which already knows it's not loading an _encrypted private_ key can treat them as boolean) - term->esc_query, and the 'query' parameter in toggle_mode in terminal.c, which _usually_ hold 0 for ESC[123h or 1 for ESC[?123h, but can also hold -1 for some other intervening character that we don't support. In a few places there's an integer that I haven't turned into a bool even though it really _can_ only take values 0 or 1 (and, as above, tried to make the call sites consistent in not calling those values true and false), on the grounds that I thought it would make it more confusing to imply that the 0 value was in some sense 'negative' or bad and the 1 positive or good: - the return value of plug_accepting uses the POSIXish convention of 0=success and nonzero=error; I think if I made it bool then I'd also want to reverse its sense, and that's a job for a separate piece of work. - the 'screen' parameter to lineptr() in terminal.c, where 0 and 1 represent the default and alternate screens. There's no obvious reason why one of those should be considered 'true' or 'positive' or 'success' - they're just indices - so I've left it as int. ssh_scp_recv had particularly confusing semantics for its previous int return value: its call sites used '<= 0' to check for error, but it never actually returned a negative number, just 0 or 1. Now the function and its call sites agree that it's a bool. In a couple of places I've renamed variables called 'ret', because I don't like that name any more - it's unclear whether it means the return value (in preparation) for the _containing_ function or the return value received from a subroutine call, and occasionally I've accidentally used the same variable for both and introduced a bug. So where one of those got in my way, I've renamed it to 'toret' or 'retd' (the latter short for 'returned') in line with my usual modern practice, but I haven't done a thorough job of finding all of them. Finally, one amusing side effect of doing this is that I've had to separate quite a few chained assignments. It used to be perfectly fine to write 'a = b = c = TRUE' when a,b,c were int and TRUE was just a the 'true' defined by stdbool.h, that idiom provokes a warning from gcc: 'suggest parentheses around assignment used as truth value'!
2018-11-02 19:23:19 +00:00
static bool is_alt_pressed(void)
Rectangular-block selection. Enabled by Alt+drag, unless you configure it to be the default in which case it's _dis_abled by Alt+drag. [originally from svn r1350]
2001-10-31 18:50:09 +00:00
{
BYTE keystate[256];
int r = GetKeyboardState(keystate);
if (!r)
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
return false;
Rectangular-block selection. Enabled by Alt+drag, unless you configure it to be the default in which case it's _dis_abled by Alt+drag. [originally from svn r1350]
2001-10-31 18:50:09 +00:00
if (keystate[VK_MENU] & 0x80)
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
return true;
Rectangular-block selection. Enabled by Alt+drag, unless you configure it to be the default in which case it's _dis_abled by Alt+drag. [originally from svn r1350]
2001-10-31 18:50:09 +00:00
if (keystate[VK_RMENU] & 0x80)
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
return true;
Adopt C99 <stdbool.h>'s true/false. This commit includes <stdbool.h> from defs.h and deletes my traditional definitions of TRUE and FALSE, but other than that, it's a 100% mechanical search-and-replace transforming all uses of TRUE and FALSE into the C99-standardised lowercase spellings. No actual types are changed in this commit; that will come next. This is just getting the noise out of the way, so that subsequent commits can have a higher proportion of signal.
2018-10-29 19:50:29 +00:00
return false;
Rectangular-block selection. Enabled by Alt+drag, unless you configure it to be the default in which case it's _dis_abled by Alt+drag. [originally from svn r1350]
2001-10-31 18:50:09 +00:00
}
Move contents of win_seat_notify_remote_exit into a callback. This matches the way it's done in the GTK backend: the only thing that happens inside seat_notify_remote_exit is that we schedule a toplevel callback, and all the real work happens later on when that callback is called. The particular situation where this makes a difference is if you perform a user abort during proxy authentication (e.g. hit ^D at a proxy password prompt), so that the main SSH backend gets PLUGCLOSE_USER_ABORT and calls ssh_user_close. That doesn't immediately close the socket; it just sets ssh->pending_close, schedules a run of ssh_bpp_output_raw_data_callback, and returns. So if seat_notify_remote_exit calls back _synchronously_ to ssh_return_exitcode, it will see that the socket is still open and return -1. But if it schedules a callback and waits, then the callback to ssh_bpp_output_raw_data_callback will happen first, which will close the socket, and then the exit processing will get the right answer. So the user-visible effect is that if you ^D a proxy auth prompt, GTK PuTTY will close the whole window (assuming you didn't set close-on- exit to 'never'), whereas Windows PuTTY will leave the window open, and not even know that the connection is now shut (in that it'll still ask 'Are you sure you want to close this session?' if you try to close it by hand). With this fix, Windows PuTTY behaves the same as GTK in this respect.
2022-05-19 16:44:39 +00:00
static void exit_callback(void *vctx)
Start using notify_remote_exit() in the Windows front end, in place of the previous ad-hockery which depended on the return value from select_result() and hence which will not adapt sensibly to a world in which the primary session is something local rather than a network connection. [originally from svn r6802]
2006-08-26 10:04:46 +00:00
{
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
WinGuiSeat *wgs = (WinGuiSeat *)vctx;
Post-release destabilisation! Completely remove the struct type 'Config' in putty.h, which stores all PuTTY's settings and includes an arbitrary length limit on every single one of those settings which is stored in string form. In place of it is 'Conf', an opaque data type everywhere outside the new file conf.c, which stores a list of (key, value) pairs in which every key contains an integer identifying a configuration setting, and for some of those integers the key also contains extra parts (so that, for instance, CONF_environmt is a string-to-string mapping). Everywhere that a Config was previously used, a Conf is now; everywhere there was a Config structure copy, conf_copy() is called; every lookup, adjustment, load and save operation on a Config has been rewritten; and there's a mechanism for serialising a Conf into a binary blob and back for use with Duplicate Session. User-visible effects of this change _should_ be minimal, though I don't doubt I've introduced one or two bugs here and there which will eventually be found. The _intended_ visible effects of this change are that all arbitrary limits on configuration strings and lists (e.g. limit on number of port forwardings) should now disappear; that list boxes in the configuration will now be displayed in a sorted order rather than the arbitrary order in which they were added to the list (since the underlying data structure is now a sorted tree234 rather than an ad-hoc comma-separated string); and one more specific change, which is that local and dynamic port forwardings on the same port number are now mutually exclusive in the configuration (putting 'D' in the key rather than the value was a mistake in the first place). One other reorganisation as a result of this is that I've moved all the dialog.c standard handlers (dlg_stdeditbox_handler and friends) out into config.c, because I can't really justify calling them generic any more. When they took a pointer to an arbitrary structure type and the offset of a field within that structure, they were independent of whether that structure was a Config or something completely different, but now they really do expect to talk to a Conf, which can _only_ be used for PuTTY configuration, so I've renamed them all things like conf_editbox_handler and moved them out of the nominally independent dialog-box management module into the PuTTY-specific config.c. [originally from svn r9214]
2011-07-14 18:52:21 +00:00
int exitcode, close_on_exit;
Start using notify_remote_exit() in the Windows front end, in place of the previous ad-hockery which depended on the return value from select_result() and hence which will not adapt sensibly to a world in which the primary session is something local rather than a network connection. [originally from svn r6802]
2006-08-26 10:04:46 +00:00
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
if (!wgs->session_closed &&
(exitcode = backend_exitcode(wgs->backend)) >= 0) {
close_on_exit = conf_get_int(wgs->conf, CONF_close_on_exit);
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
/* Abnormal exits will already have set session_closed and taken
* appropriate action. */
if (close_on_exit == FORCE_ON ||
(close_on_exit == AUTO && exitcode != INT_MAX)) {
PostQuitMessage(0);
} else {
WinGuiSeat refactoring: fix a missing context parameter. Of the three calls to queue_toplevel_callback in window.c, one of them was still passing NULL as its context parameter, rather than the new 'wgs'. As a result, a segfault could occur during some session closures.
2022-09-16 08:18:52 +00:00
queue_toplevel_callback(close_session, wgs);
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
wgs->session_closed = true;
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
/* exitcode == INT_MAX indicates that the connection was closed
* by a fatal error, so an error box will be coming our way and
* we should not generate this informational one. */
On Windows, show hidden mouse pointer on error. If a terminal window closed with a popup (due to a network error, for instance) while the mouse pointer was hidden by 'Hide mouse pointer when typing in window', the mouse pointer could remain hidden while over the terminal window, making it hard to navigate to the popup.
2020-04-14 19:36:46 +00:00
if (exitcode != INT_MAX) {
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
show_mouseptr(wgs, true);
MessageBox(wgs->term_hwnd, "Connection closed by remote host",
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
appname, MB_OK | MB_ICONINFORMATION);
On Windows, show hidden mouse pointer on error. If a terminal window closed with a popup (due to a network error, for instance) while the mouse pointer was hidden by 'Hide mouse pointer when typing in window', the mouse pointer could remain hidden while over the terminal window, making it hard to navigate to the popup.
2020-04-14 19:36:46 +00:00
}
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
}
Start using notify_remote_exit() in the Windows front end, in place of the previous ad-hockery which depended on the return value from select_result() and hence which will not adapt sensibly to a world in which the primary session is something local rather than a network connection. [originally from svn r6802]
2006-08-26 10:04:46 +00:00
}
}
New timing infrastructure. There's a new function schedule_timer() which pretty much any module can call to request a call-back in the future. So terminal.c can do its own handling of blinking, visual bells and deferred screen updates, without having to rely on term_update() being called 50 times a second (fixes: pterm-timer); and ssh.c and telnet.c both invoke a new module pinger.c which takes care of sending keepalives, so they get sent uniformly in all front ends (fixes: plink-keepalives, unix-keepalives). [originally from svn r4906] [this svn revision also touched putty-wishlist]
2004-11-27 13:20:21 +00:00
Move contents of win_seat_notify_remote_exit into a callback. This matches the way it's done in the GTK backend: the only thing that happens inside seat_notify_remote_exit is that we schedule a toplevel callback, and all the real work happens later on when that callback is called. The particular situation where this makes a difference is if you perform a user abort during proxy authentication (e.g. hit ^D at a proxy password prompt), so that the main SSH backend gets PLUGCLOSE_USER_ABORT and calls ssh_user_close. That doesn't immediately close the socket; it just sets ssh->pending_close, schedules a run of ssh_bpp_output_raw_data_callback, and returns. So if seat_notify_remote_exit calls back _synchronously_ to ssh_return_exitcode, it will see that the socket is still open and return -1. But if it schedules a callback and waits, then the callback to ssh_bpp_output_raw_data_callback will happen first, which will close the socket, and then the exit processing will get the right answer. So the user-visible effect is that if you ^D a proxy auth prompt, GTK PuTTY will close the whole window (assuming you didn't set close-on- exit to 'never'), whereas Windows PuTTY will leave the window open, and not even know that the connection is now shut (in that it'll still ask 'Are you sure you want to close this session?' if you try to close it by hand). With this fix, Windows PuTTY behaves the same as GTK in this respect.
2022-05-19 16:44:39 +00:00
static void win_seat_notify_remote_exit(Seat *seat)
{
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
WinGuiSeat *wgs = container_of(seat, WinGuiSeat, seat);
queue_toplevel_callback(exit_callback, wgs);
Move contents of win_seat_notify_remote_exit into a callback. This matches the way it's done in the GTK backend: the only thing that happens inside seat_notify_remote_exit is that we schedule a toplevel callback, and all the real work happens later on when that callback is called. The particular situation where this makes a difference is if you perform a user abort during proxy authentication (e.g. hit ^D at a proxy password prompt), so that the main SSH backend gets PLUGCLOSE_USER_ABORT and calls ssh_user_close. That doesn't immediately close the socket; it just sets ssh->pending_close, schedules a run of ssh_bpp_output_raw_data_callback, and returns. So if seat_notify_remote_exit calls back _synchronously_ to ssh_return_exitcode, it will see that the socket is still open and return -1. But if it schedules a callback and waits, then the callback to ssh_bpp_output_raw_data_callback will happen first, which will close the socket, and then the exit processing will get the right answer. So the user-visible effect is that if you ^D a proxy auth prompt, GTK PuTTY will close the whole window (assuming you didn't set close-on- exit to 'never'), whereas Windows PuTTY will leave the window open, and not even know that the connection is now shut (in that it'll still ask 'Are you sure you want to close this session?' if you try to close it by hand). With this fix, Windows PuTTY behaves the same as GTK in this respect.
2022-05-19 16:44:39 +00:00
}
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
static void conf_cache_data(WinGuiSeat *wgs)
Post-release destabilisation! Completely remove the struct type 'Config' in putty.h, which stores all PuTTY's settings and includes an arbitrary length limit on every single one of those settings which is stored in string form. In place of it is 'Conf', an opaque data type everywhere outside the new file conf.c, which stores a list of (key, value) pairs in which every key contains an integer identifying a configuration setting, and for some of those integers the key also contains extra parts (so that, for instance, CONF_environmt is a string-to-string mapping). Everywhere that a Config was previously used, a Conf is now; everywhere there was a Config structure copy, conf_copy() is called; every lookup, adjustment, load and save operation on a Config has been rewritten; and there's a mechanism for serialising a Conf into a binary blob and back for use with Duplicate Session. User-visible effects of this change _should_ be minimal, though I don't doubt I've introduced one or two bugs here and there which will eventually be found. The _intended_ visible effects of this change are that all arbitrary limits on configuration strings and lists (e.g. limit on number of port forwardings) should now disappear; that list boxes in the configuration will now be displayed in a sorted order rather than the arbitrary order in which they were added to the list (since the underlying data structure is now a sorted tree234 rather than an ad-hoc comma-separated string); and one more specific change, which is that local and dynamic port forwardings on the same port number are now mutually exclusive in the configuration (putting 'D' in the key rather than the value was a mistake in the first place). One other reorganisation as a result of this is that I've moved all the dialog.c standard handlers (dlg_stdeditbox_handler and friends) out into config.c, because I can't really justify calling them generic any more. When they took a pointer to an arbitrary structure type and the offset of a field within that structure, they were independent of whether that structure was a Config or something completely different, but now they really do expect to talk to a Conf, which can _only_ be used for PuTTY configuration, so I've renamed them all things like conf_editbox_handler and moved them out of the nominally independent dialog-box management module into the PuTTY-specific config.c. [originally from svn r9214]
2011-07-14 18:52:21 +00:00
{
/* Cache some items from conf to speed lookups in very hot code */
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
wgs->cursor_type = conf_get_int(wgs->conf, CONF_cursor_type);
wgs->vtmode = conf_get_int(wgs->conf, CONF_vtmode);
Post-release destabilisation! Completely remove the struct type 'Config' in putty.h, which stores all PuTTY's settings and includes an arbitrary length limit on every single one of those settings which is stored in string form. In place of it is 'Conf', an opaque data type everywhere outside the new file conf.c, which stores a list of (key, value) pairs in which every key contains an integer identifying a configuration setting, and for some of those integers the key also contains extra parts (so that, for instance, CONF_environmt is a string-to-string mapping). Everywhere that a Config was previously used, a Conf is now; everywhere there was a Config structure copy, conf_copy() is called; every lookup, adjustment, load and save operation on a Config has been rewritten; and there's a mechanism for serialising a Conf into a binary blob and back for use with Duplicate Session. User-visible effects of this change _should_ be minimal, though I don't doubt I've introduced one or two bugs here and there which will eventually be found. The _intended_ visible effects of this change are that all arbitrary limits on configuration strings and lists (e.g. limit on number of port forwardings) should now disappear; that list boxes in the configuration will now be displayed in a sorted order rather than the arbitrary order in which they were added to the list (since the underlying data structure is now a sorted tree234 rather than an ad-hoc comma-separated string); and one more specific change, which is that local and dynamic port forwardings on the same port number are now mutually exclusive in the configuration (putting 'D' in the key rather than the value was a mistake in the first place). One other reorganisation as a result of this is that I've moved all the dialog.c standard handlers (dlg_stdeditbox_handler and friends) out into config.c, because I can't really justify calling them generic any more. When they took a pointer to an arbitrary structure type and the offset of a field within that structure, they were independent of whether that structure was a Config or something completely different, but now they really do expect to talk to a Conf, which can _only_ be used for PuTTY configuration, so I've renamed them all things like conf_editbox_handler and moved them out of the nominally independent dialog-box management module into the PuTTY-specific config.c. [originally from svn r9214]
2011-07-14 18:52:21 +00:00
}
Add GUI configuration for choice of clipboards. On all platforms, you can now configure which clipboard the mouse pastes from, which clipboard Ctrl-Ins and Shift-Ins access, and which Ctrl-Shift-C and Ctrl-Shift-V access. In each case, the options are: - nothing at all - a clipboard which is implicitly written by the act of mouse selection (the PRIMARY selection on X, CLIP_LOCAL everywhere else) - the standard clipboard written by explicit copy/paste UI actions (CLIPBOARD on X, the unique system clipboard elsewhere). Also, you can control whether selecting text with the mouse _also_ writes to the explicitly accessed clipboard. The wording of the various messages changes between platforms, but the basic UI shape is the same everywhere.
2017-12-10 17:16:50 +00:00
static const int clips_system[] = { CLIP_SYSTEM };
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
static HDC make_hdc(WinGuiSeat *wgs)
Remove the 'Frontend' type and replace it with a vtable. After the recent Seat and LogContext revamps, _nearly_ all the remaining uses of the type 'Frontend' were in terminal.c, which needs all sorts of interactions with the GUI window the terminal lives in, from the obvious (actually drawing text on the window, reading and writing the clipboard) to the obscure (minimising, maximising and moving the window in response to particular escape sequences). All of those functions are now provided by an abstraction called TermWin. The few remaining uses of Frontend after _that_ are internal to a particular platform directory, so as to spread the implementation of that particular kind of Frontend between multiple source files; so I've renamed all of those so that they take a more specifically named type that refers to the particular implementation rather than the general abstraction. So now the name 'Frontend' no longer exists in the code base at all, and everywhere one used to be used, it's completely clear whether it was operating in one of Frontend's three abstract roles (and if so, which), or whether it was specific to a particular implementation. Another type that's disappeared is 'Context', which used to be a typedef defined to something different on each platform, describing whatever short-lived resources were necessary to draw on the terminal window: the front end would provide a ready-made one when calling term_paint, and the terminal could request one with get_ctx/free_ctx if it wanted to do proactive window updates. Now that drawing context lives inside the TermWin itself, because there was never any need to have two of those contexts live at the same time. (Another minor API change is that the window-title functions - both reading and writing - have had a missing 'const' added to their char * parameters / return values.) I don't expect this change to enable any particularly interesting new functionality (in particular, I have no plans that need more than one implementation of TermWin in the same application). But it completes the tidying-up that began with the Seat and LogContext rework.
2018-10-25 17:44:04 +00:00
{
HDC hdc;
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
if (!wgs->term_hwnd)
Remove the 'Frontend' type and replace it with a vtable. After the recent Seat and LogContext revamps, _nearly_ all the remaining uses of the type 'Frontend' were in terminal.c, which needs all sorts of interactions with the GUI window the terminal lives in, from the obvious (actually drawing text on the window, reading and writing the clipboard) to the obscure (minimising, maximising and moving the window in response to particular escape sequences). All of those functions are now provided by an abstraction called TermWin. The few remaining uses of Frontend after _that_ are internal to a particular platform directory, so as to spread the implementation of that particular kind of Frontend between multiple source files; so I've renamed all of those so that they take a more specifically named type that refers to the particular implementation rather than the general abstraction. So now the name 'Frontend' no longer exists in the code base at all, and everywhere one used to be used, it's completely clear whether it was operating in one of Frontend's three abstract roles (and if so, which), or whether it was specific to a particular implementation. Another type that's disappeared is 'Context', which used to be a typedef defined to something different on each platform, describing whatever short-lived resources were necessary to draw on the terminal window: the front end would provide a ready-made one when calling term_paint, and the terminal could request one with get_ctx/free_ctx if it wanted to do proactive window updates. Now that drawing context lives inside the TermWin itself, because there was never any need to have two of those contexts live at the same time. (Another minor API change is that the window-title functions - both reading and writing - have had a missing 'const' added to their char * parameters / return values.) I don't expect this change to enable any particularly interesting new functionality (in particular, I have no plans that need more than one implementation of TermWin in the same application). But it completes the tidying-up that began with the Seat and LogContext rework.
2018-10-25 17:44:04 +00:00
return NULL;
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
hdc = GetDC(wgs->term_hwnd);
Remove the 'Frontend' type and replace it with a vtable. After the recent Seat and LogContext revamps, _nearly_ all the remaining uses of the type 'Frontend' were in terminal.c, which needs all sorts of interactions with the GUI window the terminal lives in, from the obvious (actually drawing text on the window, reading and writing the clipboard) to the obscure (minimising, maximising and moving the window in response to particular escape sequences). All of those functions are now provided by an abstraction called TermWin. The few remaining uses of Frontend after _that_ are internal to a particular platform directory, so as to spread the implementation of that particular kind of Frontend between multiple source files; so I've renamed all of those so that they take a more specifically named type that refers to the particular implementation rather than the general abstraction. So now the name 'Frontend' no longer exists in the code base at all, and everywhere one used to be used, it's completely clear whether it was operating in one of Frontend's three abstract roles (and if so, which), or whether it was specific to a particular implementation. Another type that's disappeared is 'Context', which used to be a typedef defined to something different on each platform, describing whatever short-lived resources were necessary to draw on the terminal window: the front end would provide a ready-made one when calling term_paint, and the terminal could request one with get_ctx/free_ctx if it wanted to do proactive window updates. Now that drawing context lives inside the TermWin itself, because there was never any need to have two of those contexts live at the same time. (Another minor API change is that the window-title functions - both reading and writing - have had a missing 'const' added to their char * parameters / return values.) I don't expect this change to enable any particularly interesting new functionality (in particular, I have no plans that need more than one implementation of TermWin in the same application). But it completes the tidying-up that began with the Seat and LogContext rework.
2018-10-25 17:44:04 +00:00
if (!hdc)
return NULL;
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
SelectPalette(hdc, wgs->pal, false);
Remove the 'Frontend' type and replace it with a vtable. After the recent Seat and LogContext revamps, _nearly_ all the remaining uses of the type 'Frontend' were in terminal.c, which needs all sorts of interactions with the GUI window the terminal lives in, from the obvious (actually drawing text on the window, reading and writing the clipboard) to the obscure (minimising, maximising and moving the window in response to particular escape sequences). All of those functions are now provided by an abstraction called TermWin. The few remaining uses of Frontend after _that_ are internal to a particular platform directory, so as to spread the implementation of that particular kind of Frontend between multiple source files; so I've renamed all of those so that they take a more specifically named type that refers to the particular implementation rather than the general abstraction. So now the name 'Frontend' no longer exists in the code base at all, and everywhere one used to be used, it's completely clear whether it was operating in one of Frontend's three abstract roles (and if so, which), or whether it was specific to a particular implementation. Another type that's disappeared is 'Context', which used to be a typedef defined to something different on each platform, describing whatever short-lived resources were necessary to draw on the terminal window: the front end would provide a ready-made one when calling term_paint, and the terminal could request one with get_ctx/free_ctx if it wanted to do proactive window updates. Now that drawing context lives inside the TermWin itself, because there was never any need to have two of those contexts live at the same time. (Another minor API change is that the window-title functions - both reading and writing - have had a missing 'const' added to their char * parameters / return values.) I don't expect this change to enable any particularly interesting new functionality (in particular, I have no plans that need more than one implementation of TermWin in the same application). But it completes the tidying-up that began with the Seat and LogContext rework.
2018-10-25 17:44:04 +00:00
return hdc;
}
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
static void free_hdc(WinGuiSeat *wgs, HDC hdc)
Remove the 'Frontend' type and replace it with a vtable. After the recent Seat and LogContext revamps, _nearly_ all the remaining uses of the type 'Frontend' were in terminal.c, which needs all sorts of interactions with the GUI window the terminal lives in, from the obvious (actually drawing text on the window, reading and writing the clipboard) to the obscure (minimising, maximising and moving the window in response to particular escape sequences). All of those functions are now provided by an abstraction called TermWin. The few remaining uses of Frontend after _that_ are internal to a particular platform directory, so as to spread the implementation of that particular kind of Frontend between multiple source files; so I've renamed all of those so that they take a more specifically named type that refers to the particular implementation rather than the general abstraction. So now the name 'Frontend' no longer exists in the code base at all, and everywhere one used to be used, it's completely clear whether it was operating in one of Frontend's three abstract roles (and if so, which), or whether it was specific to a particular implementation. Another type that's disappeared is 'Context', which used to be a typedef defined to something different on each platform, describing whatever short-lived resources were necessary to draw on the terminal window: the front end would provide a ready-made one when calling term_paint, and the terminal could request one with get_ctx/free_ctx if it wanted to do proactive window updates. Now that drawing context lives inside the TermWin itself, because there was never any need to have two of those contexts live at the same time. (Another minor API change is that the window-title functions - both reading and writing - have had a missing 'const' added to their char * parameters / return values.) I don't expect this change to enable any particularly interesting new functionality (in particular, I have no plans that need more than one implementation of TermWin in the same application). But it completes the tidying-up that began with the Seat and LogContext rework.
2018-10-25 17:44:04 +00:00
{
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
assert(wgs->term_hwnd);
Adopt C99 <stdbool.h>'s true/false. This commit includes <stdbool.h> from defs.h and deletes my traditional definitions of TRUE and FALSE, but other than that, it's a 100% mechanical search-and-replace transforming all uses of TRUE and FALSE into the C99-standardised lowercase spellings. No actual types are changed in this commit; that will come next. This is just getting the noise out of the way, so that subsequent commits can have a higher proportion of signal.
2018-10-29 19:50:29 +00:00
SelectPalette(hdc, GetStockObject(DEFAULT_PALETTE), false);
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
ReleaseDC(wgs->term_hwnd, hdc);
Remove the 'Frontend' type and replace it with a vtable. After the recent Seat and LogContext revamps, _nearly_ all the remaining uses of the type 'Frontend' were in terminal.c, which needs all sorts of interactions with the GUI window the terminal lives in, from the obvious (actually drawing text on the window, reading and writing the clipboard) to the obscure (minimising, maximising and moving the window in response to particular escape sequences). All of those functions are now provided by an abstraction called TermWin. The few remaining uses of Frontend after _that_ are internal to a particular platform directory, so as to spread the implementation of that particular kind of Frontend between multiple source files; so I've renamed all of those so that they take a more specifically named type that refers to the particular implementation rather than the general abstraction. So now the name 'Frontend' no longer exists in the code base at all, and everywhere one used to be used, it's completely clear whether it was operating in one of Frontend's three abstract roles (and if so, which), or whether it was specific to a particular implementation. Another type that's disappeared is 'Context', which used to be a typedef defined to something different on each platform, describing whatever short-lived resources were necessary to draw on the terminal window: the front end would provide a ready-made one when calling term_paint, and the terminal could request one with get_ctx/free_ctx if it wanted to do proactive window updates. Now that drawing context lives inside the TermWin itself, because there was never any need to have two of those contexts live at the same time. (Another minor API change is that the window-title functions - both reading and writing - have had a missing 'const' added to their char * parameters / return values.) I don't expect this change to enable any particularly interesting new functionality (in particular, I have no plans that need more than one implementation of TermWin in the same application). But it completes the tidying-up that began with the Seat and LogContext rework.
2018-10-25 17:44:04 +00:00
}
Re-fix retention of window border on maximise. The fix in commit 31ab5b8e3083d66 was incomplete. It works when you maximise the window by pressing the maximise button in the title bar, but not when you drag the window to the very top of the screen. In the latter case, the resize at the instant of maximisation works right, but then we get a WM_EXITSIZEMOVE when the drag is released, triggering one final resize which ignored the window border again. That was because wm_size_resize_term() was being given a flag on purpose telling it to ignore the border: apparently at some point in the past, ignoring the border for even a normally maximised window (not even full-screen) was done on purpose. But for the reasons in the previous commit, I'm changing that.
2024-11-23 11:17:07 +00:00
static void wm_size_resize_term(WinGuiSeat *wgs, LPARAM lParam)
Windows: make the need_backend_resize mechanism consistent. There were three separate clauses in the WM_SIZE message handler which potentially called term_size() to resize the actual Terminal object. Two of them (for maximisation and normal non-maximised resizing drags) first checked if an interactive resize was in progress, and if so, instead set the need_backend_resize, to defer the term_size call to the end of the interactive operation. But the third, for _un_-maximising a window, didn't have that check. As a result, if you start with a maximised window, drag its title bar downward from the top of the screen (which unmaximises it), and without letting go, drag it back up again (which maximises it), the effect would be that you'd get one call to term_size in the middle of the drag, and a second at the end. This isn't what I intended, and it can also cause a redraw failure in full-screen applications on the server (such as a terminal-based text editor - I reproduced this with emacs), in which after the second term_size the terminal doesn't manage to redraw itself. Now I've pulled out the common logic that was in two of those three pieces of code (and should have been in all three) into a subroutine wm_size_resize_term, and arranged to call that in all three cases. This fixes the inconsistency, and also fixes the emacs redraw problem in the edge case I describe above.
2021-02-07 19:59:21 +00:00
{
int width = LOWORD(lParam);
int height = HIWORD(lParam);
Re-fix retention of window border on maximise. The fix in commit 31ab5b8e3083d66 was incomplete. It works when you maximise the window by pressing the maximise button in the title bar, but not when you drag the window to the very top of the screen. In the latter case, the resize at the instant of maximisation works right, but then we get a WM_EXITSIZEMOVE when the drag is released, triggering one final resize which ignored the window border again. That was because wm_size_resize_term() was being given a flag on purpose telling it to ignore the border: apparently at some point in the past, ignoring the border for even a normally maximised window (not even full-screen) was done on purpose. But for the reasons in the previous commit, I'm changing that.
2024-11-23 11:17:07 +00:00
int border_size = conf_get_int(wgs->conf, CONF_window_border);
Windows: make the need_backend_resize mechanism consistent. There were three separate clauses in the WM_SIZE message handler which potentially called term_size() to resize the actual Terminal object. Two of them (for maximisation and normal non-maximised resizing drags) first checked if an interactive resize was in progress, and if so, instead set the need_backend_resize, to defer the term_size call to the end of the interactive operation. But the third, for _un_-maximising a window, didn't have that check. As a result, if you start with a maximised window, drag its title bar downward from the top of the screen (which unmaximises it), and without letting go, drag it back up again (which maximises it), the effect would be that you'd get one call to term_size in the middle of the drag, and a second at the end. This isn't what I intended, and it can also cause a redraw failure in full-screen applications on the server (such as a terminal-based text editor - I reproduced this with emacs), in which after the second term_size the terminal doesn't manage to redraw itself. Now I've pulled out the common logic that was in two of those three pieces of code (and should have been in all three) into a subroutine wm_size_resize_term, and arranged to call that in all three cases. This fixes the inconsistency, and also fixes the emacs redraw problem in the edge case I describe above.
2021-02-07 19:59:21 +00:00
windows/window.c: move more variables into WinGuiSeat. In commit f9e572595bb8cb6 I claimed that I'd removed very nearly all the global and static variables from windows/window.c. It turns out that this was wildly overoptimistic - I missed quite a few of them! I'm not quite sure how I managed that; my best guess is that I used an underpowered 'nm' command that failed to find some classes of variable. Some of the remaining function-scope statics were removed completely by commit afb3dab1e97a09f just now. In this commit, I've swept up some more and turn them into fields of WinGuiSeat, where they should have been moved last September. The (hopefully complete this time) list of remaining variables, generated by running this rune in the Windows build directory: nm windows/CMakeFiles/putty.dir/window.c.obj | grep -E '^([^ ]+)? *[bBcCdDgGsS] [^\.]' consists of the following variables which are legitimately global across the whole process and not related to a particular window: - 'hinst' and 'hprev', instance handles for Windows loadable modules - 'classname' in the terminal_window_class_a() and terminal_window_class_w() functions, which allocate a window class reusably - some pointers to Windows API functions retrieved via the DECL_WINDOWS_FUNCTION / GET_WINDOWS_FUNCTION system, such as p_AdjustWindowRectExForDpi and p_FlashWindowEx - some pointers to Windows API functions set up by assigning them at startup to the right one of the ANSI or Unicode version depending on the Windows version, e.g. sw_DefWindowProc and sw_DispatchMessage - 'unicode_window', a boolean flag set at the same time as those sw_Foo function pointers - 'sesslist', storing the last-retrieved version of the saved sessions menu - 'cursor_visible' in show_mouseptr() and 'forced_visible' in update_mouse_pointer(), each of which tracks the cumulative number of times that function has shown or hidden the mouse pointer, so as to manage its effect on the global state updated by ShowCursor - 'trust_icon', loaded from the executable's resources - 'wgslisthead', the list of all active WinGuiSeats - 'wm_mousewheel', the window-message id we use for mouse wheel events and the following which are nothing to do with our code: - '_OptionsStorage' in __local_stdio_printf_options() and __local_stdio_scanf_options(), which I'd never noticed before, but apparently are internal to a standard library header.
2023-05-27 13:59:20 +00:00
int w = (width - border_size*2) / wgs->font_width;
int h = (height - border_size*2) / wgs->font_height;
Windows: make the need_backend_resize mechanism consistent. There were three separate clauses in the WM_SIZE message handler which potentially called term_size() to resize the actual Terminal object. Two of them (for maximisation and normal non-maximised resizing drags) first checked if an interactive resize was in progress, and if so, instead set the need_backend_resize, to defer the term_size call to the end of the interactive operation. But the third, for _un_-maximising a window, didn't have that check. As a result, if you start with a maximised window, drag its title bar downward from the top of the screen (which unmaximises it), and without letting go, drag it back up again (which maximises it), the effect would be that you'd get one call to term_size in the middle of the drag, and a second at the end. This isn't what I intended, and it can also cause a redraw failure in full-screen applications on the server (such as a terminal-based text editor - I reproduced this with emacs), in which after the second term_size the terminal doesn't manage to redraw itself. Now I've pulled out the common logic that was in two of those three pieces of code (and should have been in all three) into a subroutine wm_size_resize_term, and arranged to call that in all three cases. This fixes the inconsistency, and also fixes the emacs redraw problem in the edge case I describe above.
2021-02-07 19:59:21 +00:00
if (w < 1) w = 1;
if (h < 1) h = 1;
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
if (wgs->resizing) {
Windows: make the need_backend_resize mechanism consistent. There were three separate clauses in the WM_SIZE message handler which potentially called term_size() to resize the actual Terminal object. Two of them (for maximisation and normal non-maximised resizing drags) first checked if an interactive resize was in progress, and if so, instead set the need_backend_resize, to defer the term_size call to the end of the interactive operation. But the third, for _un_-maximising a window, didn't have that check. As a result, if you start with a maximised window, drag its title bar downward from the top of the screen (which unmaximises it), and without letting go, drag it back up again (which maximises it), the effect would be that you'd get one call to term_size in the middle of the drag, and a second at the end. This isn't what I intended, and it can also cause a redraw failure in full-screen applications on the server (such as a terminal-based text editor - I reproduced this with emacs), in which after the second term_size the terminal doesn't manage to redraw itself. Now I've pulled out the common logic that was in two of those three pieces of code (and should have been in all three) into a subroutine wm_size_resize_term, and arranged to call that in all three cases. This fixes the inconsistency, and also fixes the emacs redraw problem in the edge case I describe above.
2021-02-07 19:59:21 +00:00
/*
* If we're in the middle of an interactive resize, we don't
* call term_size. This means that, firstly, the user can drag
* the size back and forth indecisively without wiping out any
* actual terminal contents, and secondly, the Terminal
* doesn't call back->size in turn for each increment of the
* resizing drag, so we don't spam the server with huge
* numbers of resize events.
*/
windows/window.c: move more variables into WinGuiSeat. In commit f9e572595bb8cb6 I claimed that I'd removed very nearly all the global and static variables from windows/window.c. It turns out that this was wildly overoptimistic - I missed quite a few of them! I'm not quite sure how I managed that; my best guess is that I used an underpowered 'nm' command that failed to find some classes of variable. Some of the remaining function-scope statics were removed completely by commit afb3dab1e97a09f just now. In this commit, I've swept up some more and turn them into fields of WinGuiSeat, where they should have been moved last September. The (hopefully complete this time) list of remaining variables, generated by running this rune in the Windows build directory: nm windows/CMakeFiles/putty.dir/window.c.obj | grep -E '^([^ ]+)? *[bBcCdDgGsS] [^\.]' consists of the following variables which are legitimately global across the whole process and not related to a particular window: - 'hinst' and 'hprev', instance handles for Windows loadable modules - 'classname' in the terminal_window_class_a() and terminal_window_class_w() functions, which allocate a window class reusably - some pointers to Windows API functions retrieved via the DECL_WINDOWS_FUNCTION / GET_WINDOWS_FUNCTION system, such as p_AdjustWindowRectExForDpi and p_FlashWindowEx - some pointers to Windows API functions set up by assigning them at startup to the right one of the ANSI or Unicode version depending on the Windows version, e.g. sw_DefWindowProc and sw_DispatchMessage - 'unicode_window', a boolean flag set at the same time as those sw_Foo function pointers - 'sesslist', storing the last-retrieved version of the saved sessions menu - 'cursor_visible' in show_mouseptr() and 'forced_visible' in update_mouse_pointer(), each of which tracks the cumulative number of times that function has shown or hidden the mouse pointer, so as to manage its effect on the global state updated by ShowCursor - 'trust_icon', loaded from the executable's resources - 'wgslisthead', the list of all active WinGuiSeats - 'wm_mousewheel', the window-message id we use for mouse wheel events and the following which are nothing to do with our code: - '_OptionsStorage' in __local_stdio_printf_options() and __local_stdio_scanf_options(), which I'd never noticed before, but apparently are internal to a standard library header.
2023-05-27 13:59:20 +00:00
wgs->need_backend_resize = true;
Windows: make the need_backend_resize mechanism consistent. There were three separate clauses in the WM_SIZE message handler which potentially called term_size() to resize the actual Terminal object. Two of them (for maximisation and normal non-maximised resizing drags) first checked if an interactive resize was in progress, and if so, instead set the need_backend_resize, to defer the term_size call to the end of the interactive operation. But the third, for _un_-maximising a window, didn't have that check. As a result, if you start with a maximised window, drag its title bar downward from the top of the screen (which unmaximises it), and without letting go, drag it back up again (which maximises it), the effect would be that you'd get one call to term_size in the middle of the drag, and a second at the end. This isn't what I intended, and it can also cause a redraw failure in full-screen applications on the server (such as a terminal-based text editor - I reproduced this with emacs), in which after the second term_size the terminal doesn't manage to redraw itself. Now I've pulled out the common logic that was in two of those three pieces of code (and should have been in all three) into a subroutine wm_size_resize_term, and arranged to call that in all three cases. This fixes the inconsistency, and also fixes the emacs redraw problem in the edge case I describe above.
2021-02-07 19:59:21 +00:00
} else {
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
term_size(wgs->term, h, w,
conf_get_int(wgs->conf, CONF_savelines));
Windows: make the need_backend_resize mechanism consistent. There were three separate clauses in the WM_SIZE message handler which potentially called term_size() to resize the actual Terminal object. Two of them (for maximisation and normal non-maximised resizing drags) first checked if an interactive resize was in progress, and if so, instead set the need_backend_resize, to defer the term_size call to the end of the interactive operation. But the third, for _un_-maximising a window, didn't have that check. As a result, if you start with a maximised window, drag its title bar downward from the top of the screen (which unmaximises it), and without letting go, drag it back up again (which maximises it), the effect would be that you'd get one call to term_size in the middle of the drag, and a second at the end. This isn't what I intended, and it can also cause a redraw failure in full-screen applications on the server (such as a terminal-based text editor - I reproduced this with emacs), in which after the second term_size the terminal doesn't manage to redraw itself. Now I've pulled out the common logic that was in two of those three pieces of code (and should have been in all three) into a subroutine wm_size_resize_term, and arranged to call that in all three cases. This fixes the inconsistency, and also fixes the emacs redraw problem in the edge case I describe above.
2021-02-07 19:59:21 +00:00
}
wm_size_resize_term: update conf unconditionally. A user reported that when a PuTTY window is resized by the 'FancyZones' tool included in Microsoft PowerToys, the terminal itself knows the new size ('stty' showed that it had sent a correct SIGWINCH to the SSH server), but the next invocation of the Change Settings dialog box still has the old size entered in it, leading to confusing behaviour when you press Apply. Inside PuTTY, this must mean that we updated the actual terminal's size, but didn't update the main Conf object to match it, which is where Change Settings populates its initial dialog state from. It looks as if this is because FancyZones resizes the window by sending it one single WM_SIZE, without wrapping it in the WM_ENTERSIZEMOVE and WM_EXITSIZEMOVE messages that signal the start and end of an interactive dragging resize operation. And the update of Conf in wm_size_resize_term was in only one branch of the if statement that checks whether we're in an interactive resize. Now it's outside the if, so Conf will be updated in both cases.
2024-12-15 14:48:01 +00:00
conf_set_int(wgs->conf, CONF_height, h);
conf_set_int(wgs->conf, CONF_width, w);
Windows: make the need_backend_resize mechanism consistent. There were three separate clauses in the WM_SIZE message handler which potentially called term_size() to resize the actual Terminal object. Two of them (for maximisation and normal non-maximised resizing drags) first checked if an interactive resize was in progress, and if so, instead set the need_backend_resize, to defer the term_size call to the end of the interactive operation. But the third, for _un_-maximising a window, didn't have that check. As a result, if you start with a maximised window, drag its title bar downward from the top of the screen (which unmaximises it), and without letting go, drag it back up again (which maximises it), the effect would be that you'd get one call to term_size in the middle of the drag, and a second at the end. This isn't what I intended, and it can also cause a redraw failure in full-screen applications on the server (such as a terminal-based text editor - I reproduced this with emacs), in which after the second term_size the terminal doesn't manage to redraw itself. Now I've pulled out the common logic that was in two of those three pieces of code (and should have been in all three) into a subroutine wm_size_resize_term, and arranged to call that in all three cases. This fixes the inconsistency, and also fixes the emacs redraw problem in the edge case I describe above.
2021-02-07 19:59:21 +00:00
}
Run entire source base through GNU indent to tidy up the varying coding styles of the various contributors! Woohoo! [originally from svn r1098]
2001-05-06 14:35:20 +00:00
static LRESULT CALLBACK WndProc(HWND hwnd, UINT message,
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
WPARAM wParam, LPARAM lParam)
Run entire source base through GNU indent to tidy up the varying coding styles of the various contributors! Woohoo! [originally from svn r1098]
2001-05-06 14:35:20 +00:00
{
Initial checkin: beta 0.43 [originally from svn r11]
1999-01-08 13:02:13 +00:00
HDC hdc;
Post-release destabilisation! Completely remove the struct type 'Config' in putty.h, which stores all PuTTY's settings and includes an arbitrary length limit on every single one of those settings which is stored in string form. In place of it is 'Conf', an opaque data type everywhere outside the new file conf.c, which stores a list of (key, value) pairs in which every key contains an integer identifying a configuration setting, and for some of those integers the key also contains extra parts (so that, for instance, CONF_environmt is a string-to-string mapping). Everywhere that a Config was previously used, a Conf is now; everywhere there was a Config structure copy, conf_copy() is called; every lookup, adjustment, load and save operation on a Config has been rewritten; and there's a mechanism for serialising a Conf into a binary blob and back for use with Duplicate Session. User-visible effects of this change _should_ be minimal, though I don't doubt I've introduced one or two bugs here and there which will eventually be found. The _intended_ visible effects of this change are that all arbitrary limits on configuration strings and lists (e.g. limit on number of port forwardings) should now disappear; that list boxes in the configuration will now be displayed in a sorted order rather than the arbitrary order in which they were added to the list (since the underlying data structure is now a sorted tree234 rather than an ad-hoc comma-separated string); and one more specific change, which is that local and dynamic port forwardings on the same port number are now mutually exclusive in the configuration (putting 'D' in the key rather than the value was a mistake in the first place). One other reorganisation as a result of this is that I've moved all the dialog.c standard handlers (dlg_stdeditbox_handler and friends) out into config.c, because I can't really justify calling them generic any more. When they took a pointer to an arbitrary structure type and the offset of a field within that structure, they were independent of whether that structure was a Config or something completely different, but now they really do expect to talk to a Conf, which can _only_ be used for PuTTY configuration, so I've renamed them all things like conf_editbox_handler and moved them out of the nominally independent dialog-box management module into the PuTTY-specific config.c. [originally from svn r9214]
2011-07-14 18:52:21 +00:00
int resize_action;
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
WinGuiSeat *wgs = (WinGuiSeat *)GetWindowLongPtr(hwnd, GWLP_USERDATA);
Initial checkin: beta 0.43 [originally from svn r11]
1999-01-08 13:02:13 +00:00
switch (message) {
case WM_CREATE:
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
break;
Formatting change to braces around one case of a switch. Sometimes, within a switch statement, you want to declare local variables specific to the handler for one particular case. Until now I've mostly been writing this in the form switch (discriminant) { case SIMPLE: do stuff; break; case COMPLICATED: { declare variables; do stuff; } break; } which is ugly because the two pieces of essentially similar code appear at different indent levels, and also inconvenient because you have less horizontal space available to write the complicated case handler in - particuarly undesirable because _complicated_ case handlers are the ones most likely to need all the space they can get! After encountering a rather nicer idiom in the LLVM source code, and after a bit of hackery this morning figuring out how to persuade Emacs's auto-indent to do what I wanted with it, I've decided to move to an idiom in which the open brace comes right after the case statement, and the code within it is indented the same as it would have been without the brace. Then the whole case handler (including the break) lives inside those braces, and you get something that looks more like this: switch (discriminant) { case SIMPLE: do stuff; break; case COMPLICATED: { declare variables; do stuff; break; } } This commit is a big-bang change that reformats all the complicated case handlers I could find into the new layout. This is particularly nice in the Pageant main function, in which almost _every_ case handler had a bundle of variables and was long and complicated. (In fact that's what motivated me to get round to this.) Some of the innermost parts of the terminal escape-sequence handling are also breathing a bit easier now the horizontal pressure on them is relieved. (Also, in a few cases, I was able to remove the extra braces completely, because the only variable local to the case handler was a loop variable which our new C99 policy allows me to move into the initialiser clause of its for statement.) Viewed with whitespace ignored, this is not too disruptive a change. Downstream patches that conflict with it may need to be reapplied using --ignore-whitespace or similar.
2020-02-16 07:49:52 +00:00
case WM_CLOSE: {
Mention any extant downstreams in close warning. Suggested by Brian Rak.
2021-02-21 14:17:03 +00:00
char *title, *msg, *additional = NULL;
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
show_mouseptr(wgs, true);
Mention any extant downstreams in close warning. Suggested by Brian Rak.
2021-02-21 14:17:03 +00:00
title = dupprintf("%s Exit Confirmation", appname);
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
if (wgs->backend && wgs->backend->vt->close_warn_text) {
additional = wgs->backend->vt->close_warn_text(wgs->backend);
Mention any extant downstreams in close warning. Suggested by Brian Rak.
2021-02-21 14:17:03 +00:00
}
msg = dupprintf("Are you sure you want to close this session?%s%s",
additional ? "\n" : "",
additional ? additional : "");
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
if (wgs->session_closed ||
!conf_get_bool(wgs->conf, CONF_warn_on_close) ||
Mention any extant downstreams in close warning. Suggested by Brian Rak.
2021-02-21 14:17:03 +00:00
MessageBox(hwnd, msg, title,
MB_ICONWARNING | MB_OKCANCEL | MB_DEFBUTTON1)
Formatting change to braces around one case of a switch. Sometimes, within a switch statement, you want to declare local variables specific to the handler for one particular case. Until now I've mostly been writing this in the form switch (discriminant) { case SIMPLE: do stuff; break; case COMPLICATED: { declare variables; do stuff; } break; } which is ugly because the two pieces of essentially similar code appear at different indent levels, and also inconvenient because you have less horizontal space available to write the complicated case handler in - particuarly undesirable because _complicated_ case handlers are the ones most likely to need all the space they can get! After encountering a rather nicer idiom in the LLVM source code, and after a bit of hackery this morning figuring out how to persuade Emacs's auto-indent to do what I wanted with it, I've decided to move to an idiom in which the open brace comes right after the case statement, and the code within it is indented the same as it would have been without the brace. Then the whole case handler (including the break) lives inside those braces, and you get something that looks more like this: switch (discriminant) { case SIMPLE: do stuff; break; case COMPLICATED: { declare variables; do stuff; break; } } This commit is a big-bang change that reformats all the complicated case handlers I could find into the new layout. This is particularly nice in the Pageant main function, in which almost _every_ case handler had a bundle of variables and was long and complicated. (In fact that's what motivated me to get round to this.) Some of the innermost parts of the terminal escape-sequence handling are also breathing a bit easier now the horizontal pressure on them is relieved. (Also, in a few cases, I was able to remove the extra braces completely, because the only variable local to the case handler was a loop variable which our new C99 policy allows me to move into the initialiser clause of its for statement.) Viewed with whitespace ignored, this is not too disruptive a change. Downstream patches that conflict with it may need to be reapplied using --ignore-whitespace or similar.
2020-02-16 07:49:52 +00:00
== IDOK)
DestroyWindow(hwnd);
Mention any extant downstreams in close warning. Suggested by Brian Rak.
2021-02-21 14:17:03 +00:00
sfree(title);
sfree(msg);
sfree(additional);
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
return 0;
Formatting change to braces around one case of a switch. Sometimes, within a switch statement, you want to declare local variables specific to the handler for one particular case. Until now I've mostly been writing this in the form switch (discriminant) { case SIMPLE: do stuff; break; case COMPLICATED: { declare variables; do stuff; } break; } which is ugly because the two pieces of essentially similar code appear at different indent levels, and also inconvenient because you have less horizontal space available to write the complicated case handler in - particuarly undesirable because _complicated_ case handlers are the ones most likely to need all the space they can get! After encountering a rather nicer idiom in the LLVM source code, and after a bit of hackery this morning figuring out how to persuade Emacs's auto-indent to do what I wanted with it, I've decided to move to an idiom in which the open brace comes right after the case statement, and the code within it is indented the same as it would have been without the brace. Then the whole case handler (including the break) lives inside those braces, and you get something that looks more like this: switch (discriminant) { case SIMPLE: do stuff; break; case COMPLICATED: { declare variables; do stuff; break; } } This commit is a big-bang change that reformats all the complicated case handlers I could find into the new layout. This is particularly nice in the Pageant main function, in which almost _every_ case handler had a bundle of variables and was long and complicated. (In fact that's what motivated me to get round to this.) Some of the innermost parts of the terminal escape-sequence handling are also breathing a bit easier now the horizontal pressure on them is relieved. (Also, in a few cases, I was able to remove the extra braces completely, because the only variable local to the case handler was a loop variable which our new C99 policy allows me to move into the initialiser clause of its for statement.) Viewed with whitespace ignored, this is not too disruptive a change. Downstream patches that conflict with it may need to be reapplied using --ignore-whitespace or similar.
2020-02-16 07:49:52 +00:00
}
Initial checkin: beta 0.43 [originally from svn r11]
1999-01-08 13:02:13 +00:00
case WM_DESTROY:
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
show_mouseptr(wgs, true);
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
PostQuitMessage(0);
return 0;
If a new session was saved from Change Settings, a side-effect on Windows was that the global `sesslist' got out of sync with the saved-sessions submenu, causing the latter to launch the wrong sessions. Also, Change Settings wasn't getting a fresh session list, so if the set of sessions had changed since session startup it wouldn't reflect that (at least until a session was saved). Fixed (on all platforms). Therefore, since the global sesslist didn't seem to be useful, I've got rid of it; config.c creates one as needed, as do the frontends. (Not tried compiling Mac changes.) Also, we now build the saved-sessions submenu on demand on Windows and Unix. (This should probably also be done on the Mac.) [originally from svn r5609]
2005-04-07 01:36:28 +00:00
case WM_INITMENUPOPUP:
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
if ((HMENU)wParam == wgs->savedsess_menu) {
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
/* About to pop up Saved Sessions sub-menu.
* Refresh the session list. */
get_sesslist(&sesslist, false); /* free */
get_sesslist(&sesslist, true);
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
update_savedsess_menu(wgs);
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
return 0;
}
break;
Introduce a context menu which appears on Ctrl+rightclick. This menu contains all the stuff in the System menu except for the standard System menu bits (move, resize, close etc), and also contains `Paste'. [originally from svn r3555]
2003-11-19 20:48:30 +00:00
case WM_COMMAND:
Stop putting meaning in bottom four bits of WM_SYSCOMMAND wParam [originally from svn r265]
1999-10-28 16:29:06 +00:00
case WM_SYSCOMMAND:
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
switch (wParam & ~0xF) { /* low 4 bits reserved to Windows */
Windows: reinstate redraws during interactive scrollbar drag. I just discovered that they weren't happening, and the reason why is thoroughly annoying. Details are in the long comment I've added to the WM_VSCROLL handler in WndProc, but the short version is that when you interactively drag the terminal window's scrollbar, a subsidiary message loop is launched by DefWndProc, causing all our timer events to go missing until the user lets go of the scrollbar again. So we have to manually update the terminal window on scroll events, because the normal system is out of action. I assume this changed behaviour round about the big rework of terminal updating in February. Good job I spotted it just _before_ 0.75, and not just after!
2021-04-24 18:43:43 +00:00
case SC_VSCROLL:
case SC_HSCROLL:
if (message == WM_SYSCOMMAND) {
/* As per the long comment in WM_VSCROLL handler: give
* this message the default handling, which starts a
* subsidiary message loop, but set a flag so that
* when we're re-entered from that loop, scroll events
* within an interactive scrollbar-drag can be handled
* differently. */
windows/window.c: move more variables into WinGuiSeat. In commit f9e572595bb8cb6 I claimed that I'd removed very nearly all the global and static variables from windows/window.c. It turns out that this was wildly overoptimistic - I missed quite a few of them! I'm not quite sure how I managed that; my best guess is that I used an underpowered 'nm' command that failed to find some classes of variable. Some of the remaining function-scope statics were removed completely by commit afb3dab1e97a09f just now. In this commit, I've swept up some more and turn them into fields of WinGuiSeat, where they should have been moved last September. The (hopefully complete this time) list of remaining variables, generated by running this rune in the Windows build directory: nm windows/CMakeFiles/putty.dir/window.c.obj | grep -E '^([^ ]+)? *[bBcCdDgGsS] [^\.]' consists of the following variables which are legitimately global across the whole process and not related to a particular window: - 'hinst' and 'hprev', instance handles for Windows loadable modules - 'classname' in the terminal_window_class_a() and terminal_window_class_w() functions, which allocate a window class reusably - some pointers to Windows API functions retrieved via the DECL_WINDOWS_FUNCTION / GET_WINDOWS_FUNCTION system, such as p_AdjustWindowRectExForDpi and p_FlashWindowEx - some pointers to Windows API functions set up by assigning them at startup to the right one of the ANSI or Unicode version depending on the Windows version, e.g. sw_DefWindowProc and sw_DispatchMessage - 'unicode_window', a boolean flag set at the same time as those sw_Foo function pointers - 'sesslist', storing the last-retrieved version of the saved sessions menu - 'cursor_visible' in show_mouseptr() and 'forced_visible' in update_mouse_pointer(), each of which tracks the cumulative number of times that function has shown or hidden the mouse pointer, so as to manage its effect on the global state updated by ShowCursor - 'trust_icon', loaded from the executable's resources - 'wgslisthead', the list of all active WinGuiSeats - 'wm_mousewheel', the window-message id we use for mouse wheel events and the following which are nothing to do with our code: - '_OptionsStorage' in __local_stdio_printf_options() and __local_stdio_scanf_options(), which I'd never noticed before, but apparently are internal to a standard library header.
2023-05-27 13:59:20 +00:00
wgs->in_scrollbar_loop = true;
Windows: runtime switch between Unicode and ANSI windows. Turns out that PuTTY hasn't run successfully on legacy Windows since 0.66, in spite of an ongoing intention to keep it working. Among the reasons for this is that CreateWindowExW simply fails with ERROR_CALL_NOT_IMPLEMENTED: apparently Win95 and its ilk just didn't have fully-Unicode windows as an option. Fixed by resurrecting the previous code from the git history (in particular, code removed by commit 67e5ceb9a8e6bc2 was useful), and including it as a runtime alternative. One subtlety was that I found I had to name the A and W window classes differently (by appending ".ansi" to the A one): apparently they occupy the same namespace even though the names are in different character sets, so if you somehow manage to register both classes, they'll collide with each other without that tweak.
2022-03-12 06:43:59 +00:00
LRESULT result = sw_DefWindowProc(
hwnd, message, wParam, lParam);
windows/window.c: move more variables into WinGuiSeat. In commit f9e572595bb8cb6 I claimed that I'd removed very nearly all the global and static variables from windows/window.c. It turns out that this was wildly overoptimistic - I missed quite a few of them! I'm not quite sure how I managed that; my best guess is that I used an underpowered 'nm' command that failed to find some classes of variable. Some of the remaining function-scope statics were removed completely by commit afb3dab1e97a09f just now. In this commit, I've swept up some more and turn them into fields of WinGuiSeat, where they should have been moved last September. The (hopefully complete this time) list of remaining variables, generated by running this rune in the Windows build directory: nm windows/CMakeFiles/putty.dir/window.c.obj | grep -E '^([^ ]+)? *[bBcCdDgGsS] [^\.]' consists of the following variables which are legitimately global across the whole process and not related to a particular window: - 'hinst' and 'hprev', instance handles for Windows loadable modules - 'classname' in the terminal_window_class_a() and terminal_window_class_w() functions, which allocate a window class reusably - some pointers to Windows API functions retrieved via the DECL_WINDOWS_FUNCTION / GET_WINDOWS_FUNCTION system, such as p_AdjustWindowRectExForDpi and p_FlashWindowEx - some pointers to Windows API functions set up by assigning them at startup to the right one of the ANSI or Unicode version depending on the Windows version, e.g. sw_DefWindowProc and sw_DispatchMessage - 'unicode_window', a boolean flag set at the same time as those sw_Foo function pointers - 'sesslist', storing the last-retrieved version of the saved sessions menu - 'cursor_visible' in show_mouseptr() and 'forced_visible' in update_mouse_pointer(), each of which tracks the cumulative number of times that function has shown or hidden the mouse pointer, so as to manage its effect on the global state updated by ShowCursor - 'trust_icon', loaded from the executable's resources - 'wgslisthead', the list of all active WinGuiSeats - 'wm_mousewheel', the window-message id we use for mouse wheel events and the following which are nothing to do with our code: - '_OptionsStorage' in __local_stdio_printf_options() and __local_stdio_scanf_options(), which I'd never noticed before, but apparently are internal to a standard library header.
2023-05-27 13:59:20 +00:00
wgs->in_scrollbar_loop = false;
Windows: reinstate redraws during interactive scrollbar drag. I just discovered that they weren't happening, and the reason why is thoroughly annoying. Details are in the long comment I've added to the WM_VSCROLL handler in WndProc, but the short version is that when you interactively drag the terminal window's scrollbar, a subsidiary message loop is launched by DefWndProc, causing all our timer events to go missing until the user lets go of the scrollbar again. So we have to manually update the terminal window on scroll events, because the normal system is out of action. I assume this changed behaviour round about the big rework of terminal updating in February. Good job I spotted it just _before_ 0.75, and not just after!
2021-04-24 18:43:43 +00:00
return result;
}
break;
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
case IDM_SHOWLOG:
showeventlog(hwnd);
break;
case IDM_NEWSESS:
case IDM_DUPSESS:
Formatting change to braces around one case of a switch. Sometimes, within a switch statement, you want to declare local variables specific to the handler for one particular case. Until now I've mostly been writing this in the form switch (discriminant) { case SIMPLE: do stuff; break; case COMPLICATED: { declare variables; do stuff; } break; } which is ugly because the two pieces of essentially similar code appear at different indent levels, and also inconvenient because you have less horizontal space available to write the complicated case handler in - particuarly undesirable because _complicated_ case handlers are the ones most likely to need all the space they can get! After encountering a rather nicer idiom in the LLVM source code, and after a bit of hackery this morning figuring out how to persuade Emacs's auto-indent to do what I wanted with it, I've decided to move to an idiom in which the open brace comes right after the case statement, and the code within it is indented the same as it would have been without the brace. Then the whole case handler (including the break) lives inside those braces, and you get something that looks more like this: switch (discriminant) { case SIMPLE: do stuff; break; case COMPLICATED: { declare variables; do stuff; break; } } This commit is a big-bang change that reformats all the complicated case handlers I could find into the new layout. This is particularly nice in the Pageant main function, in which almost _every_ case handler had a bundle of variables and was long and complicated. (In fact that's what motivated me to get round to this.) Some of the innermost parts of the terminal escape-sequence handling are also breathing a bit easier now the horizontal pressure on them is relieved. (Also, in a few cases, I was able to remove the extra braces completely, because the only variable local to the case handler was a loop variable which our new C99 policy allows me to move into the initialiser clause of its for statement.) Viewed with whitespace ignored, this is not too disruptive a change. Downstream patches that conflict with it may need to be reapplied using --ignore-whitespace or similar.
2020-02-16 07:49:52 +00:00
case IDM_SAVEDSESS: {
char b[2048];
char *cl;
const char *argprefix;
bool inherit_handles;
STARTUPINFO si;
PROCESS_INFORMATION pi;
HANDLE filemap = NULL;
if (restricted_acl())
argprefix = "&R";
else
argprefix = "";
if (wParam == IDM_DUPSESS) {
Formatting: normalise back to 4-space indentation. In several pieces of development recently I've run across the occasional code block in the middle of a function which suddenly switched to 2-space indent from this code base's usual 4. I decided I was tired of it, so I ran the whole code base through a re-indenter, which made a huge mess, and then manually sifted out the changes that actually made sense from that pass. Indeed, this caught quite a few large sections with 2-space indent level, a couple with 8, and a handful of even weirder things like 3 spaces or 12. This commit fixes them all.
2022-08-03 19:48:46 +00:00
/*
* Allocate a file-mapping memory chunk for the
* config structure.
*/
SECURITY_ATTRIBUTES sa;
strbuf *serbuf;
void *p;
int size;
serbuf = strbuf_new();
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
conf_serialise(BinarySink_UPCAST(serbuf), wgs->conf);
Formatting: normalise back to 4-space indentation. In several pieces of development recently I've run across the occasional code block in the middle of a function which suddenly switched to 2-space indent from this code base's usual 4. I decided I was tired of it, so I ran the whole code base through a re-indenter, which made a huge mess, and then manually sifted out the changes that actually made sense from that pass. Indeed, this caught quite a few large sections with 2-space indent level, a couple with 8, and a handful of even weirder things like 3 spaces or 12. This commit fixes them all.
2022-08-03 19:48:46 +00:00
size = serbuf->len;
sa.nLength = sizeof(sa);
sa.lpSecurityDescriptor = NULL;
sa.bInheritHandle = true;
filemap = CreateFileMapping(INVALID_HANDLE_VALUE,
&sa,
PAGE_READWRITE,
0, size, NULL);
if (filemap && filemap != INVALID_HANDLE_VALUE) {
p = MapViewOfFile(filemap, FILE_MAP_WRITE, 0, 0, size);
if (p) {
memcpy(p, serbuf->s, size);
UnmapViewOfFile(p);
}
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
}
Formatting change to braces around one case of a switch. Sometimes, within a switch statement, you want to declare local variables specific to the handler for one particular case. Until now I've mostly been writing this in the form switch (discriminant) { case SIMPLE: do stuff; break; case COMPLICATED: { declare variables; do stuff; } break; } which is ugly because the two pieces of essentially similar code appear at different indent levels, and also inconvenient because you have less horizontal space available to write the complicated case handler in - particuarly undesirable because _complicated_ case handlers are the ones most likely to need all the space they can get! After encountering a rather nicer idiom in the LLVM source code, and after a bit of hackery this morning figuring out how to persuade Emacs's auto-indent to do what I wanted with it, I've decided to move to an idiom in which the open brace comes right after the case statement, and the code within it is indented the same as it would have been without the brace. Then the whole case handler (including the break) lives inside those braces, and you get something that looks more like this: switch (discriminant) { case SIMPLE: do stuff; break; case COMPLICATED: { declare variables; do stuff; break; } } This commit is a big-bang change that reformats all the complicated case handlers I could find into the new layout. This is particularly nice in the Pageant main function, in which almost _every_ case handler had a bundle of variables and was long and complicated. (In fact that's what motivated me to get round to this.) Some of the innermost parts of the terminal escape-sequence handling are also breathing a bit easier now the horizontal pressure on them is relieved. (Also, in a few cases, I was able to remove the extra braces completely, because the only variable local to the case handler was a loop variable which our new C99 policy allows me to move into the initialiser clause of its for statement.) Viewed with whitespace ignored, this is not too disruptive a change. Downstream patches that conflict with it may need to be reapplied using --ignore-whitespace or similar.
2020-02-16 07:49:52 +00:00
Formatting: normalise back to 4-space indentation. In several pieces of development recently I've run across the occasional code block in the middle of a function which suddenly switched to 2-space indent from this code base's usual 4. I decided I was tired of it, so I ran the whole code base through a re-indenter, which made a huge mess, and then manually sifted out the changes that actually made sense from that pass. Indeed, this caught quite a few large sections with 2-space indent level, a couple with 8, and a handful of even weirder things like 3 spaces or 12. This commit fixes them all.
2022-08-03 19:48:46 +00:00
strbuf_free(serbuf);
inherit_handles = true;
cl = dupprintf("putty %s&%p:%u", argprefix,
filemap, (unsigned)size);
Formatting change to braces around one case of a switch. Sometimes, within a switch statement, you want to declare local variables specific to the handler for one particular case. Until now I've mostly been writing this in the form switch (discriminant) { case SIMPLE: do stuff; break; case COMPLICATED: { declare variables; do stuff; } break; } which is ugly because the two pieces of essentially similar code appear at different indent levels, and also inconvenient because you have less horizontal space available to write the complicated case handler in - particuarly undesirable because _complicated_ case handlers are the ones most likely to need all the space they can get! After encountering a rather nicer idiom in the LLVM source code, and after a bit of hackery this morning figuring out how to persuade Emacs's auto-indent to do what I wanted with it, I've decided to move to an idiom in which the open brace comes right after the case statement, and the code within it is indented the same as it would have been without the brace. Then the whole case handler (including the break) lives inside those braces, and you get something that looks more like this: switch (discriminant) { case SIMPLE: do stuff; break; case COMPLICATED: { declare variables; do stuff; break; } } This commit is a big-bang change that reformats all the complicated case handlers I could find into the new layout. This is particularly nice in the Pageant main function, in which almost _every_ case handler had a bundle of variables and was long and complicated. (In fact that's what motivated me to get round to this.) Some of the innermost parts of the terminal escape-sequence handling are also breathing a bit easier now the horizontal pressure on them is relieved. (Also, in a few cases, I was able to remove the extra braces completely, because the only variable local to the case handler was a loop variable which our new C99 policy allows me to move into the initialiser clause of its for statement.) Viewed with whitespace ignored, this is not too disruptive a change. Downstream patches that conflict with it may need to be reapplied using --ignore-whitespace or similar.
2020-02-16 07:49:52 +00:00
} else if (wParam == IDM_SAVEDSESS) {
Formatting: normalise back to 4-space indentation. In several pieces of development recently I've run across the occasional code block in the middle of a function which suddenly switched to 2-space indent from this code base's usual 4. I decided I was tired of it, so I ran the whole code base through a re-indenter, which made a huge mess, and then manually sifted out the changes that actually made sense from that pass. Indeed, this caught quite a few large sections with 2-space indent level, a couple with 8, and a handful of even weirder things like 3 spaces or 12. This commit fixes them all.
2022-08-03 19:48:46 +00:00
unsigned int sessno = ((lParam - IDM_SAVED_MIN)
/ MENU_SAVED_STEP) + 1;
if (sessno < (unsigned)sesslist.nsessions) {
const char *session = sesslist.sessions[sessno];
cl = dupprintf("putty %s@%s", argprefix, session);
inherit_handles = false;
} else
break;
Formatting change to braces around one case of a switch. Sometimes, within a switch statement, you want to declare local variables specific to the handler for one particular case. Until now I've mostly been writing this in the form switch (discriminant) { case SIMPLE: do stuff; break; case COMPLICATED: { declare variables; do stuff; } break; } which is ugly because the two pieces of essentially similar code appear at different indent levels, and also inconvenient because you have less horizontal space available to write the complicated case handler in - particuarly undesirable because _complicated_ case handlers are the ones most likely to need all the space they can get! After encountering a rather nicer idiom in the LLVM source code, and after a bit of hackery this morning figuring out how to persuade Emacs's auto-indent to do what I wanted with it, I've decided to move to an idiom in which the open brace comes right after the case statement, and the code within it is indented the same as it would have been without the brace. Then the whole case handler (including the break) lives inside those braces, and you get something that looks more like this: switch (discriminant) { case SIMPLE: do stuff; break; case COMPLICATED: { declare variables; do stuff; break; } } This commit is a big-bang change that reformats all the complicated case handlers I could find into the new layout. This is particularly nice in the Pageant main function, in which almost _every_ case handler had a bundle of variables and was long and complicated. (In fact that's what motivated me to get round to this.) Some of the innermost parts of the terminal escape-sequence handling are also breathing a bit easier now the horizontal pressure on them is relieved. (Also, in a few cases, I was able to remove the extra braces completely, because the only variable local to the case handler was a loop variable which our new C99 policy allows me to move into the initialiser clause of its for statement.) Viewed with whitespace ignored, this is not too disruptive a change. Downstream patches that conflict with it may need to be reapplied using --ignore-whitespace or similar.
2020-02-16 07:49:52 +00:00
} else /* IDM_NEWSESS */ {
Formatting: normalise back to 4-space indentation. In several pieces of development recently I've run across the occasional code block in the middle of a function which suddenly switched to 2-space indent from this code base's usual 4. I decided I was tired of it, so I ran the whole code base through a re-indenter, which made a huge mess, and then manually sifted out the changes that actually made sense from that pass. Indeed, this caught quite a few large sections with 2-space indent level, a couple with 8, and a handful of even weirder things like 3 spaces or 12. This commit fixes them all.
2022-08-03 19:48:46 +00:00
cl = dupprintf("putty%s%s",
*argprefix ? " " : "",
argprefix);
inherit_handles = false;
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
}
Formatting change to braces around one case of a switch. Sometimes, within a switch statement, you want to declare local variables specific to the handler for one particular case. Until now I've mostly been writing this in the form switch (discriminant) { case SIMPLE: do stuff; break; case COMPLICATED: { declare variables; do stuff; } break; } which is ugly because the two pieces of essentially similar code appear at different indent levels, and also inconvenient because you have less horizontal space available to write the complicated case handler in - particuarly undesirable because _complicated_ case handlers are the ones most likely to need all the space they can get! After encountering a rather nicer idiom in the LLVM source code, and after a bit of hackery this morning figuring out how to persuade Emacs's auto-indent to do what I wanted with it, I've decided to move to an idiom in which the open brace comes right after the case statement, and the code within it is indented the same as it would have been without the brace. Then the whole case handler (including the break) lives inside those braces, and you get something that looks more like this: switch (discriminant) { case SIMPLE: do stuff; break; case COMPLICATED: { declare variables; do stuff; break; } } This commit is a big-bang change that reformats all the complicated case handlers I could find into the new layout. This is particularly nice in the Pageant main function, in which almost _every_ case handler had a bundle of variables and was long and complicated. (In fact that's what motivated me to get round to this.) Some of the innermost parts of the terminal escape-sequence handling are also breathing a bit easier now the horizontal pressure on them is relieved. (Also, in a few cases, I was able to remove the extra braces completely, because the only variable local to the case handler was a loop variable which our new C99 policy allows me to move into the initialiser clause of its for statement.) Viewed with whitespace ignored, this is not too disruptive a change. Downstream patches that conflict with it may need to be reapplied using --ignore-whitespace or similar.
2020-02-16 07:49:52 +00:00
GetModuleFileName(NULL, b, sizeof(b) - 1);
si.cb = sizeof(si);
si.lpReserved = NULL;
si.lpDesktop = NULL;
si.lpTitle = NULL;
si.dwFlags = 0;
si.cbReserved2 = 0;
si.lpReserved2 = NULL;
CreateProcess(b, cl, NULL, NULL, inherit_handles,
NORMAL_PRIORITY_CLASS, NULL, NULL, &si, &pi);
CloseHandle(pi.hProcess);
CloseHandle(pi.hThread);
if (filemap)
CloseHandle(filemap);
sfree(cl);
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
break;
Formatting change to braces around one case of a switch. Sometimes, within a switch statement, you want to declare local variables specific to the handler for one particular case. Until now I've mostly been writing this in the form switch (discriminant) { case SIMPLE: do stuff; break; case COMPLICATED: { declare variables; do stuff; } break; } which is ugly because the two pieces of essentially similar code appear at different indent levels, and also inconvenient because you have less horizontal space available to write the complicated case handler in - particuarly undesirable because _complicated_ case handlers are the ones most likely to need all the space they can get! After encountering a rather nicer idiom in the LLVM source code, and after a bit of hackery this morning figuring out how to persuade Emacs's auto-indent to do what I wanted with it, I've decided to move to an idiom in which the open brace comes right after the case statement, and the code within it is indented the same as it would have been without the brace. Then the whole case handler (including the break) lives inside those braces, and you get something that looks more like this: switch (discriminant) { case SIMPLE: do stuff; break; case COMPLICATED: { declare variables; do stuff; break; } } This commit is a big-bang change that reformats all the complicated case handlers I could find into the new layout. This is particularly nice in the Pageant main function, in which almost _every_ case handler had a bundle of variables and was long and complicated. (In fact that's what motivated me to get round to this.) Some of the innermost parts of the terminal escape-sequence handling are also breathing a bit easier now the horizontal pressure on them is relieved. (Also, in a few cases, I was able to remove the extra braces completely, because the only variable local to the case handler was a loop variable which our new C99 policy allows me to move into the initialiser clause of its for statement.) Viewed with whitespace ignored, this is not too disruptive a change. Downstream patches that conflict with it may need to be reapplied using --ignore-whitespace or similar.
2020-02-16 07:49:52 +00:00
}
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
case IDM_RESTART:
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
if (!wgs->backend) {
lp_eventlog(&wgs->logpolicy, "----- Session restarted -----");
term_pwron(wgs->term, false);
start_backend(wgs);
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
}
break;
Formatting change to braces around one case of a switch. Sometimes, within a switch statement, you want to declare local variables specific to the handler for one particular case. Until now I've mostly been writing this in the form switch (discriminant) { case SIMPLE: do stuff; break; case COMPLICATED: { declare variables; do stuff; } break; } which is ugly because the two pieces of essentially similar code appear at different indent levels, and also inconvenient because you have less horizontal space available to write the complicated case handler in - particuarly undesirable because _complicated_ case handlers are the ones most likely to need all the space they can get! After encountering a rather nicer idiom in the LLVM source code, and after a bit of hackery this morning figuring out how to persuade Emacs's auto-indent to do what I wanted with it, I've decided to move to an idiom in which the open brace comes right after the case statement, and the code within it is indented the same as it would have been without the brace. Then the whole case handler (including the break) lives inside those braces, and you get something that looks more like this: switch (discriminant) { case SIMPLE: do stuff; break; case COMPLICATED: { declare variables; do stuff; break; } } This commit is a big-bang change that reformats all the complicated case handlers I could find into the new layout. This is particularly nice in the Pageant main function, in which almost _every_ case handler had a bundle of variables and was long and complicated. (In fact that's what motivated me to get round to this.) Some of the innermost parts of the terminal escape-sequence handling are also breathing a bit easier now the horizontal pressure on them is relieved. (Also, in a few cases, I was able to remove the extra braces completely, because the only variable local to the case handler was a loop variable which our new C99 policy allows me to move into the initialiser clause of its for statement.) Viewed with whitespace ignored, this is not too disruptive a change. Downstream patches that conflict with it may need to be reapplied using --ignore-whitespace or similar.
2020-02-16 07:49:52 +00:00
case IDM_RECONF: {
Conf *prev_conf;
int init_lvl = 1;
bool reconfig_result;
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
if (wgs->reconfiguring)
Formatting change to braces around one case of a switch. Sometimes, within a switch statement, you want to declare local variables specific to the handler for one particular case. Until now I've mostly been writing this in the form switch (discriminant) { case SIMPLE: do stuff; break; case COMPLICATED: { declare variables; do stuff; } break; } which is ugly because the two pieces of essentially similar code appear at different indent levels, and also inconvenient because you have less horizontal space available to write the complicated case handler in - particuarly undesirable because _complicated_ case handlers are the ones most likely to need all the space they can get! After encountering a rather nicer idiom in the LLVM source code, and after a bit of hackery this morning figuring out how to persuade Emacs's auto-indent to do what I wanted with it, I've decided to move to an idiom in which the open brace comes right after the case statement, and the code within it is indented the same as it would have been without the brace. Then the whole case handler (including the break) lives inside those braces, and you get something that looks more like this: switch (discriminant) { case SIMPLE: do stuff; break; case COMPLICATED: { declare variables; do stuff; break; } } This commit is a big-bang change that reformats all the complicated case handlers I could find into the new layout. This is particularly nice in the Pageant main function, in which almost _every_ case handler had a bundle of variables and was long and complicated. (In fact that's what motivated me to get round to this.) Some of the innermost parts of the terminal escape-sequence handling are also breathing a bit easier now the horizontal pressure on them is relieved. (Also, in a few cases, I was able to remove the extra braces completely, because the only variable local to the case handler was a loop variable which our new C99 policy allows me to move into the initialiser clause of its for statement.) Viewed with whitespace ignored, this is not too disruptive a change. Downstream patches that conflict with it may need to be reapplied using --ignore-whitespace or similar.
2020-02-16 07:49:52 +00:00
break;
else
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
wgs->reconfiguring = true;
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
term_pre_reconfig(wgs->term, wgs->conf);
prev_conf = conf_copy(wgs->conf);
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
Formatting change to braces around one case of a switch. Sometimes, within a switch statement, you want to declare local variables specific to the handler for one particular case. Until now I've mostly been writing this in the form switch (discriminant) { case SIMPLE: do stuff; break; case COMPLICATED: { declare variables; do stuff; } break; } which is ugly because the two pieces of essentially similar code appear at different indent levels, and also inconvenient because you have less horizontal space available to write the complicated case handler in - particuarly undesirable because _complicated_ case handlers are the ones most likely to need all the space they can get! After encountering a rather nicer idiom in the LLVM source code, and after a bit of hackery this morning figuring out how to persuade Emacs's auto-indent to do what I wanted with it, I've decided to move to an idiom in which the open brace comes right after the case statement, and the code within it is indented the same as it would have been without the brace. Then the whole case handler (including the break) lives inside those braces, and you get something that looks more like this: switch (discriminant) { case SIMPLE: do stuff; break; case COMPLICATED: { declare variables; do stuff; break; } } This commit is a big-bang change that reformats all the complicated case handlers I could find into the new layout. This is particularly nice in the Pageant main function, in which almost _every_ case handler had a bundle of variables and was long and complicated. (In fact that's what motivated me to get round to this.) Some of the innermost parts of the terminal escape-sequence handling are also breathing a bit easier now the horizontal pressure on them is relieved. (Also, in a few cases, I was able to remove the extra braces completely, because the only variable local to the case handler was a loop variable which our new C99 policy allows me to move into the initialiser clause of its for statement.) Viewed with whitespace ignored, this is not too disruptive a change. Downstream patches that conflict with it may need to be reapplied using --ignore-whitespace or similar.
2020-02-16 07:49:52 +00:00
reconfig_result = do_reconfig(
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
hwnd, wgs->conf,
wgs->backend ? backend_cfg_info(wgs->backend) : 0);
wgs->reconfiguring = false;
Formatting change to braces around one case of a switch. Sometimes, within a switch statement, you want to declare local variables specific to the handler for one particular case. Until now I've mostly been writing this in the form switch (discriminant) { case SIMPLE: do stuff; break; case COMPLICATED: { declare variables; do stuff; } break; } which is ugly because the two pieces of essentially similar code appear at different indent levels, and also inconvenient because you have less horizontal space available to write the complicated case handler in - particuarly undesirable because _complicated_ case handlers are the ones most likely to need all the space they can get! After encountering a rather nicer idiom in the LLVM source code, and after a bit of hackery this morning figuring out how to persuade Emacs's auto-indent to do what I wanted with it, I've decided to move to an idiom in which the open brace comes right after the case statement, and the code within it is indented the same as it would have been without the brace. Then the whole case handler (including the break) lives inside those braces, and you get something that looks more like this: switch (discriminant) { case SIMPLE: do stuff; break; case COMPLICATED: { declare variables; do stuff; break; } } This commit is a big-bang change that reformats all the complicated case handlers I could find into the new layout. This is particularly nice in the Pageant main function, in which almost _every_ case handler had a bundle of variables and was long and complicated. (In fact that's what motivated me to get round to this.) Some of the innermost parts of the terminal escape-sequence handling are also breathing a bit easier now the horizontal pressure on them is relieved. (Also, in a few cases, I was able to remove the extra braces completely, because the only variable local to the case handler was a loop variable which our new C99 policy allows me to move into the initialiser clause of its for statement.) Viewed with whitespace ignored, this is not too disruptive a change. Downstream patches that conflict with it may need to be reapplied using --ignore-whitespace or similar.
2020-02-16 07:49:52 +00:00
if (!reconfig_result) {
Formatting: normalise back to 4-space indentation. In several pieces of development recently I've run across the occasional code block in the middle of a function which suddenly switched to 2-space indent from this code base's usual 4. I decided I was tired of it, so I ran the whole code base through a re-indenter, which made a huge mess, and then manually sifted out the changes that actually made sense from that pass. Indeed, this caught quite a few large sections with 2-space indent level, a couple with 8, and a handful of even weirder things like 3 spaces or 12. This commit fixes them all.
2022-08-03 19:48:46 +00:00
conf_free(prev_conf);
break;
Formatting change to braces around one case of a switch. Sometimes, within a switch statement, you want to declare local variables specific to the handler for one particular case. Until now I've mostly been writing this in the form switch (discriminant) { case SIMPLE: do stuff; break; case COMPLICATED: { declare variables; do stuff; } break; } which is ugly because the two pieces of essentially similar code appear at different indent levels, and also inconvenient because you have less horizontal space available to write the complicated case handler in - particuarly undesirable because _complicated_ case handlers are the ones most likely to need all the space they can get! After encountering a rather nicer idiom in the LLVM source code, and after a bit of hackery this morning figuring out how to persuade Emacs's auto-indent to do what I wanted with it, I've decided to move to an idiom in which the open brace comes right after the case statement, and the code within it is indented the same as it would have been without the brace. Then the whole case handler (including the break) lives inside those braces, and you get something that looks more like this: switch (discriminant) { case SIMPLE: do stuff; break; case COMPLICATED: { declare variables; do stuff; break; } } This commit is a big-bang change that reformats all the complicated case handlers I could find into the new layout. This is particularly nice in the Pageant main function, in which almost _every_ case handler had a bundle of variables and was long and complicated. (In fact that's what motivated me to get round to this.) Some of the innermost parts of the terminal escape-sequence handling are also breathing a bit easier now the horizontal pressure on them is relieved. (Also, in a few cases, I was able to remove the extra braces completely, because the only variable local to the case handler was a loop variable which our new C99 policy allows me to move into the initialiser clause of its for statement.) Viewed with whitespace ignored, this is not too disruptive a change. Downstream patches that conflict with it may need to be reapplied using --ignore-whitespace or similar.
2020-02-16 07:49:52 +00:00
}
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
conf_cache_data(wgs);
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
resize_action = conf_get_int(wgs->conf, CONF_resize_action);
Formatting change to braces around one case of a switch. Sometimes, within a switch statement, you want to declare local variables specific to the handler for one particular case. Until now I've mostly been writing this in the form switch (discriminant) { case SIMPLE: do stuff; break; case COMPLICATED: { declare variables; do stuff; } break; } which is ugly because the two pieces of essentially similar code appear at different indent levels, and also inconvenient because you have less horizontal space available to write the complicated case handler in - particuarly undesirable because _complicated_ case handlers are the ones most likely to need all the space they can get! After encountering a rather nicer idiom in the LLVM source code, and after a bit of hackery this morning figuring out how to persuade Emacs's auto-indent to do what I wanted with it, I've decided to move to an idiom in which the open brace comes right after the case statement, and the code within it is indented the same as it would have been without the brace. Then the whole case handler (including the break) lives inside those braces, and you get something that looks more like this: switch (discriminant) { case SIMPLE: do stuff; break; case COMPLICATED: { declare variables; do stuff; break; } } This commit is a big-bang change that reformats all the complicated case handlers I could find into the new layout. This is particularly nice in the Pageant main function, in which almost _every_ case handler had a bundle of variables and was long and complicated. (In fact that's what motivated me to get round to this.) Some of the innermost parts of the terminal escape-sequence handling are also breathing a bit easier now the horizontal pressure on them is relieved. (Also, in a few cases, I was able to remove the extra braces completely, because the only variable local to the case handler was a loop variable which our new C99 policy allows me to move into the initialiser clause of its for statement.) Viewed with whitespace ignored, this is not too disruptive a change. Downstream patches that conflict with it may need to be reapplied using --ignore-whitespace or similar.
2020-02-16 07:49:52 +00:00
{
Formatting: normalise back to 4-space indentation. In several pieces of development recently I've run across the occasional code block in the middle of a function which suddenly switched to 2-space indent from this code base's usual 4. I decided I was tired of it, so I ran the whole code base through a re-indenter, which made a huge mess, and then manually sifted out the changes that actually made sense from that pass. Indeed, this caught quite a few large sections with 2-space indent level, a couple with 8, and a handful of even weirder things like 3 spaces or 12. This commit fixes them all.
2022-08-03 19:48:46 +00:00
/* Disable full-screen if resizing forbidden */
int i;
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
for (i = 0; i < lenof(wgs->popup_menus); i++)
EnableMenuItem(wgs->popup_menus[i].menu, IDM_FULLSCREEN,
Formatting: normalise back to 4-space indentation. In several pieces of development recently I've run across the occasional code block in the middle of a function which suddenly switched to 2-space indent from this code base's usual 4. I decided I was tired of it, so I ran the whole code base through a re-indenter, which made a huge mess, and then manually sifted out the changes that actually made sense from that pass. Indeed, this caught quite a few large sections with 2-space indent level, a couple with 8, and a handful of even weirder things like 3 spaces or 12. This commit fixes them all.
2022-08-03 19:48:46 +00:00
MF_BYCOMMAND |
(resize_action == RESIZE_DISABLED
? MF_GRAYED : MF_ENABLED));
/* Gracefully unzoom if necessary */
if (IsZoomed(hwnd) && (resize_action == RESIZE_DISABLED))
ShowWindow(hwnd, SW_RESTORE);
Formatting change to braces around one case of a switch. Sometimes, within a switch statement, you want to declare local variables specific to the handler for one particular case. Until now I've mostly been writing this in the form switch (discriminant) { case SIMPLE: do stuff; break; case COMPLICATED: { declare variables; do stuff; } break; } which is ugly because the two pieces of essentially similar code appear at different indent levels, and also inconvenient because you have less horizontal space available to write the complicated case handler in - particuarly undesirable because _complicated_ case handlers are the ones most likely to need all the space they can get! After encountering a rather nicer idiom in the LLVM source code, and after a bit of hackery this morning figuring out how to persuade Emacs's auto-indent to do what I wanted with it, I've decided to move to an idiom in which the open brace comes right after the case statement, and the code within it is indented the same as it would have been without the brace. Then the whole case handler (including the break) lives inside those braces, and you get something that looks more like this: switch (discriminant) { case SIMPLE: do stuff; break; case COMPLICATED: { declare variables; do stuff; break; } } This commit is a big-bang change that reformats all the complicated case handlers I could find into the new layout. This is particularly nice in the Pageant main function, in which almost _every_ case handler had a bundle of variables and was long and complicated. (In fact that's what motivated me to get round to this.) Some of the innermost parts of the terminal escape-sequence handling are also breathing a bit easier now the horizontal pressure on them is relieved. (Also, in a few cases, I was able to remove the extra braces completely, because the only variable local to the case handler was a loop variable which our new C99 policy allows me to move into the initialiser clause of its for statement.) Viewed with whitespace ignored, this is not too disruptive a change. Downstream patches that conflict with it may need to be reapplied using --ignore-whitespace or similar.
2020-02-16 07:49:52 +00:00
}
Improved session logging courtesy of Roman Pompejus [originally from svn r846]
2001-01-07 18:24:59 +00:00
Formatting change to braces around one case of a switch. Sometimes, within a switch statement, you want to declare local variables specific to the handler for one particular case. Until now I've mostly been writing this in the form switch (discriminant) { case SIMPLE: do stuff; break; case COMPLICATED: { declare variables; do stuff; } break; } which is ugly because the two pieces of essentially similar code appear at different indent levels, and also inconvenient because you have less horizontal space available to write the complicated case handler in - particuarly undesirable because _complicated_ case handlers are the ones most likely to need all the space they can get! After encountering a rather nicer idiom in the LLVM source code, and after a bit of hackery this morning figuring out how to persuade Emacs's auto-indent to do what I wanted with it, I've decided to move to an idiom in which the open brace comes right after the case statement, and the code within it is indented the same as it would have been without the brace. Then the whole case handler (including the break) lives inside those braces, and you get something that looks more like this: switch (discriminant) { case SIMPLE: do stuff; break; case COMPLICATED: { declare variables; do stuff; break; } } This commit is a big-bang change that reformats all the complicated case handlers I could find into the new layout. This is particularly nice in the Pageant main function, in which almost _every_ case handler had a bundle of variables and was long and complicated. (In fact that's what motivated me to get round to this.) Some of the innermost parts of the terminal escape-sequence handling are also breathing a bit easier now the horizontal pressure on them is relieved. (Also, in a few cases, I was able to remove the extra braces completely, because the only variable local to the case handler was a loop variable which our new C99 policy allows me to move into the initialiser clause of its for statement.) Viewed with whitespace ignored, this is not too disruptive a change. Downstream patches that conflict with it may need to be reapplied using --ignore-whitespace or similar.
2020-02-16 07:49:52 +00:00
/* Pass new config data to the logging module */
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
log_reconfig(wgs->logctx, wgs->conf);
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
sfree(wgs->logpal);
Formatting change to braces around one case of a switch. Sometimes, within a switch statement, you want to declare local variables specific to the handler for one particular case. Until now I've mostly been writing this in the form switch (discriminant) { case SIMPLE: do stuff; break; case COMPLICATED: { declare variables; do stuff; } break; } which is ugly because the two pieces of essentially similar code appear at different indent levels, and also inconvenient because you have less horizontal space available to write the complicated case handler in - particuarly undesirable because _complicated_ case handlers are the ones most likely to need all the space they can get! After encountering a rather nicer idiom in the LLVM source code, and after a bit of hackery this morning figuring out how to persuade Emacs's auto-indent to do what I wanted with it, I've decided to move to an idiom in which the open brace comes right after the case statement, and the code within it is indented the same as it would have been without the brace. Then the whole case handler (including the break) lives inside those braces, and you get something that looks more like this: switch (discriminant) { case SIMPLE: do stuff; break; case COMPLICATED: { declare variables; do stuff; break; } } This commit is a big-bang change that reformats all the complicated case handlers I could find into the new layout. This is particularly nice in the Pageant main function, in which almost _every_ case handler had a bundle of variables and was long and complicated. (In fact that's what motivated me to get round to this.) Some of the innermost parts of the terminal escape-sequence handling are also breathing a bit easier now the horizontal pressure on them is relieved. (Also, in a few cases, I was able to remove the extra braces completely, because the only variable local to the case handler was a loop variable which our new C99 policy allows me to move into the initialiser clause of its for statement.) Viewed with whitespace ignored, this is not too disruptive a change. Downstream patches that conflict with it may need to be reapplied using --ignore-whitespace or similar.
2020-02-16 07:49:52 +00:00
/*
* Flush the line discipline's edit buffer in the
* case where local editing has just been disabled.
*/
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
if (wgs->ldisc) {
ldisc_configure(wgs->ldisc, wgs->conf);
ldisc_echoedit_update(wgs->ldisc);
Formatting change to braces around one case of a switch. Sometimes, within a switch statement, you want to declare local variables specific to the handler for one particular case. Until now I've mostly been writing this in the form switch (discriminant) { case SIMPLE: do stuff; break; case COMPLICATED: { declare variables; do stuff; } break; } which is ugly because the two pieces of essentially similar code appear at different indent levels, and also inconvenient because you have less horizontal space available to write the complicated case handler in - particuarly undesirable because _complicated_ case handlers are the ones most likely to need all the space they can get! After encountering a rather nicer idiom in the LLVM source code, and after a bit of hackery this morning figuring out how to persuade Emacs's auto-indent to do what I wanted with it, I've decided to move to an idiom in which the open brace comes right after the case statement, and the code within it is indented the same as it would have been without the brace. Then the whole case handler (including the break) lives inside those braces, and you get something that looks more like this: switch (discriminant) { case SIMPLE: do stuff; break; case COMPLICATED: { declare variables; do stuff; break; } } This commit is a big-bang change that reformats all the complicated case handlers I could find into the new layout. This is particularly nice in the Pageant main function, in which almost _every_ case handler had a bundle of variables and was long and complicated. (In fact that's what motivated me to get round to this.) Some of the innermost parts of the terminal escape-sequence handling are also breathing a bit easier now the horizontal pressure on them is relieved. (Also, in a few cases, I was able to remove the extra braces completely, because the only variable local to the case handler was a loop variable which our new C99 policy allows me to move into the initialiser clause of its for statement.) Viewed with whitespace ignored, this is not too disruptive a change. Downstream patches that conflict with it may need to be reapplied using --ignore-whitespace or similar.
2020-02-16 07:49:52 +00:00
}
Centralise palette setup into terminal.c. Now terminal.c makes nearly all the decisions about what the colour palette should actually contain: it does the job of reading the GUI-configurable colours out of Conf, and also the job of making up the rest of the xterm-256 palette. The only exception is that TermWin can provide a method to override some of the default colours, which on Windows is used to implement the 'Use system colours' config option. This saves code overall, partly because the front ends don't have to be able to send palette data back to the Terminal any more (the Terminal keeps the master copy and can answer palette-query escape sequences from its own knowledge), and also because now there's only one copy of the xterm-256 palette setup code (previously gtkwin.c and window.c each had their own version of it). In this rewrite, I've also introduced a multi-layered storage system for the palette data in Terminal. One layer contains the palette information derived from Conf; the next contains platform overrides (currently just Windows's 'Use system colours'); the last one contains overrides set by escape sequences in the middle of the session. The topmost two layers can each _conditionally_ override the ones below. As a result, if a server-side application manually resets (say) the default fg and bg colours in mid-session to something that works well in a particular application, those changes won't be wiped out by a change in the Windows system colours or the Conf, which they would have been before. Instead, changes in Conf or the system colours alter the lower layers of the structure, but then when palette_rebuild is called, the upper layer continues to override them, until a palette reset (ESC]R) or terminal reset (e.g. ESC c) removes those upper-layer changes. This seems like a more consistent strategy, in that the same set of configuration settings will produce the same end result regardless of what order they were applied in. The palette-related methods in TermWin have had a total rework. palette_get and palette_reset are both gone; palette_set can now set a contiguous range of colours in one go; and the new palette_get_overrides replaces window.c's old systopalette().
2021-02-07 19:59:21 +00:00
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
if (conf_get_bool(wgs->conf, CONF_system_colour) !=
Centralise palette setup into terminal.c. Now terminal.c makes nearly all the decisions about what the colour palette should actually contain: it does the job of reading the GUI-configurable colours out of Conf, and also the job of making up the rest of the xterm-256 palette. The only exception is that TermWin can provide a method to override some of the default colours, which on Windows is used to implement the 'Use system colours' config option. This saves code overall, partly because the front ends don't have to be able to send palette data back to the Terminal any more (the Terminal keeps the master copy and can answer palette-query escape sequences from its own knowledge), and also because now there's only one copy of the xterm-256 palette setup code (previously gtkwin.c and window.c each had their own version of it). In this rewrite, I've also introduced a multi-layered storage system for the palette data in Terminal. One layer contains the palette information derived from Conf; the next contains platform overrides (currently just Windows's 'Use system colours'); the last one contains overrides set by escape sequences in the middle of the session. The topmost two layers can each _conditionally_ override the ones below. As a result, if a server-side application manually resets (say) the default fg and bg colours in mid-session to something that works well in a particular application, those changes won't be wiped out by a change in the Windows system colours or the Conf, which they would have been before. Instead, changes in Conf or the system colours alter the lower layers of the structure, but then when palette_rebuild is called, the upper layer continues to override them, until a palette reset (ESC]R) or terminal reset (e.g. ESC c) removes those upper-layer changes. This seems like a more consistent strategy, in that the same set of configuration settings will produce the same end result regardless of what order they were applied in. The palette-related methods in TermWin have had a total rework. palette_get and palette_reset are both gone; palette_set can now set a contiguous range of colours in one go; and the new palette_get_overrides replaces window.c's old systopalette().
2021-02-07 19:59:21 +00:00
conf_get_bool(prev_conf, CONF_system_colour))
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
term_notify_palette_changed(wgs->term);
Centralise palette setup into terminal.c. Now terminal.c makes nearly all the decisions about what the colour palette should actually contain: it does the job of reading the GUI-configurable colours out of Conf, and also the job of making up the rest of the xterm-256 palette. The only exception is that TermWin can provide a method to override some of the default colours, which on Windows is used to implement the 'Use system colours' config option. This saves code overall, partly because the front ends don't have to be able to send palette data back to the Terminal any more (the Terminal keeps the master copy and can answer palette-query escape sequences from its own knowledge), and also because now there's only one copy of the xterm-256 palette setup code (previously gtkwin.c and window.c each had their own version of it). In this rewrite, I've also introduced a multi-layered storage system for the palette data in Terminal. One layer contains the palette information derived from Conf; the next contains platform overrides (currently just Windows's 'Use system colours'); the last one contains overrides set by escape sequences in the middle of the session. The topmost two layers can each _conditionally_ override the ones below. As a result, if a server-side application manually resets (say) the default fg and bg colours in mid-session to something that works well in a particular application, those changes won't be wiped out by a change in the Windows system colours or the Conf, which they would have been before. Instead, changes in Conf or the system colours alter the lower layers of the structure, but then when palette_rebuild is called, the upper layer continues to override them, until a palette reset (ESC]R) or terminal reset (e.g. ESC c) removes those upper-layer changes. This seems like a more consistent strategy, in that the same set of configuration settings will produce the same end result regardless of what order they were applied in. The palette-related methods in TermWin have had a total rework. palette_get and palette_reset are both gone; palette_set can now set a contiguous range of colours in one go; and the new palette_get_overrides replaces window.c's old systopalette().
2021-02-07 19:59:21 +00:00
/* Pass new config data to the terminal */
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
term_reconfig(wgs->term, wgs->conf);
setup_clipboards(wgs->term, wgs->conf);
Centralise palette setup into terminal.c. Now terminal.c makes nearly all the decisions about what the colour palette should actually contain: it does the job of reading the GUI-configurable colours out of Conf, and also the job of making up the rest of the xterm-256 palette. The only exception is that TermWin can provide a method to override some of the default colours, which on Windows is used to implement the 'Use system colours' config option. This saves code overall, partly because the front ends don't have to be able to send palette data back to the Terminal any more (the Terminal keeps the master copy and can answer palette-query escape sequences from its own knowledge), and also because now there's only one copy of the xterm-256 palette setup code (previously gtkwin.c and window.c each had their own version of it). In this rewrite, I've also introduced a multi-layered storage system for the palette data in Terminal. One layer contains the palette information derived from Conf; the next contains platform overrides (currently just Windows's 'Use system colours'); the last one contains overrides set by escape sequences in the middle of the session. The topmost two layers can each _conditionally_ override the ones below. As a result, if a server-side application manually resets (say) the default fg and bg colours in mid-session to something that works well in a particular application, those changes won't be wiped out by a change in the Windows system colours or the Conf, which they would have been before. Instead, changes in Conf or the system colours alter the lower layers of the structure, but then when palette_rebuild is called, the upper layer continues to override them, until a palette reset (ESC]R) or terminal reset (e.g. ESC c) removes those upper-layer changes. This seems like a more consistent strategy, in that the same set of configuration settings will produce the same end result regardless of what order they were applied in. The palette-related methods in TermWin have had a total rework. palette_get and palette_reset are both gone; palette_set can now set a contiguous range of colours in one go; and the new palette_get_overrides replaces window.c's old systopalette().
2021-02-07 19:59:21 +00:00
/* Reinitialise the colour palette, in case the terminal
* just read new settings out of Conf */
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
if (wgs->pal)
DeleteObject(wgs->pal);
wgs->logpal = NULL;
wgs->pal = NULL;
init_palette(wgs);
Formatting change to braces around one case of a switch. Sometimes, within a switch statement, you want to declare local variables specific to the handler for one particular case. Until now I've mostly been writing this in the form switch (discriminant) { case SIMPLE: do stuff; break; case COMPLICATED: { declare variables; do stuff; } break; } which is ugly because the two pieces of essentially similar code appear at different indent levels, and also inconvenient because you have less horizontal space available to write the complicated case handler in - particuarly undesirable because _complicated_ case handlers are the ones most likely to need all the space they can get! After encountering a rather nicer idiom in the LLVM source code, and after a bit of hackery this morning figuring out how to persuade Emacs's auto-indent to do what I wanted with it, I've decided to move to an idiom in which the open brace comes right after the case statement, and the code within it is indented the same as it would have been without the brace. Then the whole case handler (including the break) lives inside those braces, and you get something that looks more like this: switch (discriminant) { case SIMPLE: do stuff; break; case COMPLICATED: { declare variables; do stuff; break; } } This commit is a big-bang change that reformats all the complicated case handlers I could find into the new layout. This is particularly nice in the Pageant main function, in which almost _every_ case handler had a bundle of variables and was long and complicated. (In fact that's what motivated me to get round to this.) Some of the innermost parts of the terminal escape-sequence handling are also breathing a bit easier now the horizontal pressure on them is relieved. (Also, in a few cases, I was able to remove the extra braces completely, because the only variable local to the case handler was a loop variable which our new C99 policy allows me to move into the initialiser clause of its for statement.) Viewed with whitespace ignored, this is not too disruptive a change. Downstream patches that conflict with it may need to be reapplied using --ignore-whitespace or similar.
2020-02-16 07:49:52 +00:00
/* Pass new config data to the back end */
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
if (wgs->backend)
backend_reconfig(wgs->backend, wgs->conf);
Formatting change to braces around one case of a switch. Sometimes, within a switch statement, you want to declare local variables specific to the handler for one particular case. Until now I've mostly been writing this in the form switch (discriminant) { case SIMPLE: do stuff; break; case COMPLICATED: { declare variables; do stuff; } break; } which is ugly because the two pieces of essentially similar code appear at different indent levels, and also inconvenient because you have less horizontal space available to write the complicated case handler in - particuarly undesirable because _complicated_ case handlers are the ones most likely to need all the space they can get! After encountering a rather nicer idiom in the LLVM source code, and after a bit of hackery this morning figuring out how to persuade Emacs's auto-indent to do what I wanted with it, I've decided to move to an idiom in which the open brace comes right after the case statement, and the code within it is indented the same as it would have been without the brace. Then the whole case handler (including the break) lives inside those braces, and you get something that looks more like this: switch (discriminant) { case SIMPLE: do stuff; break; case COMPLICATED: { declare variables; do stuff; break; } } This commit is a big-bang change that reformats all the complicated case handlers I could find into the new layout. This is particularly nice in the Pageant main function, in which almost _every_ case handler had a bundle of variables and was long and complicated. (In fact that's what motivated me to get round to this.) Some of the innermost parts of the terminal escape-sequence handling are also breathing a bit easier now the horizontal pressure on them is relieved. (Also, in a few cases, I was able to remove the extra braces completely, because the only variable local to the case handler was a loop variable which our new C99 policy allows me to move into the initialiser clause of its for statement.) Viewed with whitespace ignored, this is not too disruptive a change. Downstream patches that conflict with it may need to be reapplied using --ignore-whitespace or similar.
2020-02-16 07:49:52 +00:00
/* Screen size changed ? */
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
if (conf_get_int(wgs->conf, CONF_height) !=
Formatting change to braces around one case of a switch. Sometimes, within a switch statement, you want to declare local variables specific to the handler for one particular case. Until now I've mostly been writing this in the form switch (discriminant) { case SIMPLE: do stuff; break; case COMPLICATED: { declare variables; do stuff; } break; } which is ugly because the two pieces of essentially similar code appear at different indent levels, and also inconvenient because you have less horizontal space available to write the complicated case handler in - particuarly undesirable because _complicated_ case handlers are the ones most likely to need all the space they can get! After encountering a rather nicer idiom in the LLVM source code, and after a bit of hackery this morning figuring out how to persuade Emacs's auto-indent to do what I wanted with it, I've decided to move to an idiom in which the open brace comes right after the case statement, and the code within it is indented the same as it would have been without the brace. Then the whole case handler (including the break) lives inside those braces, and you get something that looks more like this: switch (discriminant) { case SIMPLE: do stuff; break; case COMPLICATED: { declare variables; do stuff; break; } } This commit is a big-bang change that reformats all the complicated case handlers I could find into the new layout. This is particularly nice in the Pageant main function, in which almost _every_ case handler had a bundle of variables and was long and complicated. (In fact that's what motivated me to get round to this.) Some of the innermost parts of the terminal escape-sequence handling are also breathing a bit easier now the horizontal pressure on them is relieved. (Also, in a few cases, I was able to remove the extra braces completely, because the only variable local to the case handler was a loop variable which our new C99 policy allows me to move into the initialiser clause of its for statement.) Viewed with whitespace ignored, this is not too disruptive a change. Downstream patches that conflict with it may need to be reapplied using --ignore-whitespace or similar.
2020-02-16 07:49:52 +00:00
conf_get_int(prev_conf, CONF_height) ||
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
conf_get_int(wgs->conf, CONF_width) !=
Formatting change to braces around one case of a switch. Sometimes, within a switch statement, you want to declare local variables specific to the handler for one particular case. Until now I've mostly been writing this in the form switch (discriminant) { case SIMPLE: do stuff; break; case COMPLICATED: { declare variables; do stuff; } break; } which is ugly because the two pieces of essentially similar code appear at different indent levels, and also inconvenient because you have less horizontal space available to write the complicated case handler in - particuarly undesirable because _complicated_ case handlers are the ones most likely to need all the space they can get! After encountering a rather nicer idiom in the LLVM source code, and after a bit of hackery this morning figuring out how to persuade Emacs's auto-indent to do what I wanted with it, I've decided to move to an idiom in which the open brace comes right after the case statement, and the code within it is indented the same as it would have been without the brace. Then the whole case handler (including the break) lives inside those braces, and you get something that looks more like this: switch (discriminant) { case SIMPLE: do stuff; break; case COMPLICATED: { declare variables; do stuff; break; } } This commit is a big-bang change that reformats all the complicated case handlers I could find into the new layout. This is particularly nice in the Pageant main function, in which almost _every_ case handler had a bundle of variables and was long and complicated. (In fact that's what motivated me to get round to this.) Some of the innermost parts of the terminal escape-sequence handling are also breathing a bit easier now the horizontal pressure on them is relieved. (Also, in a few cases, I was able to remove the extra braces completely, because the only variable local to the case handler was a loop variable which our new C99 policy allows me to move into the initialiser clause of its for statement.) Viewed with whitespace ignored, this is not too disruptive a change. Downstream patches that conflict with it may need to be reapplied using --ignore-whitespace or similar.
2020-02-16 07:49:52 +00:00
conf_get_int(prev_conf, CONF_width) ||
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
conf_get_int(wgs->conf, CONF_savelines) !=
Formatting change to braces around one case of a switch. Sometimes, within a switch statement, you want to declare local variables specific to the handler for one particular case. Until now I've mostly been writing this in the form switch (discriminant) { case SIMPLE: do stuff; break; case COMPLICATED: { declare variables; do stuff; } break; } which is ugly because the two pieces of essentially similar code appear at different indent levels, and also inconvenient because you have less horizontal space available to write the complicated case handler in - particuarly undesirable because _complicated_ case handlers are the ones most likely to need all the space they can get! After encountering a rather nicer idiom in the LLVM source code, and after a bit of hackery this morning figuring out how to persuade Emacs's auto-indent to do what I wanted with it, I've decided to move to an idiom in which the open brace comes right after the case statement, and the code within it is indented the same as it would have been without the brace. Then the whole case handler (including the break) lives inside those braces, and you get something that looks more like this: switch (discriminant) { case SIMPLE: do stuff; break; case COMPLICATED: { declare variables; do stuff; break; } } This commit is a big-bang change that reformats all the complicated case handlers I could find into the new layout. This is particularly nice in the Pageant main function, in which almost _every_ case handler had a bundle of variables and was long and complicated. (In fact that's what motivated me to get round to this.) Some of the innermost parts of the terminal escape-sequence handling are also breathing a bit easier now the horizontal pressure on them is relieved. (Also, in a few cases, I was able to remove the extra braces completely, because the only variable local to the case handler was a loop variable which our new C99 policy allows me to move into the initialiser clause of its for statement.) Viewed with whitespace ignored, this is not too disruptive a change. Downstream patches that conflict with it may need to be reapplied using --ignore-whitespace or similar.
2020-02-16 07:49:52 +00:00
conf_get_int(prev_conf, CONF_savelines) ||
resize_action == RESIZE_FONT ||
(resize_action == RESIZE_EITHER && IsZoomed(hwnd)) ||
resize_action == RESIZE_DISABLED)
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
term_size(wgs->term, conf_get_int(wgs->conf, CONF_height),
conf_get_int(wgs->conf, CONF_width),
conf_get_int(wgs->conf, CONF_savelines));
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
Formatting change to braces around one case of a switch. Sometimes, within a switch statement, you want to declare local variables specific to the handler for one particular case. Until now I've mostly been writing this in the form switch (discriminant) { case SIMPLE: do stuff; break; case COMPLICATED: { declare variables; do stuff; } break; } which is ugly because the two pieces of essentially similar code appear at different indent levels, and also inconvenient because you have less horizontal space available to write the complicated case handler in - particuarly undesirable because _complicated_ case handlers are the ones most likely to need all the space they can get! After encountering a rather nicer idiom in the LLVM source code, and after a bit of hackery this morning figuring out how to persuade Emacs's auto-indent to do what I wanted with it, I've decided to move to an idiom in which the open brace comes right after the case statement, and the code within it is indented the same as it would have been without the brace. Then the whole case handler (including the break) lives inside those braces, and you get something that looks more like this: switch (discriminant) { case SIMPLE: do stuff; break; case COMPLICATED: { declare variables; do stuff; break; } } This commit is a big-bang change that reformats all the complicated case handlers I could find into the new layout. This is particularly nice in the Pageant main function, in which almost _every_ case handler had a bundle of variables and was long and complicated. (In fact that's what motivated me to get round to this.) Some of the innermost parts of the terminal escape-sequence handling are also breathing a bit easier now the horizontal pressure on them is relieved. (Also, in a few cases, I was able to remove the extra braces completely, because the only variable local to the case handler was a loop variable which our new C99 policy allows me to move into the initialiser clause of its for statement.) Viewed with whitespace ignored, this is not too disruptive a change. Downstream patches that conflict with it may need to be reapplied using --ignore-whitespace or similar.
2020-02-16 07:49:52 +00:00
/* Enable or disable the scroll bar, etc */
{
Formatting: normalise back to 4-space indentation. In several pieces of development recently I've run across the occasional code block in the middle of a function which suddenly switched to 2-space indent from this code base's usual 4. I decided I was tired of it, so I ran the whole code base through a re-indenter, which made a huge mess, and then manually sifted out the changes that actually made sense from that pass. Indeed, this caught quite a few large sections with 2-space indent level, a couple with 8, and a handful of even weirder things like 3 spaces or 12. This commit fixes them all.
2022-08-03 19:48:46 +00:00
LONG nflg, flag = GetWindowLongPtr(hwnd, GWL_STYLE);
LONG nexflag, exflag =
GetWindowLongPtr(hwnd, GWL_EXSTYLE);
nexflag = exflag;
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
if (conf_get_bool(wgs->conf, CONF_alwaysontop) !=
Formatting: normalise back to 4-space indentation. In several pieces of development recently I've run across the occasional code block in the middle of a function which suddenly switched to 2-space indent from this code base's usual 4. I decided I was tired of it, so I ran the whole code base through a re-indenter, which made a huge mess, and then manually sifted out the changes that actually made sense from that pass. Indeed, this caught quite a few large sections with 2-space indent level, a couple with 8, and a handful of even weirder things like 3 spaces or 12. This commit fixes them all.
2022-08-03 19:48:46 +00:00
conf_get_bool(prev_conf, CONF_alwaysontop)) {
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
if (conf_get_bool(wgs->conf, CONF_alwaysontop)) {
Formatting: normalise back to 4-space indentation. In several pieces of development recently I've run across the occasional code block in the middle of a function which suddenly switched to 2-space indent from this code base's usual 4. I decided I was tired of it, so I ran the whole code base through a re-indenter, which made a huge mess, and then manually sifted out the changes that actually made sense from that pass. Indeed, this caught quite a few large sections with 2-space indent level, a couple with 8, and a handful of even weirder things like 3 spaces or 12. This commit fixes them all.
2022-08-03 19:48:46 +00:00
nexflag |= WS_EX_TOPMOST;
SetWindowPos(hwnd, HWND_TOPMOST, 0, 0, 0, 0,
SWP_NOMOVE | SWP_NOSIZE);
} else {
nexflag &= ~(WS_EX_TOPMOST);
SetWindowPos(hwnd, HWND_NOTOPMOST, 0, 0, 0, 0,
SWP_NOMOVE | SWP_NOSIZE);
}
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
}
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
if (conf_get_bool(wgs->conf, CONF_sunken_edge))
Formatting: normalise back to 4-space indentation. In several pieces of development recently I've run across the occasional code block in the middle of a function which suddenly switched to 2-space indent from this code base's usual 4. I decided I was tired of it, so I ran the whole code base through a re-indenter, which made a huge mess, and then manually sifted out the changes that actually made sense from that pass. Indeed, this caught quite a few large sections with 2-space indent level, a couple with 8, and a handful of even weirder things like 3 spaces or 12. This commit fixes them all.
2022-08-03 19:48:46 +00:00
nexflag |= WS_EX_CLIENTEDGE;
else
nexflag &= ~(WS_EX_CLIENTEDGE);
Formatting change to braces around one case of a switch. Sometimes, within a switch statement, you want to declare local variables specific to the handler for one particular case. Until now I've mostly been writing this in the form switch (discriminant) { case SIMPLE: do stuff; break; case COMPLICATED: { declare variables; do stuff; } break; } which is ugly because the two pieces of essentially similar code appear at different indent levels, and also inconvenient because you have less horizontal space available to write the complicated case handler in - particuarly undesirable because _complicated_ case handlers are the ones most likely to need all the space they can get! After encountering a rather nicer idiom in the LLVM source code, and after a bit of hackery this morning figuring out how to persuade Emacs's auto-indent to do what I wanted with it, I've decided to move to an idiom in which the open brace comes right after the case statement, and the code within it is indented the same as it would have been without the brace. Then the whole case handler (including the break) lives inside those braces, and you get something that looks more like this: switch (discriminant) { case SIMPLE: do stuff; break; case COMPLICATED: { declare variables; do stuff; break; } } This commit is a big-bang change that reformats all the complicated case handlers I could find into the new layout. This is particularly nice in the Pageant main function, in which almost _every_ case handler had a bundle of variables and was long and complicated. (In fact that's what motivated me to get round to this.) Some of the innermost parts of the terminal escape-sequence handling are also breathing a bit easier now the horizontal pressure on them is relieved. (Also, in a few cases, I was able to remove the extra braces completely, because the only variable local to the case handler was a loop variable which our new C99 policy allows me to move into the initialiser clause of its for statement.) Viewed with whitespace ignored, this is not too disruptive a change. Downstream patches that conflict with it may need to be reapplied using --ignore-whitespace or similar.
2020-02-16 07:49:52 +00:00
Formatting: normalise back to 4-space indentation. In several pieces of development recently I've run across the occasional code block in the middle of a function which suddenly switched to 2-space indent from this code base's usual 4. I decided I was tired of it, so I ran the whole code base through a re-indenter, which made a huge mess, and then manually sifted out the changes that actually made sense from that pass. Indeed, this caught quite a few large sections with 2-space indent level, a couple with 8, and a handful of even weirder things like 3 spaces or 12. This commit fixes them all.
2022-08-03 19:48:46 +00:00
nflg = flag;
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
if (conf_get_bool(wgs->conf, is_full_screen(wgs) ?
Formatting: normalise back to 4-space indentation. In several pieces of development recently I've run across the occasional code block in the middle of a function which suddenly switched to 2-space indent from this code base's usual 4. I decided I was tired of it, so I ran the whole code base through a re-indenter, which made a huge mess, and then manually sifted out the changes that actually made sense from that pass. Indeed, this caught quite a few large sections with 2-space indent level, a couple with 8, and a handful of even weirder things like 3 spaces or 12. This commit fixes them all.
2022-08-03 19:48:46 +00:00
CONF_scrollbar_in_fullscreen :
CONF_scrollbar))
nflg |= WS_VSCROLL;
else
nflg &= ~WS_VSCROLL;
if (resize_action == RESIZE_DISABLED ||
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
is_full_screen(wgs))
Formatting: normalise back to 4-space indentation. In several pieces of development recently I've run across the occasional code block in the middle of a function which suddenly switched to 2-space indent from this code base's usual 4. I decided I was tired of it, so I ran the whole code base through a re-indenter, which made a huge mess, and then manually sifted out the changes that actually made sense from that pass. Indeed, this caught quite a few large sections with 2-space indent level, a couple with 8, and a handful of even weirder things like 3 spaces or 12. This commit fixes them all.
2022-08-03 19:48:46 +00:00
nflg &= ~WS_THICKFRAME;
else
nflg |= WS_THICKFRAME;
if (resize_action == RESIZE_DISABLED)
nflg &= ~WS_MAXIMIZEBOX;
else
nflg |= WS_MAXIMIZEBOX;
if (nflg != flag || nexflag != exflag) {
if (nflg != flag)
SetWindowLongPtr(hwnd, GWL_STYLE, nflg);
if (nexflag != exflag)
SetWindowLongPtr(hwnd, GWL_EXSTYLE, nexflag);
SetWindowPos(hwnd, NULL, 0, 0, 0, 0,
SWP_NOACTIVATE | SWP_NOCOPYBITS |
SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER |
SWP_FRAMECHANGED);
init_lvl = 2;
}
Formatting change to braces around one case of a switch. Sometimes, within a switch statement, you want to declare local variables specific to the handler for one particular case. Until now I've mostly been writing this in the form switch (discriminant) { case SIMPLE: do stuff; break; case COMPLICATED: { declare variables; do stuff; } break; } which is ugly because the two pieces of essentially similar code appear at different indent levels, and also inconvenient because you have less horizontal space available to write the complicated case handler in - particuarly undesirable because _complicated_ case handlers are the ones most likely to need all the space they can get! After encountering a rather nicer idiom in the LLVM source code, and after a bit of hackery this morning figuring out how to persuade Emacs's auto-indent to do what I wanted with it, I've decided to move to an idiom in which the open brace comes right after the case statement, and the code within it is indented the same as it would have been without the brace. Then the whole case handler (including the break) lives inside those braces, and you get something that looks more like this: switch (discriminant) { case SIMPLE: do stuff; break; case COMPLICATED: { declare variables; do stuff; break; } } This commit is a big-bang change that reformats all the complicated case handlers I could find into the new layout. This is particularly nice in the Pageant main function, in which almost _every_ case handler had a bundle of variables and was long and complicated. (In fact that's what motivated me to get round to this.) Some of the innermost parts of the terminal escape-sequence handling are also breathing a bit easier now the horizontal pressure on them is relieved. (Also, in a few cases, I was able to remove the extra braces completely, because the only variable local to the case handler was a loop variable which our new C99 policy allows me to move into the initialiser clause of its for statement.) Viewed with whitespace ignored, this is not too disruptive a change. Downstream patches that conflict with it may need to be reapplied using --ignore-whitespace or similar.
2020-02-16 07:49:52 +00:00
}
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
Formatting change to braces around one case of a switch. Sometimes, within a switch statement, you want to declare local variables specific to the handler for one particular case. Until now I've mostly been writing this in the form switch (discriminant) { case SIMPLE: do stuff; break; case COMPLICATED: { declare variables; do stuff; } break; } which is ugly because the two pieces of essentially similar code appear at different indent levels, and also inconvenient because you have less horizontal space available to write the complicated case handler in - particuarly undesirable because _complicated_ case handlers are the ones most likely to need all the space they can get! After encountering a rather nicer idiom in the LLVM source code, and after a bit of hackery this morning figuring out how to persuade Emacs's auto-indent to do what I wanted with it, I've decided to move to an idiom in which the open brace comes right after the case statement, and the code within it is indented the same as it would have been without the brace. Then the whole case handler (including the break) lives inside those braces, and you get something that looks more like this: switch (discriminant) { case SIMPLE: do stuff; break; case COMPLICATED: { declare variables; do stuff; break; } } This commit is a big-bang change that reformats all the complicated case handlers I could find into the new layout. This is particularly nice in the Pageant main function, in which almost _every_ case handler had a bundle of variables and was long and complicated. (In fact that's what motivated me to get round to this.) Some of the innermost parts of the terminal escape-sequence handling are also breathing a bit easier now the horizontal pressure on them is relieved. (Also, in a few cases, I was able to remove the extra braces completely, because the only variable local to the case handler was a loop variable which our new C99 policy allows me to move into the initialiser clause of its for statement.) Viewed with whitespace ignored, this is not too disruptive a change. Downstream patches that conflict with it may need to be reapplied using --ignore-whitespace or similar.
2020-02-16 07:49:52 +00:00
/* Oops */
if (resize_action == RESIZE_DISABLED && IsZoomed(hwnd)) {
Formatting: normalise back to 4-space indentation. In several pieces of development recently I've run across the occasional code block in the middle of a function which suddenly switched to 2-space indent from this code base's usual 4. I decided I was tired of it, so I ran the whole code base through a re-indenter, which made a huge mess, and then manually sifted out the changes that actually made sense from that pass. Indeed, this caught quite a few large sections with 2-space indent level, a couple with 8, and a handful of even weirder things like 3 spaces or 12. This commit fixes them all.
2022-08-03 19:48:46 +00:00
force_normal(hwnd);
init_lvl = 2;
Formatting change to braces around one case of a switch. Sometimes, within a switch statement, you want to declare local variables specific to the handler for one particular case. Until now I've mostly been writing this in the form switch (discriminant) { case SIMPLE: do stuff; break; case COMPLICATED: { declare variables; do stuff; } break; } which is ugly because the two pieces of essentially similar code appear at different indent levels, and also inconvenient because you have less horizontal space available to write the complicated case handler in - particuarly undesirable because _complicated_ case handlers are the ones most likely to need all the space they can get! After encountering a rather nicer idiom in the LLVM source code, and after a bit of hackery this morning figuring out how to persuade Emacs's auto-indent to do what I wanted with it, I've decided to move to an idiom in which the open brace comes right after the case statement, and the code within it is indented the same as it would have been without the brace. Then the whole case handler (including the break) lives inside those braces, and you get something that looks more like this: switch (discriminant) { case SIMPLE: do stuff; break; case COMPLICATED: { declare variables; do stuff; break; } } This commit is a big-bang change that reformats all the complicated case handlers I could find into the new layout. This is particularly nice in the Pageant main function, in which almost _every_ case handler had a bundle of variables and was long and complicated. (In fact that's what motivated me to get round to this.) Some of the innermost parts of the terminal escape-sequence handling are also breathing a bit easier now the horizontal pressure on them is relieved. (Also, in a few cases, I was able to remove the extra braces completely, because the only variable local to the case handler was a loop variable which our new C99 policy allows me to move into the initialiser clause of its for statement.) Viewed with whitespace ignored, this is not too disruptive a change. Downstream patches that conflict with it may need to be reapplied using --ignore-whitespace or similar.
2020-02-16 07:49:52 +00:00
}
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
Formatting change to braces around one case of a switch. Sometimes, within a switch statement, you want to declare local variables specific to the handler for one particular case. Until now I've mostly been writing this in the form switch (discriminant) { case SIMPLE: do stuff; break; case COMPLICATED: { declare variables; do stuff; } break; } which is ugly because the two pieces of essentially similar code appear at different indent levels, and also inconvenient because you have less horizontal space available to write the complicated case handler in - particuarly undesirable because _complicated_ case handlers are the ones most likely to need all the space they can get! After encountering a rather nicer idiom in the LLVM source code, and after a bit of hackery this morning figuring out how to persuade Emacs's auto-indent to do what I wanted with it, I've decided to move to an idiom in which the open brace comes right after the case statement, and the code within it is indented the same as it would have been without the brace. Then the whole case handler (including the break) lives inside those braces, and you get something that looks more like this: switch (discriminant) { case SIMPLE: do stuff; break; case COMPLICATED: { declare variables; do stuff; break; } } This commit is a big-bang change that reformats all the complicated case handlers I could find into the new layout. This is particularly nice in the Pageant main function, in which almost _every_ case handler had a bundle of variables and was long and complicated. (In fact that's what motivated me to get round to this.) Some of the innermost parts of the terminal escape-sequence handling are also breathing a bit easier now the horizontal pressure on them is relieved. (Also, in a few cases, I was able to remove the extra braces completely, because the only variable local to the case handler was a loop variable which our new C99 policy allows me to move into the initialiser clause of its for statement.) Viewed with whitespace ignored, this is not too disruptive a change. Downstream patches that conflict with it may need to be reapplied using --ignore-whitespace or similar.
2020-02-16 07:49:52 +00:00
{
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
FontSpec *font = conf_get_fontspec(wgs->conf, CONF_font);
Formatting: normalise back to 4-space indentation. In several pieces of development recently I've run across the occasional code block in the middle of a function which suddenly switched to 2-space indent from this code base's usual 4. I decided I was tired of it, so I ran the whole code base through a re-indenter, which made a huge mess, and then manually sifted out the changes that actually made sense from that pass. Indeed, this caught quite a few large sections with 2-space indent level, a couple with 8, and a handful of even weirder things like 3 spaces or 12. This commit fixes them all.
2022-08-03 19:48:46 +00:00
FontSpec *prev_font = conf_get_fontspec(prev_conf,
CONF_font);
if (!strcmp(font->name, prev_font->name) ||
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
!strcmp(conf_get_str(wgs->conf, CONF_line_codepage),
Formatting: normalise back to 4-space indentation. In several pieces of development recently I've run across the occasional code block in the middle of a function which suddenly switched to 2-space indent from this code base's usual 4. I decided I was tired of it, so I ran the whole code base through a re-indenter, which made a huge mess, and then manually sifted out the changes that actually made sense from that pass. Indeed, this caught quite a few large sections with 2-space indent level, a couple with 8, and a handful of even weirder things like 3 spaces or 12. This commit fixes them all.
2022-08-03 19:48:46 +00:00
conf_get_str(prev_conf, CONF_line_codepage)) ||
font->isbold != prev_font->isbold ||
font->height != prev_font->height ||
font->charset != prev_font->charset ||
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
conf_get_int(wgs->conf, CONF_font_quality) !=
Formatting: normalise back to 4-space indentation. In several pieces of development recently I've run across the occasional code block in the middle of a function which suddenly switched to 2-space indent from this code base's usual 4. I decided I was tired of it, so I ran the whole code base through a re-indenter, which made a huge mess, and then manually sifted out the changes that actually made sense from that pass. Indeed, this caught quite a few large sections with 2-space indent level, a couple with 8, and a handful of even weirder things like 3 spaces or 12. This commit fixes them all.
2022-08-03 19:48:46 +00:00
conf_get_int(prev_conf, CONF_font_quality) ||
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
conf_get_int(wgs->conf, CONF_vtmode) !=
Formatting: normalise back to 4-space indentation. In several pieces of development recently I've run across the occasional code block in the middle of a function which suddenly switched to 2-space indent from this code base's usual 4. I decided I was tired of it, so I ran the whole code base through a re-indenter, which made a huge mess, and then manually sifted out the changes that actually made sense from that pass. Indeed, this caught quite a few large sections with 2-space indent level, a couple with 8, and a handful of even weirder things like 3 spaces or 12. This commit fixes them all.
2022-08-03 19:48:46 +00:00
conf_get_int(prev_conf, CONF_vtmode) ||
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
conf_get_int(wgs->conf, CONF_bold_style) !=
Formatting: normalise back to 4-space indentation. In several pieces of development recently I've run across the occasional code block in the middle of a function which suddenly switched to 2-space indent from this code base's usual 4. I decided I was tired of it, so I ran the whole code base through a re-indenter, which made a huge mess, and then manually sifted out the changes that actually made sense from that pass. Indeed, this caught quite a few large sections with 2-space indent level, a couple with 8, and a handful of even weirder things like 3 spaces or 12. This commit fixes them all.
2022-08-03 19:48:46 +00:00
conf_get_int(prev_conf, CONF_bold_style) ||
resize_action == RESIZE_DISABLED ||
resize_action == RESIZE_EITHER ||
resize_action != conf_get_int(prev_conf,
CONF_resize_action))
init_lvl = 2;
Formatting change to braces around one case of a switch. Sometimes, within a switch statement, you want to declare local variables specific to the handler for one particular case. Until now I've mostly been writing this in the form switch (discriminant) { case SIMPLE: do stuff; break; case COMPLICATED: { declare variables; do stuff; } break; } which is ugly because the two pieces of essentially similar code appear at different indent levels, and also inconvenient because you have less horizontal space available to write the complicated case handler in - particuarly undesirable because _complicated_ case handlers are the ones most likely to need all the space they can get! After encountering a rather nicer idiom in the LLVM source code, and after a bit of hackery this morning figuring out how to persuade Emacs's auto-indent to do what I wanted with it, I've decided to move to an idiom in which the open brace comes right after the case statement, and the code within it is indented the same as it would have been without the brace. Then the whole case handler (including the break) lives inside those braces, and you get something that looks more like this: switch (discriminant) { case SIMPLE: do stuff; break; case COMPLICATED: { declare variables; do stuff; break; } } This commit is a big-bang change that reformats all the complicated case handlers I could find into the new layout. This is particularly nice in the Pageant main function, in which almost _every_ case handler had a bundle of variables and was long and complicated. (In fact that's what motivated me to get round to this.) Some of the innermost parts of the terminal escape-sequence handling are also breathing a bit easier now the horizontal pressure on them is relieved. (Also, in a few cases, I was able to remove the extra braces completely, because the only variable local to the case handler was a loop variable which our new C99 policy allows me to move into the initialiser clause of its for statement.) Viewed with whitespace ignored, this is not too disruptive a change. Downstream patches that conflict with it may need to be reapplied using --ignore-whitespace or similar.
2020-02-16 07:49:52 +00:00
}
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
Formatting change to braces around one case of a switch. Sometimes, within a switch statement, you want to declare local variables specific to the handler for one particular case. Until now I've mostly been writing this in the form switch (discriminant) { case SIMPLE: do stuff; break; case COMPLICATED: { declare variables; do stuff; } break; } which is ugly because the two pieces of essentially similar code appear at different indent levels, and also inconvenient because you have less horizontal space available to write the complicated case handler in - particuarly undesirable because _complicated_ case handlers are the ones most likely to need all the space they can get! After encountering a rather nicer idiom in the LLVM source code, and after a bit of hackery this morning figuring out how to persuade Emacs's auto-indent to do what I wanted with it, I've decided to move to an idiom in which the open brace comes right after the case statement, and the code within it is indented the same as it would have been without the brace. Then the whole case handler (including the break) lives inside those braces, and you get something that looks more like this: switch (discriminant) { case SIMPLE: do stuff; break; case COMPLICATED: { declare variables; do stuff; break; } } This commit is a big-bang change that reformats all the complicated case handlers I could find into the new layout. This is particularly nice in the Pageant main function, in which almost _every_ case handler had a bundle of variables and was long and complicated. (In fact that's what motivated me to get round to this.) Some of the innermost parts of the terminal escape-sequence handling are also breathing a bit easier now the horizontal pressure on them is relieved. (Also, in a few cases, I was able to remove the extra braces completely, because the only variable local to the case handler was a loop variable which our new C99 policy allows me to move into the initialiser clause of its for statement.) Viewed with whitespace ignored, this is not too disruptive a change. Downstream patches that conflict with it may need to be reapplied using --ignore-whitespace or similar.
2020-02-16 07:49:52 +00:00
InvalidateRect(hwnd, NULL, true);
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
reset_window(wgs, init_lvl);
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
Formatting change to braces around one case of a switch. Sometimes, within a switch statement, you want to declare local variables specific to the handler for one particular case. Until now I've mostly been writing this in the form switch (discriminant) { case SIMPLE: do stuff; break; case COMPLICATED: { declare variables; do stuff; } break; } which is ugly because the two pieces of essentially similar code appear at different indent levels, and also inconvenient because you have less horizontal space available to write the complicated case handler in - particuarly undesirable because _complicated_ case handlers are the ones most likely to need all the space they can get! After encountering a rather nicer idiom in the LLVM source code, and after a bit of hackery this morning figuring out how to persuade Emacs's auto-indent to do what I wanted with it, I've decided to move to an idiom in which the open brace comes right after the case statement, and the code within it is indented the same as it would have been without the brace. Then the whole case handler (including the break) lives inside those braces, and you get something that looks more like this: switch (discriminant) { case SIMPLE: do stuff; break; case COMPLICATED: { declare variables; do stuff; break; } } This commit is a big-bang change that reformats all the complicated case handlers I could find into the new layout. This is particularly nice in the Pageant main function, in which almost _every_ case handler had a bundle of variables and was long and complicated. (In fact that's what motivated me to get round to this.) Some of the innermost parts of the terminal escape-sequence handling are also breathing a bit easier now the horizontal pressure on them is relieved. (Also, in a few cases, I was able to remove the extra braces completely, because the only variable local to the case handler was a loop variable which our new C99 policy allows me to move into the initialiser clause of its for statement.) Viewed with whitespace ignored, this is not too disruptive a change. Downstream patches that conflict with it may need to be reapplied using --ignore-whitespace or similar.
2020-02-16 07:49:52 +00:00
conf_free(prev_conf);
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
break;
Formatting change to braces around one case of a switch. Sometimes, within a switch statement, you want to declare local variables specific to the handler for one particular case. Until now I've mostly been writing this in the form switch (discriminant) { case SIMPLE: do stuff; break; case COMPLICATED: { declare variables; do stuff; } break; } which is ugly because the two pieces of essentially similar code appear at different indent levels, and also inconvenient because you have less horizontal space available to write the complicated case handler in - particuarly undesirable because _complicated_ case handlers are the ones most likely to need all the space they can get! After encountering a rather nicer idiom in the LLVM source code, and after a bit of hackery this morning figuring out how to persuade Emacs's auto-indent to do what I wanted with it, I've decided to move to an idiom in which the open brace comes right after the case statement, and the code within it is indented the same as it would have been without the brace. Then the whole case handler (including the break) lives inside those braces, and you get something that looks more like this: switch (discriminant) { case SIMPLE: do stuff; break; case COMPLICATED: { declare variables; do stuff; break; } } This commit is a big-bang change that reformats all the complicated case handlers I could find into the new layout. This is particularly nice in the Pageant main function, in which almost _every_ case handler had a bundle of variables and was long and complicated. (In fact that's what motivated me to get round to this.) Some of the innermost parts of the terminal escape-sequence handling are also breathing a bit easier now the horizontal pressure on them is relieved. (Also, in a few cases, I was able to remove the extra braces completely, because the only variable local to the case handler was a loop variable which our new C99 policy allows me to move into the initialiser clause of its for statement.) Viewed with whitespace ignored, this is not too disruptive a change. Downstream patches that conflict with it may need to be reapplied using --ignore-whitespace or similar.
2020-02-16 07:49:52 +00:00
}
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
case IDM_COPYALL:
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
term_copyall(wgs->term, clips_system, lenof(clips_system));
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
break;
case IDM_COPY:
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
term_request_copy(wgs->term, clips_system, lenof(clips_system));
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
break;
case IDM_PASTE:
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
term_request_paste(wgs->term, CLIP_SYSTEM);
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
break;
case IDM_CLRSB:
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
term_clrsb(wgs->term);
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
break;
case IDM_RESET:
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
term_pwron(wgs->term, true);
if (wgs->ldisc)
ldisc_echoedit_update(wgs->ldisc);
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
break;
case IDM_ABOUT:
showabout(hwnd);
break;
case IDM_HELP:
launch_help(hwnd, NULL);
break;
case SC_MOUSEMENU:
/*
* We get this if the System menu has been activated
* using the mouse.
*/
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
show_mouseptr(wgs, true);
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
break;
Robert de Bath's `Patch.a_alt_key': clean up the handling of Alt-Space, Alt-only and the System menu. It lets Windows do more of the work, and also saves a static variable, so it must be good :-) [originally from svn r1237]
2001-09-07 21:39:03 +00:00
case SC_KEYMENU:
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
/*
* We get this if the System menu has been activated
* using the keyboard. This might happen from within
* TranslateKey, in which case it really wants to be
* followed by a `space' character to actually _bring
* the menu up_ rather than just sitting there in
* `ready to appear' state.
*/
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
show_mouseptr(wgs, true); /* make sure pointer is visible */
Formatting: normalise to put a space after condition keywords. 'if (thing)' is the local style here, not 'if(thing)'. Similarly with 'for' and 'while'.
2022-12-28 15:32:24 +00:00
if (lParam == 0)
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
PostMessage(hwnd, WM_CHAR, ' ', 0);
break;
case IDM_FULLSCREEN:
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
flip_full_screen(wgs);
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
break;
default:
if (wParam >= IDM_SAVED_MIN && wParam < IDM_SAVED_MAX) {
SendMessage(hwnd, WM_SYSCOMMAND, IDM_SAVEDSESS, wParam);
}
if (wParam >= IDM_SPECIAL_MIN && wParam <= IDM_SPECIAL_MAX) {
int i = (wParam - IDM_SPECIAL_MIN) / 0x10;
/*
* Ensure we haven't been sent a bogus SYSCOMMAND
* which would cause us to reference invalid memory
* and crash. Perhaps I'm just too paranoid here.
*/
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
if (i >= wgs->n_specials)
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
break;
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
if (wgs->backend)
backend_special(wgs->backend, wgs->specials[i].code,
wgs->specials[i].arg);
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
}
}
break;
John Sullivan's patches plus more fixes: - Stop using the identifier `environ' as some platforms make it a macro - Fix silly error box at end of connection in FWHACK mode - Fix GPF on maximise-then-restore - Use SetCapture to allow drag-selecting outside the window - Correctly update window title when iconic and in win_name_always mode [originally from svn r12]
1999-01-08 13:10:19 +00:00
#define X_POS(l) ((int)(short)LOWORD(l))
#define Y_POS(l) ((int)(short)HIWORD(l))
windows/window.c: move more variables into WinGuiSeat. In commit f9e572595bb8cb6 I claimed that I'd removed very nearly all the global and static variables from windows/window.c. It turns out that this was wildly overoptimistic - I missed quite a few of them! I'm not quite sure how I managed that; my best guess is that I used an underpowered 'nm' command that failed to find some classes of variable. Some of the remaining function-scope statics were removed completely by commit afb3dab1e97a09f just now. In this commit, I've swept up some more and turn them into fields of WinGuiSeat, where they should have been moved last September. The (hopefully complete this time) list of remaining variables, generated by running this rune in the Windows build directory: nm windows/CMakeFiles/putty.dir/window.c.obj | grep -E '^([^ ]+)? *[bBcCdDgGsS] [^\.]' consists of the following variables which are legitimately global across the whole process and not related to a particular window: - 'hinst' and 'hprev', instance handles for Windows loadable modules - 'classname' in the terminal_window_class_a() and terminal_window_class_w() functions, which allocate a window class reusably - some pointers to Windows API functions retrieved via the DECL_WINDOWS_FUNCTION / GET_WINDOWS_FUNCTION system, such as p_AdjustWindowRectExForDpi and p_FlashWindowEx - some pointers to Windows API functions set up by assigning them at startup to the right one of the ANSI or Unicode version depending on the Windows version, e.g. sw_DefWindowProc and sw_DispatchMessage - 'unicode_window', a boolean flag set at the same time as those sw_Foo function pointers - 'sesslist', storing the last-retrieved version of the saved sessions menu - 'cursor_visible' in show_mouseptr() and 'forced_visible' in update_mouse_pointer(), each of which tracks the cumulative number of times that function has shown or hidden the mouse pointer, so as to manage its effect on the global state updated by ShowCursor - 'trust_icon', loaded from the executable's resources - 'wgslisthead', the list of all active WinGuiSeats - 'wm_mousewheel', the window-message id we use for mouse wheel events and the following which are nothing to do with our code: - '_OptionsStorage' in __local_stdio_printf_options() and __local_stdio_scanf_options(), which I'd never noticed before, but apparently are internal to a standard library header.
2023-05-27 13:59:20 +00:00
#define TO_CHR_X(x) ((((x)<0 ? (x)-wgs->font_width+1 : \
(x))-wgs->offset_width) / wgs->font_width)
#define TO_CHR_Y(y) ((((y)<0 ? (y)-wgs->font_height+1 : \
(y))-wgs->offset_height) / wgs->font_height)
Initial checkin: beta 0.43 [originally from svn r11]
1999-01-08 13:02:13 +00:00
case WM_LBUTTONDOWN:
case WM_MBUTTONDOWN:
case WM_RBUTTONDOWN:
Wez Furlong's patch to add xterm mouse reporting and proper mouse wheel support. [originally from svn r1097]
2001-05-06 14:20:41 +00:00
case WM_LBUTTONUP:
case WM_MBUTTONUP:
Initial checkin: beta 0.43 [originally from svn r11]
1999-01-08 13:02:13 +00:00
case WM_RBUTTONUP:
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
if (message == WM_RBUTTONDOWN &&
((wParam & MK_CONTROL) ||
Cleanup: make an enum for the values of CONF_mouse_is_xterm. Again, there's no sensible reason why these should be written at the point of use as bare integers.
2023-05-29 14:52:32 +00:00
(conf_get_int(wgs->conf, CONF_mouse_is_xterm) == MOUSE_WINDOWS))) {
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
POINT cursorpos;
Cancel drag-select when the context menu pops up. I got a pterm into a stuck state this morning by an accidental mouse action. I'd intended to press Ctrl + right-click to pop up the context menu, but I accidentally pressed down the left button first, starting a selection drag, and then while the left button was still held down, pressed down the right button as well, triggering the menu. The effect was that the context menu appeared while term->selstate was set to DRAGGING, in which state terminal output is suppressed, and which is only unset by a mouse-button release event. But then that release event went to the popup menu, and the terminal window never got it. So the terminal stayed stuck forever - or rather, until I guessed the cause and did another selection drag to reset it. This happened to me on GTK, but once I knew how I'd done it, I found I could reproduce the same misbehaviour on Windows by the same method. Added a simplistic fix, on both platforms, that cancels a selection drag if the popup menu is summoned part way through it.
2022-03-29 17:05:11 +00:00
/* Just in case this happened in mid-select */
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
term_cancel_selection_drag(wgs->term);
Cancel drag-select when the context menu pops up. I got a pterm into a stuck state this morning by an accidental mouse action. I'd intended to press Ctrl + right-click to pop up the context menu, but I accidentally pressed down the left button first, starting a selection drag, and then while the left button was still held down, pressed down the right button as well, triggering the menu. The effect was that the context menu appeared while term->selstate was set to DRAGGING, in which state terminal output is suppressed, and which is only unset by a mouse-button release event. But then that release event went to the popup menu, and the terminal window never got it. So the terminal stayed stuck forever - or rather, until I guessed the cause and did another selection drag to reset it. This happened to me on GTK, but once I knew how I'd done it, I found I could reproduce the same misbehaviour on Windows by the same method. Added a simplistic fix, on both platforms, that cancels a selection drag if the popup menu is summoned part way through it.
2022-03-29 17:05:11 +00:00
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
show_mouseptr(wgs, true); /* make sure pointer is visible */
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
GetCursorPos(&cursorpos);
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
TrackPopupMenu(wgs->popup_menus[CTXMENU].menu,
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
TPM_LEFTALIGN | TPM_TOPALIGN | TPM_RIGHTBUTTON,
cursorpos.x, cursorpos.y,
0, hwnd, NULL);
break;
}
{
int button;
Convert a lot of 'int' variables to 'bool'. My normal habit these days, in new code, is to treat int and bool as _almost_ completely separate types. I'm still willing to use C's implicit test for zero on an integer (e.g. 'if (!blob.len)' is fine, no need to spell it out as blob.len != 0), but generally, if a variable is going to be conceptually a boolean, I like to declare it bool and assign to it using 'true' or 'false' rather than 0 or 1. PuTTY is an exception, because it predates the C99 bool, and I've stuck to its existing coding style even when adding new code to it. But it's been annoying me more and more, so now that I've decided C99 bool is an acceptable thing to require from our toolchain in the first place, here's a quite thorough trawl through the source doing 'boolification'. Many variables and function parameters are now typed as bool rather than int; many assignments of 0 or 1 to those variables are now spelled 'true' or 'false'. I managed this thorough conversion with the help of a custom clang plugin that I wrote to trawl the AST and apply heuristics to point out where things might want changing. So I've even managed to do a decent job on parts of the code I haven't looked at in years! To make the plugin's work easier, I pushed platform front ends generally in the direction of using standard 'bool' in preference to platform-specific boolean types like Windows BOOL or GTK's gboolean; I've left the platform booleans in places they _have_ to be for the platform APIs to work right, but variables only used by my own code have been converted wherever I found them. In a few places there are int values that look very like booleans in _most_ of the places they're used, but have a rarely-used third value, or a distinction between different nonzero values that most users don't care about. In these cases, I've _removed_ uses of 'true' and 'false' for the return values, to emphasise that there's something more subtle going on than a simple boolean answer: - the 'multisel' field in dialog.h's list box structure, for which the GTK front end in particular recognises a difference between 1 and 2 but nearly everything else treats as boolean - the 'urgent' parameter to plug_receive, where 1 vs 2 tells you something about the specific location of the urgent pointer, but most clients only care about 0 vs 'something nonzero' - the return value of wc_match, where -1 indicates a syntax error in the wildcard. - the return values from SSH-1 RSA-key loading functions, which use -1 for 'wrong passphrase' and 0 for all other failures (so any caller which already knows it's not loading an _encrypted private_ key can treat them as boolean) - term->esc_query, and the 'query' parameter in toggle_mode in terminal.c, which _usually_ hold 0 for ESC[123h or 1 for ESC[?123h, but can also hold -1 for some other intervening character that we don't support. In a few places there's an integer that I haven't turned into a bool even though it really _can_ only take values 0 or 1 (and, as above, tried to make the call sites consistent in not calling those values true and false), on the grounds that I thought it would make it more confusing to imply that the 0 value was in some sense 'negative' or bad and the 1 positive or good: - the return value of plug_accepting uses the POSIXish convention of 0=success and nonzero=error; I think if I made it bool then I'd also want to reverse its sense, and that's a job for a separate piece of work. - the 'screen' parameter to lineptr() in terminal.c, where 0 and 1 represent the default and alternate screens. There's no obvious reason why one of those should be considered 'true' or 'positive' or 'success' - they're just indices - so I've left it as int. ssh_scp_recv had particularly confusing semantics for its previous int return value: its call sites used '<= 0' to check for error, but it never actually returned a negative number, just 0 or 1. Now the function and its call sites agree that it's a bool. In a couple of places I've renamed variables called 'ret', because I don't like that name any more - it's unclear whether it means the return value (in preparation) for the _containing_ function or the return value received from a subroutine call, and occasionally I've accidentally used the same variable for both and introduced a bug. So where one of those got in my way, I've renamed it to 'toret' or 'retd' (the latter short for 'returned') in line with my usual modern practice, but I haven't done a thorough job of finding all of them. Finally, one amusing side effect of doing this is that I've had to separate quite a few chained assignments. It used to be perfectly fine to write 'a = b = c = TRUE' when a,b,c were int and TRUE was just a the 'true' defined by stdbool.h, that idiom provokes a warning from gcc: 'suggest parentheses around assignment used as truth value'!
2018-11-02 19:23:19 +00:00
bool press;
Rectangular-block selection. Enabled by Alt+drag, unless you configure it to be the default in which case it's _dis_abled by Alt+drag. [originally from svn r1350]
2001-10-31 18:50:09 +00:00
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
switch (message) {
case WM_LBUTTONDOWN:
button = MBT_LEFT;
wParam |= MK_LBUTTON;
press = true;
break;
case WM_MBUTTONDOWN:
button = MBT_MIDDLE;
wParam |= MK_MBUTTON;
press = true;
break;
case WM_RBUTTONDOWN:
button = MBT_RIGHT;
wParam |= MK_RBUTTON;
press = true;
break;
case WM_LBUTTONUP:
button = MBT_LEFT;
wParam &= ~MK_LBUTTON;
Convert a lot of 'int' variables to 'bool'. My normal habit these days, in new code, is to treat int and bool as _almost_ completely separate types. I'm still willing to use C's implicit test for zero on an integer (e.g. 'if (!blob.len)' is fine, no need to spell it out as blob.len != 0), but generally, if a variable is going to be conceptually a boolean, I like to declare it bool and assign to it using 'true' or 'false' rather than 0 or 1. PuTTY is an exception, because it predates the C99 bool, and I've stuck to its existing coding style even when adding new code to it. But it's been annoying me more and more, so now that I've decided C99 bool is an acceptable thing to require from our toolchain in the first place, here's a quite thorough trawl through the source doing 'boolification'. Many variables and function parameters are now typed as bool rather than int; many assignments of 0 or 1 to those variables are now spelled 'true' or 'false'. I managed this thorough conversion with the help of a custom clang plugin that I wrote to trawl the AST and apply heuristics to point out where things might want changing. So I've even managed to do a decent job on parts of the code I haven't looked at in years! To make the plugin's work easier, I pushed platform front ends generally in the direction of using standard 'bool' in preference to platform-specific boolean types like Windows BOOL or GTK's gboolean; I've left the platform booleans in places they _have_ to be for the platform APIs to work right, but variables only used by my own code have been converted wherever I found them. In a few places there are int values that look very like booleans in _most_ of the places they're used, but have a rarely-used third value, or a distinction between different nonzero values that most users don't care about. In these cases, I've _removed_ uses of 'true' and 'false' for the return values, to emphasise that there's something more subtle going on than a simple boolean answer: - the 'multisel' field in dialog.h's list box structure, for which the GTK front end in particular recognises a difference between 1 and 2 but nearly everything else treats as boolean - the 'urgent' parameter to plug_receive, where 1 vs 2 tells you something about the specific location of the urgent pointer, but most clients only care about 0 vs 'something nonzero' - the return value of wc_match, where -1 indicates a syntax error in the wildcard. - the return values from SSH-1 RSA-key loading functions, which use -1 for 'wrong passphrase' and 0 for all other failures (so any caller which already knows it's not loading an _encrypted private_ key can treat them as boolean) - term->esc_query, and the 'query' parameter in toggle_mode in terminal.c, which _usually_ hold 0 for ESC[123h or 1 for ESC[?123h, but can also hold -1 for some other intervening character that we don't support. In a few places there's an integer that I haven't turned into a bool even though it really _can_ only take values 0 or 1 (and, as above, tried to make the call sites consistent in not calling those values true and false), on the grounds that I thought it would make it more confusing to imply that the 0 value was in some sense 'negative' or bad and the 1 positive or good: - the return value of plug_accepting uses the POSIXish convention of 0=success and nonzero=error; I think if I made it bool then I'd also want to reverse its sense, and that's a job for a separate piece of work. - the 'screen' parameter to lineptr() in terminal.c, where 0 and 1 represent the default and alternate screens. There's no obvious reason why one of those should be considered 'true' or 'positive' or 'success' - they're just indices - so I've left it as int. ssh_scp_recv had particularly confusing semantics for its previous int return value: its call sites used '<= 0' to check for error, but it never actually returned a negative number, just 0 or 1. Now the function and its call sites agree that it's a bool. In a couple of places I've renamed variables called 'ret', because I don't like that name any more - it's unclear whether it means the return value (in preparation) for the _containing_ function or the return value received from a subroutine call, and occasionally I've accidentally used the same variable for both and introduced a bug. So where one of those got in my way, I've renamed it to 'toret' or 'retd' (the latter short for 'returned') in line with my usual modern practice, but I haven't done a thorough job of finding all of them. Finally, one amusing side effect of doing this is that I've had to separate quite a few chained assignments. It used to be perfectly fine to write 'a = b = c = TRUE' when a,b,c were int and TRUE was just a the 'true' defined by stdbool.h, that idiom provokes a warning from gcc: 'suggest parentheses around assignment used as truth value'!
2018-11-02 19:23:19 +00:00
press = false;
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
break;
case WM_MBUTTONUP:
button = MBT_MIDDLE;
wParam &= ~MK_MBUTTON;
press = false;
break;
case WM_RBUTTONUP:
button = MBT_RIGHT;
wParam &= ~MK_RBUTTON;
press = false;
break;
default: /* shouldn't happen */
button = 0;
press = false;
}
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
show_mouseptr(wgs, true);
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
/*
* Special case: in full-screen mode, if the left
* button is clicked in the very top left corner of the
* window, we put up the System menu instead of doing
* selection.
*/
{
bool mouse_on_hotspot = false;
POINT pt;
GetCursorPos(&pt);
Josh Hill's patch for full-screen mode on a multi-monitor system: clicks in the top left of the window should not be detected by comparing the coordinates with (0,0) since this won't work on secondary monitors. [originally from svn r3742]
2004-01-20 19:41:43 +00:00
#ifndef NO_MULTIMON
Remove hard dependencies on multi-monitor functions. These are more functions that don't exist on all our supported legacy versions of Windows, so we need to follow the same policy as everywhere else, by trying to acquire them at run time and having a fallback if they aren't available.
2022-03-11 18:32:26 +00:00
if (p_GetMonitorInfoA && p_MonitorFromPoint) {
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
HMONITOR mon;
MONITORINFO mi;
Remove hard dependencies on multi-monitor functions. These are more functions that don't exist on all our supported legacy versions of Windows, so we need to follow the same policy as everywhere else, by trying to acquire them at run time and having a fallback if they aren't available.
2022-03-11 18:32:26 +00:00
mon = p_MonitorFromPoint(pt, MONITOR_DEFAULTTONULL);
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
if (mon != NULL) {
mi.cbSize = sizeof(MONITORINFO);
Remove hard dependencies on multi-monitor functions. These are more functions that don't exist on all our supported legacy versions of Windows, so we need to follow the same policy as everywhere else, by trying to acquire them at run time and having a fallback if they aren't available.
2022-03-11 18:32:26 +00:00
p_GetMonitorInfoA(mon, &mi);
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
if (mi.rcMonitor.left == pt.x &&
mi.rcMonitor.top == pt.y) {
mouse_on_hotspot = true;
}
}
Remove hard dependencies on multi-monitor functions. These are more functions that don't exist on all our supported legacy versions of Windows, so we need to follow the same policy as everywhere else, by trying to acquire them at run time and having a fallback if they aren't available.
2022-03-11 18:32:26 +00:00
} else
#endif
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
if (pt.x == 0 && pt.y == 0) {
mouse_on_hotspot = true;
}
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
if (is_full_screen(wgs) && press &&
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
button == MBT_LEFT && mouse_on_hotspot) {
SendMessage(hwnd, WM_SYSCOMMAND, SC_MOUSEMENU,
MAKELPARAM(pt.x, pt.y));
return 0;
}
}
if (press) {
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
click(wgs, button,
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
TO_CHR_X(X_POS(lParam)), TO_CHR_Y(Y_POS(lParam)),
wParam & MK_SHIFT, wParam & MK_CONTROL,
is_alt_pressed());
SetCapture(hwnd);
} else {
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
term_mouse(wgs->term, button, translate_button(wgs, button),
MA_RELEASE, TO_CHR_X(X_POS(lParam)),
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
TO_CHR_Y(Y_POS(lParam)), wParam & MK_SHIFT,
wParam & MK_CONTROL, is_alt_pressed());
if (!(wParam & (MK_LBUTTON | MK_MBUTTON | MK_RBUTTON)))
ReleaseCapture();
}
}
return 0;
windows/window.c: move more variables into WinGuiSeat. In commit f9e572595bb8cb6 I claimed that I'd removed very nearly all the global and static variables from windows/window.c. It turns out that this was wildly overoptimistic - I missed quite a few of them! I'm not quite sure how I managed that; my best guess is that I used an underpowered 'nm' command that failed to find some classes of variable. Some of the remaining function-scope statics were removed completely by commit afb3dab1e97a09f just now. In this commit, I've swept up some more and turn them into fields of WinGuiSeat, where they should have been moved last September. The (hopefully complete this time) list of remaining variables, generated by running this rune in the Windows build directory: nm windows/CMakeFiles/putty.dir/window.c.obj | grep -E '^([^ ]+)? *[bBcCdDgGsS] [^\.]' consists of the following variables which are legitimately global across the whole process and not related to a particular window: - 'hinst' and 'hprev', instance handles for Windows loadable modules - 'classname' in the terminal_window_class_a() and terminal_window_class_w() functions, which allocate a window class reusably - some pointers to Windows API functions retrieved via the DECL_WINDOWS_FUNCTION / GET_WINDOWS_FUNCTION system, such as p_AdjustWindowRectExForDpi and p_FlashWindowEx - some pointers to Windows API functions set up by assigning them at startup to the right one of the ANSI or Unicode version depending on the Windows version, e.g. sw_DefWindowProc and sw_DispatchMessage - 'unicode_window', a boolean flag set at the same time as those sw_Foo function pointers - 'sesslist', storing the last-retrieved version of the saved sessions menu - 'cursor_visible' in show_mouseptr() and 'forced_visible' in update_mouse_pointer(), each of which tracks the cumulative number of times that function has shown or hidden the mouse pointer, so as to manage its effect on the global state updated by ShowCursor - 'trust_icon', loaded from the executable's resources - 'wgslisthead', the list of all active WinGuiSeats - 'wm_mousewheel', the window-message id we use for mouse wheel events and the following which are nothing to do with our code: - '_OptionsStorage' in __local_stdio_printf_options() and __local_stdio_scanf_options(), which I'd never noticed before, but apparently are internal to a standard library header.
2023-05-27 13:59:20 +00:00
case WM_MOUSEMOVE:
Formatting change to braces around one case of a switch. Sometimes, within a switch statement, you want to declare local variables specific to the handler for one particular case. Until now I've mostly been writing this in the form switch (discriminant) { case SIMPLE: do stuff; break; case COMPLICATED: { declare variables; do stuff; } break; } which is ugly because the two pieces of essentially similar code appear at different indent levels, and also inconvenient because you have less horizontal space available to write the complicated case handler in - particuarly undesirable because _complicated_ case handlers are the ones most likely to need all the space they can get! After encountering a rather nicer idiom in the LLVM source code, and after a bit of hackery this morning figuring out how to persuade Emacs's auto-indent to do what I wanted with it, I've decided to move to an idiom in which the open brace comes right after the case statement, and the code within it is indented the same as it would have been without the brace. Then the whole case handler (including the break) lives inside those braces, and you get something that looks more like this: switch (discriminant) { case SIMPLE: do stuff; break; case COMPLICATED: { declare variables; do stuff; break; } } This commit is a big-bang change that reformats all the complicated case handlers I could find into the new layout. This is particularly nice in the Pageant main function, in which almost _every_ case handler had a bundle of variables and was long and complicated. (In fact that's what motivated me to get round to this.) Some of the innermost parts of the terminal escape-sequence handling are also breathing a bit easier now the horizontal pressure on them is relieved. (Also, in a few cases, I was able to remove the extra braces completely, because the only variable local to the case handler was a loop variable which our new C99 policy allows me to move into the initialiser clause of its for statement.) Viewed with whitespace ignored, this is not too disruptive a change. Downstream patches that conflict with it may need to be reapplied using --ignore-whitespace or similar.
2020-02-16 07:49:52 +00:00
/*
* Windows seems to like to occasionally send MOUSEMOVE
* events even if the mouse hasn't moved. Don't unhide
* the mouse pointer in this case.
*/
windows/window.c: move more variables into WinGuiSeat. In commit f9e572595bb8cb6 I claimed that I'd removed very nearly all the global and static variables from windows/window.c. It turns out that this was wildly overoptimistic - I missed quite a few of them! I'm not quite sure how I managed that; my best guess is that I used an underpowered 'nm' command that failed to find some classes of variable. Some of the remaining function-scope statics were removed completely by commit afb3dab1e97a09f just now. In this commit, I've swept up some more and turn them into fields of WinGuiSeat, where they should have been moved last September. The (hopefully complete this time) list of remaining variables, generated by running this rune in the Windows build directory: nm windows/CMakeFiles/putty.dir/window.c.obj | grep -E '^([^ ]+)? *[bBcCdDgGsS] [^\.]' consists of the following variables which are legitimately global across the whole process and not related to a particular window: - 'hinst' and 'hprev', instance handles for Windows loadable modules - 'classname' in the terminal_window_class_a() and terminal_window_class_w() functions, which allocate a window class reusably - some pointers to Windows API functions retrieved via the DECL_WINDOWS_FUNCTION / GET_WINDOWS_FUNCTION system, such as p_AdjustWindowRectExForDpi and p_FlashWindowEx - some pointers to Windows API functions set up by assigning them at startup to the right one of the ANSI or Unicode version depending on the Windows version, e.g. sw_DefWindowProc and sw_DispatchMessage - 'unicode_window', a boolean flag set at the same time as those sw_Foo function pointers - 'sesslist', storing the last-retrieved version of the saved sessions menu - 'cursor_visible' in show_mouseptr() and 'forced_visible' in update_mouse_pointer(), each of which tracks the cumulative number of times that function has shown or hidden the mouse pointer, so as to manage its effect on the global state updated by ShowCursor - 'trust_icon', loaded from the executable's resources - 'wgslisthead', the list of all active WinGuiSeats - 'wm_mousewheel', the window-message id we use for mouse wheel events and the following which are nothing to do with our code: - '_OptionsStorage' in __local_stdio_printf_options() and __local_stdio_scanf_options(), which I'd never noticed before, but apparently are internal to a standard library header.
2023-05-27 13:59:20 +00:00
if (wgs->last_mousemove != WM_MOUSEMOVE ||
wParam != wgs->last_wm_mousemove_wParam ||
lParam != wgs->last_wm_mousemove_lParam) {
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
show_mouseptr(wgs, true);
windows/window.c: move more variables into WinGuiSeat. In commit f9e572595bb8cb6 I claimed that I'd removed very nearly all the global and static variables from windows/window.c. It turns out that this was wildly overoptimistic - I missed quite a few of them! I'm not quite sure how I managed that; my best guess is that I used an underpowered 'nm' command that failed to find some classes of variable. Some of the remaining function-scope statics were removed completely by commit afb3dab1e97a09f just now. In this commit, I've swept up some more and turn them into fields of WinGuiSeat, where they should have been moved last September. The (hopefully complete this time) list of remaining variables, generated by running this rune in the Windows build directory: nm windows/CMakeFiles/putty.dir/window.c.obj | grep -E '^([^ ]+)? *[bBcCdDgGsS] [^\.]' consists of the following variables which are legitimately global across the whole process and not related to a particular window: - 'hinst' and 'hprev', instance handles for Windows loadable modules - 'classname' in the terminal_window_class_a() and terminal_window_class_w() functions, which allocate a window class reusably - some pointers to Windows API functions retrieved via the DECL_WINDOWS_FUNCTION / GET_WINDOWS_FUNCTION system, such as p_AdjustWindowRectExForDpi and p_FlashWindowEx - some pointers to Windows API functions set up by assigning them at startup to the right one of the ANSI or Unicode version depending on the Windows version, e.g. sw_DefWindowProc and sw_DispatchMessage - 'unicode_window', a boolean flag set at the same time as those sw_Foo function pointers - 'sesslist', storing the last-retrieved version of the saved sessions menu - 'cursor_visible' in show_mouseptr() and 'forced_visible' in update_mouse_pointer(), each of which tracks the cumulative number of times that function has shown or hidden the mouse pointer, so as to manage its effect on the global state updated by ShowCursor - 'trust_icon', loaded from the executable's resources - 'wgslisthead', the list of all active WinGuiSeats - 'wm_mousewheel', the window-message id we use for mouse wheel events and the following which are nothing to do with our code: - '_OptionsStorage' in __local_stdio_printf_options() and __local_stdio_scanf_options(), which I'd never noticed before, but apparently are internal to a standard library header.
2023-05-27 13:59:20 +00:00
wgs->last_mousemove = WM_MOUSEMOVE;
wgs->last_wm_mousemove_wParam = wParam;
wgs->last_wm_mousemove_lParam = lParam;
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
}
/*
* Add the mouse position and message time to the random
* number noise.
*/
noise_ultralight(NOISE_SOURCE_MOUSEPOS, lParam);
if (wParam & (MK_LBUTTON | MK_MBUTTON | MK_RBUTTON) &&
GetCapture() == hwnd) {
Mouse_Button b;
if (wParam & MK_LBUTTON)
b = MBT_LEFT;
else if (wParam & MK_MBUTTON)
b = MBT_MIDDLE;
else
b = MBT_RIGHT;
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
term_mouse(wgs->term, b, translate_button(wgs, b), MA_DRAG,
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
TO_CHR_X(X_POS(lParam)),
TO_CHR_Y(Y_POS(lParam)), wParam & MK_SHIFT,
wParam & MK_CONTROL, is_alt_pressed());
Support xterm any-event mouse tracking From https://invisible-island.net/xterm/ctlseqs/ctlseqs.html#h3-Any-event-tracking: Any-event mode is the same as button-event mode, except that all motion events are reported, even if no mouse button is down. It is enabled by specifying 1003 to DECSET. Normally the front ends only report mouse events when buttons are pressed, so we introduce a MA_MOVE event with MBT_NOTHING set to indicate such a mouse movement.
2019-12-20 13:56:58 +00:00
} else {
term_mouse(wgs->term, MBT_NOTHING, MBT_NOTHING, MA_MOVE,
TO_CHR_X(X_POS(lParam)),
TO_CHR_Y(Y_POS(lParam)), false,
false, false);
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
}
return 0;
windows/window.c: move more variables into WinGuiSeat. In commit f9e572595bb8cb6 I claimed that I'd removed very nearly all the global and static variables from windows/window.c. It turns out that this was wildly overoptimistic - I missed quite a few of them! I'm not quite sure how I managed that; my best guess is that I used an underpowered 'nm' command that failed to find some classes of variable. Some of the remaining function-scope statics were removed completely by commit afb3dab1e97a09f just now. In this commit, I've swept up some more and turn them into fields of WinGuiSeat, where they should have been moved last September. The (hopefully complete this time) list of remaining variables, generated by running this rune in the Windows build directory: nm windows/CMakeFiles/putty.dir/window.c.obj | grep -E '^([^ ]+)? *[bBcCdDgGsS] [^\.]' consists of the following variables which are legitimately global across the whole process and not related to a particular window: - 'hinst' and 'hprev', instance handles for Windows loadable modules - 'classname' in the terminal_window_class_a() and terminal_window_class_w() functions, which allocate a window class reusably - some pointers to Windows API functions retrieved via the DECL_WINDOWS_FUNCTION / GET_WINDOWS_FUNCTION system, such as p_AdjustWindowRectExForDpi and p_FlashWindowEx - some pointers to Windows API functions set up by assigning them at startup to the right one of the ANSI or Unicode version depending on the Windows version, e.g. sw_DefWindowProc and sw_DispatchMessage - 'unicode_window', a boolean flag set at the same time as those sw_Foo function pointers - 'sesslist', storing the last-retrieved version of the saved sessions menu - 'cursor_visible' in show_mouseptr() and 'forced_visible' in update_mouse_pointer(), each of which tracks the cumulative number of times that function has shown or hidden the mouse pointer, so as to manage its effect on the global state updated by ShowCursor - 'trust_icon', loaded from the executable's resources - 'wgslisthead', the list of all active WinGuiSeats - 'wm_mousewheel', the window-message id we use for mouse wheel events and the following which are nothing to do with our code: - '_OptionsStorage' in __local_stdio_printf_options() and __local_stdio_scanf_options(), which I'd never noticed before, but apparently are internal to a standard library header.
2023-05-27 13:59:20 +00:00
case WM_NCMOUSEMOVE:
if (wgs->last_mousemove != WM_NCMOUSEMOVE ||
wParam != wgs->last_wm_ncmousemove_wParam ||
lParam != wgs->last_wm_ncmousemove_lParam) {
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
show_mouseptr(wgs, true);
windows/window.c: move more variables into WinGuiSeat. In commit f9e572595bb8cb6 I claimed that I'd removed very nearly all the global and static variables from windows/window.c. It turns out that this was wildly overoptimistic - I missed quite a few of them! I'm not quite sure how I managed that; my best guess is that I used an underpowered 'nm' command that failed to find some classes of variable. Some of the remaining function-scope statics were removed completely by commit afb3dab1e97a09f just now. In this commit, I've swept up some more and turn them into fields of WinGuiSeat, where they should have been moved last September. The (hopefully complete this time) list of remaining variables, generated by running this rune in the Windows build directory: nm windows/CMakeFiles/putty.dir/window.c.obj | grep -E '^([^ ]+)? *[bBcCdDgGsS] [^\.]' consists of the following variables which are legitimately global across the whole process and not related to a particular window: - 'hinst' and 'hprev', instance handles for Windows loadable modules - 'classname' in the terminal_window_class_a() and terminal_window_class_w() functions, which allocate a window class reusably - some pointers to Windows API functions retrieved via the DECL_WINDOWS_FUNCTION / GET_WINDOWS_FUNCTION system, such as p_AdjustWindowRectExForDpi and p_FlashWindowEx - some pointers to Windows API functions set up by assigning them at startup to the right one of the ANSI or Unicode version depending on the Windows version, e.g. sw_DefWindowProc and sw_DispatchMessage - 'unicode_window', a boolean flag set at the same time as those sw_Foo function pointers - 'sesslist', storing the last-retrieved version of the saved sessions menu - 'cursor_visible' in show_mouseptr() and 'forced_visible' in update_mouse_pointer(), each of which tracks the cumulative number of times that function has shown or hidden the mouse pointer, so as to manage its effect on the global state updated by ShowCursor - 'trust_icon', loaded from the executable's resources - 'wgslisthead', the list of all active WinGuiSeats - 'wm_mousewheel', the window-message id we use for mouse wheel events and the following which are nothing to do with our code: - '_OptionsStorage' in __local_stdio_printf_options() and __local_stdio_scanf_options(), which I'd never noticed before, but apparently are internal to a standard library header.
2023-05-27 13:59:20 +00:00
wgs->last_mousemove = WM_NCMOUSEMOVE;
wgs->last_wm_ncmousemove_wParam = wParam;
wgs->last_wm_ncmousemove_lParam = lParam;
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
}
noise_ultralight(NOISE_SOURCE_MOUSEPOS, lParam);
break;
Initial checkin: beta 0.43 [originally from svn r11]
1999-01-08 13:02:13 +00:00
case WM_IGNORE_CLIP:
windows/window.c: move more variables into WinGuiSeat. In commit f9e572595bb8cb6 I claimed that I'd removed very nearly all the global and static variables from windows/window.c. It turns out that this was wildly overoptimistic - I missed quite a few of them! I'm not quite sure how I managed that; my best guess is that I used an underpowered 'nm' command that failed to find some classes of variable. Some of the remaining function-scope statics were removed completely by commit afb3dab1e97a09f just now. In this commit, I've swept up some more and turn them into fields of WinGuiSeat, where they should have been moved last September. The (hopefully complete this time) list of remaining variables, generated by running this rune in the Windows build directory: nm windows/CMakeFiles/putty.dir/window.c.obj | grep -E '^([^ ]+)? *[bBcCdDgGsS] [^\.]' consists of the following variables which are legitimately global across the whole process and not related to a particular window: - 'hinst' and 'hprev', instance handles for Windows loadable modules - 'classname' in the terminal_window_class_a() and terminal_window_class_w() functions, which allocate a window class reusably - some pointers to Windows API functions retrieved via the DECL_WINDOWS_FUNCTION / GET_WINDOWS_FUNCTION system, such as p_AdjustWindowRectExForDpi and p_FlashWindowEx - some pointers to Windows API functions set up by assigning them at startup to the right one of the ANSI or Unicode version depending on the Windows version, e.g. sw_DefWindowProc and sw_DispatchMessage - 'unicode_window', a boolean flag set at the same time as those sw_Foo function pointers - 'sesslist', storing the last-retrieved version of the saved sessions menu - 'cursor_visible' in show_mouseptr() and 'forced_visible' in update_mouse_pointer(), each of which tracks the cumulative number of times that function has shown or hidden the mouse pointer, so as to manage its effect on the global state updated by ShowCursor - 'trust_icon', loaded from the executable's resources - 'wgslisthead', the list of all active WinGuiSeats - 'wm_mousewheel', the window-message id we use for mouse wheel events and the following which are nothing to do with our code: - '_OptionsStorage' in __local_stdio_printf_options() and __local_stdio_scanf_options(), which I'd never noticed before, but apparently are internal to a standard library header.
2023-05-27 13:59:20 +00:00
wgs->ignore_clip = wParam; /* don't panic on DESTROYCLIPBOARD */
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
break;
Initial checkin: beta 0.43 [originally from svn r11]
1999-01-08 13:02:13 +00:00
case WM_DESTROYCLIPBOARD:
windows/window.c: move more variables into WinGuiSeat. In commit f9e572595bb8cb6 I claimed that I'd removed very nearly all the global and static variables from windows/window.c. It turns out that this was wildly overoptimistic - I missed quite a few of them! I'm not quite sure how I managed that; my best guess is that I used an underpowered 'nm' command that failed to find some classes of variable. Some of the remaining function-scope statics were removed completely by commit afb3dab1e97a09f just now. In this commit, I've swept up some more and turn them into fields of WinGuiSeat, where they should have been moved last September. The (hopefully complete this time) list of remaining variables, generated by running this rune in the Windows build directory: nm windows/CMakeFiles/putty.dir/window.c.obj | grep -E '^([^ ]+)? *[bBcCdDgGsS] [^\.]' consists of the following variables which are legitimately global across the whole process and not related to a particular window: - 'hinst' and 'hprev', instance handles for Windows loadable modules - 'classname' in the terminal_window_class_a() and terminal_window_class_w() functions, which allocate a window class reusably - some pointers to Windows API functions retrieved via the DECL_WINDOWS_FUNCTION / GET_WINDOWS_FUNCTION system, such as p_AdjustWindowRectExForDpi and p_FlashWindowEx - some pointers to Windows API functions set up by assigning them at startup to the right one of the ANSI or Unicode version depending on the Windows version, e.g. sw_DefWindowProc and sw_DispatchMessage - 'unicode_window', a boolean flag set at the same time as those sw_Foo function pointers - 'sesslist', storing the last-retrieved version of the saved sessions menu - 'cursor_visible' in show_mouseptr() and 'forced_visible' in update_mouse_pointer(), each of which tracks the cumulative number of times that function has shown or hidden the mouse pointer, so as to manage its effect on the global state updated by ShowCursor - 'trust_icon', loaded from the executable's resources - 'wgslisthead', the list of all active WinGuiSeats - 'wm_mousewheel', the window-message id we use for mouse wheel events and the following which are nothing to do with our code: - '_OptionsStorage' in __local_stdio_printf_options() and __local_stdio_scanf_options(), which I'd never noticed before, but apparently are internal to a standard library header.
2023-05-27 13:59:20 +00:00
if (!wgs->ignore_clip)
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
term_lost_clipboard_ownership(wgs->term, CLIP_SYSTEM);
windows/window.c: move more variables into WinGuiSeat. In commit f9e572595bb8cb6 I claimed that I'd removed very nearly all the global and static variables from windows/window.c. It turns out that this was wildly overoptimistic - I missed quite a few of them! I'm not quite sure how I managed that; my best guess is that I used an underpowered 'nm' command that failed to find some classes of variable. Some of the remaining function-scope statics were removed completely by commit afb3dab1e97a09f just now. In this commit, I've swept up some more and turn them into fields of WinGuiSeat, where they should have been moved last September. The (hopefully complete this time) list of remaining variables, generated by running this rune in the Windows build directory: nm windows/CMakeFiles/putty.dir/window.c.obj | grep -E '^([^ ]+)? *[bBcCdDgGsS] [^\.]' consists of the following variables which are legitimately global across the whole process and not related to a particular window: - 'hinst' and 'hprev', instance handles for Windows loadable modules - 'classname' in the terminal_window_class_a() and terminal_window_class_w() functions, which allocate a window class reusably - some pointers to Windows API functions retrieved via the DECL_WINDOWS_FUNCTION / GET_WINDOWS_FUNCTION system, such as p_AdjustWindowRectExForDpi and p_FlashWindowEx - some pointers to Windows API functions set up by assigning them at startup to the right one of the ANSI or Unicode version depending on the Windows version, e.g. sw_DefWindowProc and sw_DispatchMessage - 'unicode_window', a boolean flag set at the same time as those sw_Foo function pointers - 'sesslist', storing the last-retrieved version of the saved sessions menu - 'cursor_visible' in show_mouseptr() and 'forced_visible' in update_mouse_pointer(), each of which tracks the cumulative number of times that function has shown or hidden the mouse pointer, so as to manage its effect on the global state updated by ShowCursor - 'trust_icon', loaded from the executable's resources - 'wgslisthead', the list of all active WinGuiSeats - 'wm_mousewheel', the window-message id we use for mouse wheel events and the following which are nothing to do with our code: - '_OptionsStorage' in __local_stdio_printf_options() and __local_stdio_scanf_options(), which I'd never noticed before, but apparently are internal to a standard library header.
2023-05-27 13:59:20 +00:00
wgs->ignore_clip = false;
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
return 0;
Formatting change to braces around one case of a switch. Sometimes, within a switch statement, you want to declare local variables specific to the handler for one particular case. Until now I've mostly been writing this in the form switch (discriminant) { case SIMPLE: do stuff; break; case COMPLICATED: { declare variables; do stuff; } break; } which is ugly because the two pieces of essentially similar code appear at different indent levels, and also inconvenient because you have less horizontal space available to write the complicated case handler in - particuarly undesirable because _complicated_ case handlers are the ones most likely to need all the space they can get! After encountering a rather nicer idiom in the LLVM source code, and after a bit of hackery this morning figuring out how to persuade Emacs's auto-indent to do what I wanted with it, I've decided to move to an idiom in which the open brace comes right after the case statement, and the code within it is indented the same as it would have been without the brace. Then the whole case handler (including the break) lives inside those braces, and you get something that looks more like this: switch (discriminant) { case SIMPLE: do stuff; break; case COMPLICATED: { declare variables; do stuff; break; } } This commit is a big-bang change that reformats all the complicated case handlers I could find into the new layout. This is particularly nice in the Pageant main function, in which almost _every_ case handler had a bundle of variables and was long and complicated. (In fact that's what motivated me to get round to this.) Some of the innermost parts of the terminal escape-sequence handling are also breathing a bit easier now the horizontal pressure on them is relieved. (Also, in a few cases, I was able to remove the extra braces completely, because the only variable local to the case handler was a loop variable which our new C99 policy allows me to move into the initialiser clause of its for statement.) Viewed with whitespace ignored, this is not too disruptive a change. Downstream patches that conflict with it may need to be reapplied using --ignore-whitespace or similar.
2020-02-16 07:49:52 +00:00
case WM_PAINT: {
PAINTSTRUCT p;
HideCaret(hwnd);
hdc = BeginPaint(hwnd, &p);
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
if (wgs->pal) {
SelectPalette(hdc, wgs->pal, true);
Formatting: normalise back to 4-space indentation. In several pieces of development recently I've run across the occasional code block in the middle of a function which suddenly switched to 2-space indent from this code base's usual 4. I decided I was tired of it, so I ran the whole code base through a re-indenter, which made a huge mess, and then manually sifted out the changes that actually made sense from that pass. Indeed, this caught quite a few large sections with 2-space indent level, a couple with 8, and a handful of even weirder things like 3 spaces or 12. This commit fixes them all.
2022-08-03 19:48:46 +00:00
RealizePalette(hdc);
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
}
Formatting change to braces around one case of a switch. Sometimes, within a switch statement, you want to declare local variables specific to the handler for one particular case. Until now I've mostly been writing this in the form switch (discriminant) { case SIMPLE: do stuff; break; case COMPLICATED: { declare variables; do stuff; } break; } which is ugly because the two pieces of essentially similar code appear at different indent levels, and also inconvenient because you have less horizontal space available to write the complicated case handler in - particuarly undesirable because _complicated_ case handlers are the ones most likely to need all the space they can get! After encountering a rather nicer idiom in the LLVM source code, and after a bit of hackery this morning figuring out how to persuade Emacs's auto-indent to do what I wanted with it, I've decided to move to an idiom in which the open brace comes right after the case statement, and the code within it is indented the same as it would have been without the brace. Then the whole case handler (including the break) lives inside those braces, and you get something that looks more like this: switch (discriminant) { case SIMPLE: do stuff; break; case COMPLICATED: { declare variables; do stuff; break; } } This commit is a big-bang change that reformats all the complicated case handlers I could find into the new layout. This is particularly nice in the Pageant main function, in which almost _every_ case handler had a bundle of variables and was long and complicated. (In fact that's what motivated me to get round to this.) Some of the innermost parts of the terminal escape-sequence handling are also breathing a bit easier now the horizontal pressure on them is relieved. (Also, in a few cases, I was able to remove the extra braces completely, because the only variable local to the case handler was a loop variable which our new C99 policy allows me to move into the initialiser clause of its for statement.) Viewed with whitespace ignored, this is not too disruptive a change. Downstream patches that conflict with it may need to be reapplied using --ignore-whitespace or similar.
2020-02-16 07:49:52 +00:00
/*
* We have to be careful about term_paint(). It will
* set a bunch of character cells to INVALID and then
* call do_paint(), which will redraw those cells and
* _then mark them as done_. This may not be accurate:
* when painting in WM_PAINT context we are restricted
* to the rectangle which has just been exposed - so if
* that only covers _part_ of a character cell and the
* rest of it was already visible, that remainder will
* not be redrawn at all. Accordingly, we must not
* paint any character cell in a WM_PAINT context which
* already has a pending update due to terminal output.
* The simplest solution to this - and many, many
* thanks to Hung-Te Lin for working all this out - is
* not to do any actual painting at _all_ if there's a
* pending terminal update: just mark the relevant
* character cells as INVALID and wait for the
* scheduled full update to sort it out.
*
* I have a suspicion this isn't the _right_ solution.
* An alternative approach would be to have terminal.c
* separately track what _should_ be on the terminal
* screen and what _is_ on the terminal screen, and
* have two completely different types of redraw (one
* for full updates, which syncs the former with the
* terminal itself, and one for WM_PAINT which syncs
* the latter with the former); yet another possibility
* would be to have the Windows front end do what the
* GTK one already does, and maintain a bitmap of the
* current terminal appearance so that WM_PAINT becomes
* completely trivial. However, this should do for now.
*/
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
assert(!wgs->wintw_hdc);
wgs->wintw_hdc = hdc;
term_paint(wgs->term,
windows/window.c: move more variables into WinGuiSeat. In commit f9e572595bb8cb6 I claimed that I'd removed very nearly all the global and static variables from windows/window.c. It turns out that this was wildly overoptimistic - I missed quite a few of them! I'm not quite sure how I managed that; my best guess is that I used an underpowered 'nm' command that failed to find some classes of variable. Some of the remaining function-scope statics were removed completely by commit afb3dab1e97a09f just now. In this commit, I've swept up some more and turn them into fields of WinGuiSeat, where they should have been moved last September. The (hopefully complete this time) list of remaining variables, generated by running this rune in the Windows build directory: nm windows/CMakeFiles/putty.dir/window.c.obj | grep -E '^([^ ]+)? *[bBcCdDgGsS] [^\.]' consists of the following variables which are legitimately global across the whole process and not related to a particular window: - 'hinst' and 'hprev', instance handles for Windows loadable modules - 'classname' in the terminal_window_class_a() and terminal_window_class_w() functions, which allocate a window class reusably - some pointers to Windows API functions retrieved via the DECL_WINDOWS_FUNCTION / GET_WINDOWS_FUNCTION system, such as p_AdjustWindowRectExForDpi and p_FlashWindowEx - some pointers to Windows API functions set up by assigning them at startup to the right one of the ANSI or Unicode version depending on the Windows version, e.g. sw_DefWindowProc and sw_DispatchMessage - 'unicode_window', a boolean flag set at the same time as those sw_Foo function pointers - 'sesslist', storing the last-retrieved version of the saved sessions menu - 'cursor_visible' in show_mouseptr() and 'forced_visible' in update_mouse_pointer(), each of which tracks the cumulative number of times that function has shown or hidden the mouse pointer, so as to manage its effect on the global state updated by ShowCursor - 'trust_icon', loaded from the executable's resources - 'wgslisthead', the list of all active WinGuiSeats - 'wm_mousewheel', the window-message id we use for mouse wheel events and the following which are nothing to do with our code: - '_OptionsStorage' in __local_stdio_printf_options() and __local_stdio_scanf_options(), which I'd never noticed before, but apparently are internal to a standard library header.
2023-05-27 13:59:20 +00:00
(p.rcPaint.left-wgs->offset_width)/wgs->font_width,
(p.rcPaint.top-wgs->offset_height)/wgs->font_height,
(p.rcPaint.right-wgs->offset_width-1)/wgs->font_width,
(p.rcPaint.bottom-wgs->offset_height-1)/wgs->font_height,
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
!wgs->term->window_update_pending);
wgs->wintw_hdc = NULL;
Formatting change to braces around one case of a switch. Sometimes, within a switch statement, you want to declare local variables specific to the handler for one particular case. Until now I've mostly been writing this in the form switch (discriminant) { case SIMPLE: do stuff; break; case COMPLICATED: { declare variables; do stuff; } break; } which is ugly because the two pieces of essentially similar code appear at different indent levels, and also inconvenient because you have less horizontal space available to write the complicated case handler in - particuarly undesirable because _complicated_ case handlers are the ones most likely to need all the space they can get! After encountering a rather nicer idiom in the LLVM source code, and after a bit of hackery this morning figuring out how to persuade Emacs's auto-indent to do what I wanted with it, I've decided to move to an idiom in which the open brace comes right after the case statement, and the code within it is indented the same as it would have been without the brace. Then the whole case handler (including the break) lives inside those braces, and you get something that looks more like this: switch (discriminant) { case SIMPLE: do stuff; break; case COMPLICATED: { declare variables; do stuff; break; } } This commit is a big-bang change that reformats all the complicated case handlers I could find into the new layout. This is particularly nice in the Pageant main function, in which almost _every_ case handler had a bundle of variables and was long and complicated. (In fact that's what motivated me to get round to this.) Some of the innermost parts of the terminal escape-sequence handling are also breathing a bit easier now the horizontal pressure on them is relieved. (Also, in a few cases, I was able to remove the extra braces completely, because the only variable local to the case handler was a loop variable which our new C99 policy allows me to move into the initialiser clause of its for statement.) Viewed with whitespace ignored, this is not too disruptive a change. Downstream patches that conflict with it may need to be reapplied using --ignore-whitespace or similar.
2020-02-16 07:49:52 +00:00
if (p.fErase ||
windows/window.c: move more variables into WinGuiSeat. In commit f9e572595bb8cb6 I claimed that I'd removed very nearly all the global and static variables from windows/window.c. It turns out that this was wildly overoptimistic - I missed quite a few of them! I'm not quite sure how I managed that; my best guess is that I used an underpowered 'nm' command that failed to find some classes of variable. Some of the remaining function-scope statics were removed completely by commit afb3dab1e97a09f just now. In this commit, I've swept up some more and turn them into fields of WinGuiSeat, where they should have been moved last September. The (hopefully complete this time) list of remaining variables, generated by running this rune in the Windows build directory: nm windows/CMakeFiles/putty.dir/window.c.obj | grep -E '^([^ ]+)? *[bBcCdDgGsS] [^\.]' consists of the following variables which are legitimately global across the whole process and not related to a particular window: - 'hinst' and 'hprev', instance handles for Windows loadable modules - 'classname' in the terminal_window_class_a() and terminal_window_class_w() functions, which allocate a window class reusably - some pointers to Windows API functions retrieved via the DECL_WINDOWS_FUNCTION / GET_WINDOWS_FUNCTION system, such as p_AdjustWindowRectExForDpi and p_FlashWindowEx - some pointers to Windows API functions set up by assigning them at startup to the right one of the ANSI or Unicode version depending on the Windows version, e.g. sw_DefWindowProc and sw_DispatchMessage - 'unicode_window', a boolean flag set at the same time as those sw_Foo function pointers - 'sesslist', storing the last-retrieved version of the saved sessions menu - 'cursor_visible' in show_mouseptr() and 'forced_visible' in update_mouse_pointer(), each of which tracks the cumulative number of times that function has shown or hidden the mouse pointer, so as to manage its effect on the global state updated by ShowCursor - 'trust_icon', loaded from the executable's resources - 'wgslisthead', the list of all active WinGuiSeats - 'wm_mousewheel', the window-message id we use for mouse wheel events and the following which are nothing to do with our code: - '_OptionsStorage' in __local_stdio_printf_options() and __local_stdio_scanf_options(), which I'd never noticed before, but apparently are internal to a standard library header.
2023-05-27 13:59:20 +00:00
p.rcPaint.left < wgs->offset_width ||
p.rcPaint.top < wgs->offset_height ||
p.rcPaint.right >= (wgs->offset_width +
wgs->font_width*wgs->term->cols) ||
p.rcPaint.bottom>= (wgs->offset_height +
wgs->font_height*wgs->term->rows)) {
Formatting: normalise back to 4-space indentation. In several pieces of development recently I've run across the occasional code block in the middle of a function which suddenly switched to 2-space indent from this code base's usual 4. I decided I was tired of it, so I ran the whole code base through a re-indenter, which made a huge mess, and then manually sifted out the changes that actually made sense from that pass. Indeed, this caught quite a few large sections with 2-space indent level, a couple with 8, and a handful of even weirder things like 3 spaces or 12. This commit fixes them all.
2022-08-03 19:48:46 +00:00
HBRUSH fillcolour, oldbrush;
HPEN edge, oldpen;
fillcolour = CreateSolidBrush (
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
wgs->colours[ATTR_DEFBG>>ATTR_BGSHIFT]);
Formatting: normalise back to 4-space indentation. In several pieces of development recently I've run across the occasional code block in the middle of a function which suddenly switched to 2-space indent from this code base's usual 4. I decided I was tired of it, so I ran the whole code base through a re-indenter, which made a huge mess, and then manually sifted out the changes that actually made sense from that pass. Indeed, this caught quite a few large sections with 2-space indent level, a couple with 8, and a handful of even weirder things like 3 spaces or 12. This commit fixes them all.
2022-08-03 19:48:46 +00:00
oldbrush = SelectObject(hdc, fillcolour);
edge = CreatePen(PS_SOLID, 0,
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
wgs->colours[ATTR_DEFBG>>ATTR_BGSHIFT]);
Formatting: normalise back to 4-space indentation. In several pieces of development recently I've run across the occasional code block in the middle of a function which suddenly switched to 2-space indent from this code base's usual 4. I decided I was tired of it, so I ran the whole code base through a re-indenter, which made a huge mess, and then manually sifted out the changes that actually made sense from that pass. Indeed, this caught quite a few large sections with 2-space indent level, a couple with 8, and a handful of even weirder things like 3 spaces or 12. This commit fixes them all.
2022-08-03 19:48:46 +00:00
oldpen = SelectObject(hdc, edge);
/*
* Jordan Russell reports that this apparently
* ineffectual IntersectClipRect() call masks a
* Windows NT/2K bug causing strange display
* problems when the PuTTY window is taller than
* the primary monitor. It seems harmless enough...
*/
IntersectClipRect(hdc,
p.rcPaint.left, p.rcPaint.top,
p.rcPaint.right, p.rcPaint.bottom);
windows/window.c: move more variables into WinGuiSeat. In commit f9e572595bb8cb6 I claimed that I'd removed very nearly all the global and static variables from windows/window.c. It turns out that this was wildly overoptimistic - I missed quite a few of them! I'm not quite sure how I managed that; my best guess is that I used an underpowered 'nm' command that failed to find some classes of variable. Some of the remaining function-scope statics were removed completely by commit afb3dab1e97a09f just now. In this commit, I've swept up some more and turn them into fields of WinGuiSeat, where they should have been moved last September. The (hopefully complete this time) list of remaining variables, generated by running this rune in the Windows build directory: nm windows/CMakeFiles/putty.dir/window.c.obj | grep -E '^([^ ]+)? *[bBcCdDgGsS] [^\.]' consists of the following variables which are legitimately global across the whole process and not related to a particular window: - 'hinst' and 'hprev', instance handles for Windows loadable modules - 'classname' in the terminal_window_class_a() and terminal_window_class_w() functions, which allocate a window class reusably - some pointers to Windows API functions retrieved via the DECL_WINDOWS_FUNCTION / GET_WINDOWS_FUNCTION system, such as p_AdjustWindowRectExForDpi and p_FlashWindowEx - some pointers to Windows API functions set up by assigning them at startup to the right one of the ANSI or Unicode version depending on the Windows version, e.g. sw_DefWindowProc and sw_DispatchMessage - 'unicode_window', a boolean flag set at the same time as those sw_Foo function pointers - 'sesslist', storing the last-retrieved version of the saved sessions menu - 'cursor_visible' in show_mouseptr() and 'forced_visible' in update_mouse_pointer(), each of which tracks the cumulative number of times that function has shown or hidden the mouse pointer, so as to manage its effect on the global state updated by ShowCursor - 'trust_icon', loaded from the executable's resources - 'wgslisthead', the list of all active WinGuiSeats - 'wm_mousewheel', the window-message id we use for mouse wheel events and the following which are nothing to do with our code: - '_OptionsStorage' in __local_stdio_printf_options() and __local_stdio_scanf_options(), which I'd never noticed before, but apparently are internal to a standard library header.
2023-05-27 13:59:20 +00:00
ExcludeClipRect(
hdc, wgs->offset_width, wgs->offset_height,
wgs->offset_width+wgs->font_width*wgs->term->cols,
wgs->offset_height+wgs->font_height*wgs->term->rows);
Formatting: normalise back to 4-space indentation. In several pieces of development recently I've run across the occasional code block in the middle of a function which suddenly switched to 2-space indent from this code base's usual 4. I decided I was tired of it, so I ran the whole code base through a re-indenter, which made a huge mess, and then manually sifted out the changes that actually made sense from that pass. Indeed, this caught quite a few large sections with 2-space indent level, a couple with 8, and a handful of even weirder things like 3 spaces or 12. This commit fixes them all.
2022-08-03 19:48:46 +00:00
Rectangle(hdc, p.rcPaint.left, p.rcPaint.top,
p.rcPaint.right, p.rcPaint.bottom);
/* SelectClipRgn(hdc, NULL); */
SelectObject(hdc, oldbrush);
DeleteObject(fillcolour);
SelectObject(hdc, oldpen);
DeleteObject(edge);
Revamp Windows pending_netevent using toplevel callbacks. This greatly simplifies the process of calling select_result() from the top level after receiving WM_NETEVENT. [originally from svn r10024]
2013-08-17 16:06:35 +00:00
}
Formatting change to braces around one case of a switch. Sometimes, within a switch statement, you want to declare local variables specific to the handler for one particular case. Until now I've mostly been writing this in the form switch (discriminant) { case SIMPLE: do stuff; break; case COMPLICATED: { declare variables; do stuff; } break; } which is ugly because the two pieces of essentially similar code appear at different indent levels, and also inconvenient because you have less horizontal space available to write the complicated case handler in - particuarly undesirable because _complicated_ case handlers are the ones most likely to need all the space they can get! After encountering a rather nicer idiom in the LLVM source code, and after a bit of hackery this morning figuring out how to persuade Emacs's auto-indent to do what I wanted with it, I've decided to move to an idiom in which the open brace comes right after the case statement, and the code within it is indented the same as it would have been without the brace. Then the whole case handler (including the break) lives inside those braces, and you get something that looks more like this: switch (discriminant) { case SIMPLE: do stuff; break; case COMPLICATED: { declare variables; do stuff; break; } } This commit is a big-bang change that reformats all the complicated case handlers I could find into the new layout. This is particularly nice in the Pageant main function, in which almost _every_ case handler had a bundle of variables and was long and complicated. (In fact that's what motivated me to get round to this.) Some of the innermost parts of the terminal escape-sequence handling are also breathing a bit easier now the horizontal pressure on them is relieved. (Also, in a few cases, I was able to remove the extra braces completely, because the only variable local to the case handler was a loop variable which our new C99 policy allows me to move into the initialiser clause of its for statement.) Viewed with whitespace ignored, this is not too disruptive a change. Downstream patches that conflict with it may need to be reapplied using --ignore-whitespace or similar.
2020-02-16 07:49:52 +00:00
SelectObject(hdc, GetStockObject(SYSTEM_FONT));
SelectObject(hdc, GetStockObject(WHITE_PEN));
EndPaint(hwnd, &p);
ShowCaret(hwnd);
return 0;
}
Handle WM_NETEVENT in Windows Pageant. Apparently when I made Windows Pageant use the winselgui system, I added the call that gets WSAAsyncSelect response messages sent to Pageant's window, but I didn't add the switch case in the window procedure that actually handles those responses. I suppose I didn't notice at the time because no actual functionality used it - Pageant has never yet dealt with any real (i.e. Winsock) sockets, only with HANDLE-based named pipes, which are called 'sockets' in PuTTY's abstraction, but not by Windows.
2022-01-29 16:49:44 +00:00
case WM_NETEVENT:
winselgui_response(wParam, lParam);
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
return 0;
Initial checkin: beta 0.43 [originally from svn r11]
1999-01-08 13:02:13 +00:00
case WM_SETFOCUS:
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
term_set_focus(wgs->term, true);
windows/window.c: move more variables into WinGuiSeat. In commit f9e572595bb8cb6 I claimed that I'd removed very nearly all the global and static variables from windows/window.c. It turns out that this was wildly overoptimistic - I missed quite a few of them! I'm not quite sure how I managed that; my best guess is that I used an underpowered 'nm' command that failed to find some classes of variable. Some of the remaining function-scope statics were removed completely by commit afb3dab1e97a09f just now. In this commit, I've swept up some more and turn them into fields of WinGuiSeat, where they should have been moved last September. The (hopefully complete this time) list of remaining variables, generated by running this rune in the Windows build directory: nm windows/CMakeFiles/putty.dir/window.c.obj | grep -E '^([^ ]+)? *[bBcCdDgGsS] [^\.]' consists of the following variables which are legitimately global across the whole process and not related to a particular window: - 'hinst' and 'hprev', instance handles for Windows loadable modules - 'classname' in the terminal_window_class_a() and terminal_window_class_w() functions, which allocate a window class reusably - some pointers to Windows API functions retrieved via the DECL_WINDOWS_FUNCTION / GET_WINDOWS_FUNCTION system, such as p_AdjustWindowRectExForDpi and p_FlashWindowEx - some pointers to Windows API functions set up by assigning them at startup to the right one of the ANSI or Unicode version depending on the Windows version, e.g. sw_DefWindowProc and sw_DispatchMessage - 'unicode_window', a boolean flag set at the same time as those sw_Foo function pointers - 'sesslist', storing the last-retrieved version of the saved sessions menu - 'cursor_visible' in show_mouseptr() and 'forced_visible' in update_mouse_pointer(), each of which tracks the cumulative number of times that function has shown or hidden the mouse pointer, so as to manage its effect on the global state updated by ShowCursor - 'trust_icon', loaded from the executable's resources - 'wgslisthead', the list of all active WinGuiSeats - 'wm_mousewheel', the window-message id we use for mouse wheel events and the following which are nothing to do with our code: - '_OptionsStorage' in __local_stdio_printf_options() and __local_stdio_scanf_options(), which I'd never noticed before, but apparently are internal to a standard library header.
2023-05-27 13:59:20 +00:00
CreateCaret(hwnd, wgs->caretbm, wgs->font_width, wgs->font_height);
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
ShowCaret(hwnd);
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
flash_window(wgs, 0); /* stop */
wgs->compose_state = 0;
term_update(wgs->term);
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
break;
Initial checkin: beta 0.43 [originally from svn r11]
1999-01-08 13:02:13 +00:00
case WM_KILLFOCUS:
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
show_mouseptr(wgs, true);
term_set_focus(wgs->term, false);
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
DestroyCaret();
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
wgs->caret_x = wgs->caret_y = -1; /* ensure caret replaced next time */
term_update(wgs->term);
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
break;
John Sullivan's sizetip patch - experimental [originally from svn r269]
1999-11-03 14:08:26 +00:00
case WM_ENTERSIZEMOVE:
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
EnableSizeTip(true);
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
wgs->resizing = true;
windows/window.c: move more variables into WinGuiSeat. In commit f9e572595bb8cb6 I claimed that I'd removed very nearly all the global and static variables from windows/window.c. It turns out that this was wildly overoptimistic - I missed quite a few of them! I'm not quite sure how I managed that; my best guess is that I used an underpowered 'nm' command that failed to find some classes of variable. Some of the remaining function-scope statics were removed completely by commit afb3dab1e97a09f just now. In this commit, I've swept up some more and turn them into fields of WinGuiSeat, where they should have been moved last September. The (hopefully complete this time) list of remaining variables, generated by running this rune in the Windows build directory: nm windows/CMakeFiles/putty.dir/window.c.obj | grep -E '^([^ ]+)? *[bBcCdDgGsS] [^\.]' consists of the following variables which are legitimately global across the whole process and not related to a particular window: - 'hinst' and 'hprev', instance handles for Windows loadable modules - 'classname' in the terminal_window_class_a() and terminal_window_class_w() functions, which allocate a window class reusably - some pointers to Windows API functions retrieved via the DECL_WINDOWS_FUNCTION / GET_WINDOWS_FUNCTION system, such as p_AdjustWindowRectExForDpi and p_FlashWindowEx - some pointers to Windows API functions set up by assigning them at startup to the right one of the ANSI or Unicode version depending on the Windows version, e.g. sw_DefWindowProc and sw_DispatchMessage - 'unicode_window', a boolean flag set at the same time as those sw_Foo function pointers - 'sesslist', storing the last-retrieved version of the saved sessions menu - 'cursor_visible' in show_mouseptr() and 'forced_visible' in update_mouse_pointer(), each of which tracks the cumulative number of times that function has shown or hidden the mouse pointer, so as to manage its effect on the global state updated by ShowCursor - 'trust_icon', loaded from the executable's resources - 'wgslisthead', the list of all active WinGuiSeats - 'wm_mousewheel', the window-message id we use for mouse wheel events and the following which are nothing to do with our code: - '_OptionsStorage' in __local_stdio_printf_options() and __local_stdio_scanf_options(), which I'd never noticed before, but apparently are internal to a standard library header.
2023-05-27 13:59:20 +00:00
wgs->need_backend_resize = false;
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
break;
John Sullivan's sizetip patch - experimental [originally from svn r269]
1999-11-03 14:08:26 +00:00
case WM_EXITSIZEMOVE:
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
EnableSizeTip(false);
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
wgs->resizing = false;
windows/window.c: move more variables into WinGuiSeat. In commit f9e572595bb8cb6 I claimed that I'd removed very nearly all the global and static variables from windows/window.c. It turns out that this was wildly overoptimistic - I missed quite a few of them! I'm not quite sure how I managed that; my best guess is that I used an underpowered 'nm' command that failed to find some classes of variable. Some of the remaining function-scope statics were removed completely by commit afb3dab1e97a09f just now. In this commit, I've swept up some more and turn them into fields of WinGuiSeat, where they should have been moved last September. The (hopefully complete this time) list of remaining variables, generated by running this rune in the Windows build directory: nm windows/CMakeFiles/putty.dir/window.c.obj | grep -E '^([^ ]+)? *[bBcCdDgGsS] [^\.]' consists of the following variables which are legitimately global across the whole process and not related to a particular window: - 'hinst' and 'hprev', instance handles for Windows loadable modules - 'classname' in the terminal_window_class_a() and terminal_window_class_w() functions, which allocate a window class reusably - some pointers to Windows API functions retrieved via the DECL_WINDOWS_FUNCTION / GET_WINDOWS_FUNCTION system, such as p_AdjustWindowRectExForDpi and p_FlashWindowEx - some pointers to Windows API functions set up by assigning them at startup to the right one of the ANSI or Unicode version depending on the Windows version, e.g. sw_DefWindowProc and sw_DispatchMessage - 'unicode_window', a boolean flag set at the same time as those sw_Foo function pointers - 'sesslist', storing the last-retrieved version of the saved sessions menu - 'cursor_visible' in show_mouseptr() and 'forced_visible' in update_mouse_pointer(), each of which tracks the cumulative number of times that function has shown or hidden the mouse pointer, so as to manage its effect on the global state updated by ShowCursor - 'trust_icon', loaded from the executable's resources - 'wgslisthead', the list of all active WinGuiSeats - 'wm_mousewheel', the window-message id we use for mouse wheel events and the following which are nothing to do with our code: - '_OptionsStorage' in __local_stdio_printf_options() and __local_stdio_scanf_options(), which I'd never noticed before, but apparently are internal to a standard library header.
2023-05-27 13:59:20 +00:00
if (wgs->need_backend_resize) {
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
term_size(wgs->term, conf_get_int(wgs->conf, CONF_height),
conf_get_int(wgs->conf, CONF_width),
conf_get_int(wgs->conf, CONF_savelines));
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
InvalidateRect(hwnd, NULL, true);
}
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
recompute_window_offset(wgs);
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
break;
Initial checkin: beta 0.43 [originally from svn r11]
1999-01-08 13:02:13 +00:00
case WM_SIZING:
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
/*
* This does two jobs:
* 1) Keep the sizetip uptodate
* 2) Make sure the window size is _stepped_ in units of the font size.
*/
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
resize_action = conf_get_int(wgs->conf, CONF_resize_action);
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
if (resize_action == RESIZE_TERM ||
Post-release destabilisation! Completely remove the struct type 'Config' in putty.h, which stores all PuTTY's settings and includes an arbitrary length limit on every single one of those settings which is stored in string form. In place of it is 'Conf', an opaque data type everywhere outside the new file conf.c, which stores a list of (key, value) pairs in which every key contains an integer identifying a configuration setting, and for some of those integers the key also contains extra parts (so that, for instance, CONF_environmt is a string-to-string mapping). Everywhere that a Config was previously used, a Conf is now; everywhere there was a Config structure copy, conf_copy() is called; every lookup, adjustment, load and save operation on a Config has been rewritten; and there's a mechanism for serialising a Conf into a binary blob and back for use with Duplicate Session. User-visible effects of this change _should_ be minimal, though I don't doubt I've introduced one or two bugs here and there which will eventually be found. The _intended_ visible effects of this change are that all arbitrary limits on configuration strings and lists (e.g. limit on number of port forwardings) should now disappear; that list boxes in the configuration will now be displayed in a sorted order rather than the arbitrary order in which they were added to the list (since the underlying data structure is now a sorted tree234 rather than an ad-hoc comma-separated string); and one more specific change, which is that local and dynamic port forwardings on the same port number are now mutually exclusive in the configuration (putting 'D' in the key rather than the value was a mistake in the first place). One other reorganisation as a result of this is that I've moved all the dialog.c standard handlers (dlg_stdeditbox_handler and friends) out into config.c, because I can't really justify calling them generic any more. When they took a pointer to an arbitrary structure type and the offset of a field within that structure, they were independent of whether that structure was a Config or something completely different, but now they really do expect to talk to a Conf, which can _only_ be used for PuTTY configuration, so I've renamed them all things like conf_editbox_handler and moved them out of the nominally independent dialog-box management module into the PuTTY-specific config.c. [originally from svn r9214]
2011-07-14 18:52:21 +00:00
(resize_action == RESIZE_EITHER && !is_alt_pressed())) {
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
int width, height, w, h, ew, eh;
LPRECT r = (LPRECT) lParam;
windows/window.c: move more variables into WinGuiSeat. In commit f9e572595bb8cb6 I claimed that I'd removed very nearly all the global and static variables from windows/window.c. It turns out that this was wildly overoptimistic - I missed quite a few of them! I'm not quite sure how I managed that; my best guess is that I used an underpowered 'nm' command that failed to find some classes of variable. Some of the remaining function-scope statics were removed completely by commit afb3dab1e97a09f just now. In this commit, I've swept up some more and turn them into fields of WinGuiSeat, where they should have been moved last September. The (hopefully complete this time) list of remaining variables, generated by running this rune in the Windows build directory: nm windows/CMakeFiles/putty.dir/window.c.obj | grep -E '^([^ ]+)? *[bBcCdDgGsS] [^\.]' consists of the following variables which are legitimately global across the whole process and not related to a particular window: - 'hinst' and 'hprev', instance handles for Windows loadable modules - 'classname' in the terminal_window_class_a() and terminal_window_class_w() functions, which allocate a window class reusably - some pointers to Windows API functions retrieved via the DECL_WINDOWS_FUNCTION / GET_WINDOWS_FUNCTION system, such as p_AdjustWindowRectExForDpi and p_FlashWindowEx - some pointers to Windows API functions set up by assigning them at startup to the right one of the ANSI or Unicode version depending on the Windows version, e.g. sw_DefWindowProc and sw_DispatchMessage - 'unicode_window', a boolean flag set at the same time as those sw_Foo function pointers - 'sesslist', storing the last-retrieved version of the saved sessions menu - 'cursor_visible' in show_mouseptr() and 'forced_visible' in update_mouse_pointer(), each of which tracks the cumulative number of times that function has shown or hidden the mouse pointer, so as to manage its effect on the global state updated by ShowCursor - 'trust_icon', loaded from the executable's resources - 'wgslisthead', the list of all active WinGuiSeats - 'wm_mousewheel', the window-message id we use for mouse wheel events and the following which are nothing to do with our code: - '_OptionsStorage' in __local_stdio_printf_options() and __local_stdio_scanf_options(), which I'd never noticed before, but apparently are internal to a standard library header.
2023-05-27 13:59:20 +00:00
if (!wgs->need_backend_resize && resize_action == RESIZE_EITHER &&
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
(conf_get_int(wgs->conf, CONF_height) != wgs->term->rows ||
conf_get_int(wgs->conf, CONF_width) != wgs->term->cols)) {
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
/*
* Great! It seems that both the terminal size and the
* font size have been changed and the user is now dragging.
*
* It will now be difficult to get back to the configured
* font size!
*
* This would be easier but it seems to be too confusing.
*/
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
conf_set_int(wgs->conf, CONF_height, wgs->term->rows);
conf_set_int(wgs->conf, CONF_width, wgs->term->cols);
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
InvalidateRect(hwnd, NULL, true);
windows/window.c: move more variables into WinGuiSeat. In commit f9e572595bb8cb6 I claimed that I'd removed very nearly all the global and static variables from windows/window.c. It turns out that this was wildly overoptimistic - I missed quite a few of them! I'm not quite sure how I managed that; my best guess is that I used an underpowered 'nm' command that failed to find some classes of variable. Some of the remaining function-scope statics were removed completely by commit afb3dab1e97a09f just now. In this commit, I've swept up some more and turn them into fields of WinGuiSeat, where they should have been moved last September. The (hopefully complete this time) list of remaining variables, generated by running this rune in the Windows build directory: nm windows/CMakeFiles/putty.dir/window.c.obj | grep -E '^([^ ]+)? *[bBcCdDgGsS] [^\.]' consists of the following variables which are legitimately global across the whole process and not related to a particular window: - 'hinst' and 'hprev', instance handles for Windows loadable modules - 'classname' in the terminal_window_class_a() and terminal_window_class_w() functions, which allocate a window class reusably - some pointers to Windows API functions retrieved via the DECL_WINDOWS_FUNCTION / GET_WINDOWS_FUNCTION system, such as p_AdjustWindowRectExForDpi and p_FlashWindowEx - some pointers to Windows API functions set up by assigning them at startup to the right one of the ANSI or Unicode version depending on the Windows version, e.g. sw_DefWindowProc and sw_DispatchMessage - 'unicode_window', a boolean flag set at the same time as those sw_Foo function pointers - 'sesslist', storing the last-retrieved version of the saved sessions menu - 'cursor_visible' in show_mouseptr() and 'forced_visible' in update_mouse_pointer(), each of which tracks the cumulative number of times that function has shown or hidden the mouse pointer, so as to manage its effect on the global state updated by ShowCursor - 'trust_icon', loaded from the executable's resources - 'wgslisthead', the list of all active WinGuiSeats - 'wm_mousewheel', the window-message id we use for mouse wheel events and the following which are nothing to do with our code: - '_OptionsStorage' in __local_stdio_printf_options() and __local_stdio_scanf_options(), which I'd never noticed before, but apparently are internal to a standard library header.
2023-05-27 13:59:20 +00:00
wgs->need_backend_resize = true;
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
}
windows/window.c: move more variables into WinGuiSeat. In commit f9e572595bb8cb6 I claimed that I'd removed very nearly all the global and static variables from windows/window.c. It turns out that this was wildly overoptimistic - I missed quite a few of them! I'm not quite sure how I managed that; my best guess is that I used an underpowered 'nm' command that failed to find some classes of variable. Some of the remaining function-scope statics were removed completely by commit afb3dab1e97a09f just now. In this commit, I've swept up some more and turn them into fields of WinGuiSeat, where they should have been moved last September. The (hopefully complete this time) list of remaining variables, generated by running this rune in the Windows build directory: nm windows/CMakeFiles/putty.dir/window.c.obj | grep -E '^([^ ]+)? *[bBcCdDgGsS] [^\.]' consists of the following variables which are legitimately global across the whole process and not related to a particular window: - 'hinst' and 'hprev', instance handles for Windows loadable modules - 'classname' in the terminal_window_class_a() and terminal_window_class_w() functions, which allocate a window class reusably - some pointers to Windows API functions retrieved via the DECL_WINDOWS_FUNCTION / GET_WINDOWS_FUNCTION system, such as p_AdjustWindowRectExForDpi and p_FlashWindowEx - some pointers to Windows API functions set up by assigning them at startup to the right one of the ANSI or Unicode version depending on the Windows version, e.g. sw_DefWindowProc and sw_DispatchMessage - 'unicode_window', a boolean flag set at the same time as those sw_Foo function pointers - 'sesslist', storing the last-retrieved version of the saved sessions menu - 'cursor_visible' in show_mouseptr() and 'forced_visible' in update_mouse_pointer(), each of which tracks the cumulative number of times that function has shown or hidden the mouse pointer, so as to manage its effect on the global state updated by ShowCursor - 'trust_icon', loaded from the executable's resources - 'wgslisthead', the list of all active WinGuiSeats - 'wm_mousewheel', the window-message id we use for mouse wheel events and the following which are nothing to do with our code: - '_OptionsStorage' in __local_stdio_printf_options() and __local_stdio_scanf_options(), which I'd never noticed before, but apparently are internal to a standard library header.
2023-05-27 13:59:20 +00:00
width = r->right - r->left - wgs->extra_width;
height = r->bottom - r->top - wgs->extra_height;
w = (width + wgs->font_width / 2) / wgs->font_width;
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
if (w < 1)
w = 1;
windows/window.c: move more variables into WinGuiSeat. In commit f9e572595bb8cb6 I claimed that I'd removed very nearly all the global and static variables from windows/window.c. It turns out that this was wildly overoptimistic - I missed quite a few of them! I'm not quite sure how I managed that; my best guess is that I used an underpowered 'nm' command that failed to find some classes of variable. Some of the remaining function-scope statics were removed completely by commit afb3dab1e97a09f just now. In this commit, I've swept up some more and turn them into fields of WinGuiSeat, where they should have been moved last September. The (hopefully complete this time) list of remaining variables, generated by running this rune in the Windows build directory: nm windows/CMakeFiles/putty.dir/window.c.obj | grep -E '^([^ ]+)? *[bBcCdDgGsS] [^\.]' consists of the following variables which are legitimately global across the whole process and not related to a particular window: - 'hinst' and 'hprev', instance handles for Windows loadable modules - 'classname' in the terminal_window_class_a() and terminal_window_class_w() functions, which allocate a window class reusably - some pointers to Windows API functions retrieved via the DECL_WINDOWS_FUNCTION / GET_WINDOWS_FUNCTION system, such as p_AdjustWindowRectExForDpi and p_FlashWindowEx - some pointers to Windows API functions set up by assigning them at startup to the right one of the ANSI or Unicode version depending on the Windows version, e.g. sw_DefWindowProc and sw_DispatchMessage - 'unicode_window', a boolean flag set at the same time as those sw_Foo function pointers - 'sesslist', storing the last-retrieved version of the saved sessions menu - 'cursor_visible' in show_mouseptr() and 'forced_visible' in update_mouse_pointer(), each of which tracks the cumulative number of times that function has shown or hidden the mouse pointer, so as to manage its effect on the global state updated by ShowCursor - 'trust_icon', loaded from the executable's resources - 'wgslisthead', the list of all active WinGuiSeats - 'wm_mousewheel', the window-message id we use for mouse wheel events and the following which are nothing to do with our code: - '_OptionsStorage' in __local_stdio_printf_options() and __local_stdio_scanf_options(), which I'd never noticed before, but apparently are internal to a standard library header.
2023-05-27 13:59:20 +00:00
h = (height + wgs->font_height / 2) / wgs->font_height;
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
if (h < 1)
h = 1;
UpdateSizeTip(hwnd, w, h);
windows/window.c: move more variables into WinGuiSeat. In commit f9e572595bb8cb6 I claimed that I'd removed very nearly all the global and static variables from windows/window.c. It turns out that this was wildly overoptimistic - I missed quite a few of them! I'm not quite sure how I managed that; my best guess is that I used an underpowered 'nm' command that failed to find some classes of variable. Some of the remaining function-scope statics were removed completely by commit afb3dab1e97a09f just now. In this commit, I've swept up some more and turn them into fields of WinGuiSeat, where they should have been moved last September. The (hopefully complete this time) list of remaining variables, generated by running this rune in the Windows build directory: nm windows/CMakeFiles/putty.dir/window.c.obj | grep -E '^([^ ]+)? *[bBcCdDgGsS] [^\.]' consists of the following variables which are legitimately global across the whole process and not related to a particular window: - 'hinst' and 'hprev', instance handles for Windows loadable modules - 'classname' in the terminal_window_class_a() and terminal_window_class_w() functions, which allocate a window class reusably - some pointers to Windows API functions retrieved via the DECL_WINDOWS_FUNCTION / GET_WINDOWS_FUNCTION system, such as p_AdjustWindowRectExForDpi and p_FlashWindowEx - some pointers to Windows API functions set up by assigning them at startup to the right one of the ANSI or Unicode version depending on the Windows version, e.g. sw_DefWindowProc and sw_DispatchMessage - 'unicode_window', a boolean flag set at the same time as those sw_Foo function pointers - 'sesslist', storing the last-retrieved version of the saved sessions menu - 'cursor_visible' in show_mouseptr() and 'forced_visible' in update_mouse_pointer(), each of which tracks the cumulative number of times that function has shown or hidden the mouse pointer, so as to manage its effect on the global state updated by ShowCursor - 'trust_icon', loaded from the executable's resources - 'wgslisthead', the list of all active WinGuiSeats - 'wm_mousewheel', the window-message id we use for mouse wheel events and the following which are nothing to do with our code: - '_OptionsStorage' in __local_stdio_printf_options() and __local_stdio_scanf_options(), which I'd never noticed before, but apparently are internal to a standard library header.
2023-05-27 13:59:20 +00:00
ew = width - w * wgs->font_width;
eh = height - h * wgs->font_height;
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
if (ew != 0) {
if (wParam == WMSZ_LEFT ||
wParam == WMSZ_BOTTOMLEFT || wParam == WMSZ_TOPLEFT)
r->left += ew;
else
r->right -= ew;
}
if (eh != 0) {
if (wParam == WMSZ_TOP ||
wParam == WMSZ_TOPRIGHT || wParam == WMSZ_TOPLEFT)
r->top += eh;
else
r->bottom -= eh;
}
if (ew || eh)
return 1;
else
return 0;
} else {
int width, height, w, h, rv = 0;
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
int window_border = conf_get_int(wgs->conf, CONF_window_border);
windows/window.c: move more variables into WinGuiSeat. In commit f9e572595bb8cb6 I claimed that I'd removed very nearly all the global and static variables from windows/window.c. It turns out that this was wildly overoptimistic - I missed quite a few of them! I'm not quite sure how I managed that; my best guess is that I used an underpowered 'nm' command that failed to find some classes of variable. Some of the remaining function-scope statics were removed completely by commit afb3dab1e97a09f just now. In this commit, I've swept up some more and turn them into fields of WinGuiSeat, where they should have been moved last September. The (hopefully complete this time) list of remaining variables, generated by running this rune in the Windows build directory: nm windows/CMakeFiles/putty.dir/window.c.obj | grep -E '^([^ ]+)? *[bBcCdDgGsS] [^\.]' consists of the following variables which are legitimately global across the whole process and not related to a particular window: - 'hinst' and 'hprev', instance handles for Windows loadable modules - 'classname' in the terminal_window_class_a() and terminal_window_class_w() functions, which allocate a window class reusably - some pointers to Windows API functions retrieved via the DECL_WINDOWS_FUNCTION / GET_WINDOWS_FUNCTION system, such as p_AdjustWindowRectExForDpi and p_FlashWindowEx - some pointers to Windows API functions set up by assigning them at startup to the right one of the ANSI or Unicode version depending on the Windows version, e.g. sw_DefWindowProc and sw_DispatchMessage - 'unicode_window', a boolean flag set at the same time as those sw_Foo function pointers - 'sesslist', storing the last-retrieved version of the saved sessions menu - 'cursor_visible' in show_mouseptr() and 'forced_visible' in update_mouse_pointer(), each of which tracks the cumulative number of times that function has shown or hidden the mouse pointer, so as to manage its effect on the global state updated by ShowCursor - 'trust_icon', loaded from the executable's resources - 'wgslisthead', the list of all active WinGuiSeats - 'wm_mousewheel', the window-message id we use for mouse wheel events and the following which are nothing to do with our code: - '_OptionsStorage' in __local_stdio_printf_options() and __local_stdio_scanf_options(), which I'd never noticed before, but apparently are internal to a standard library header.
2023-05-27 13:59:20 +00:00
int ex_width = wgs->extra_width +
(window_border - wgs->offset_width) * 2;
int ex_height = wgs->extra_height +
(window_border - wgs->offset_height) * 2;
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
LPRECT r = (LPRECT) lParam;
width = r->right - r->left - ex_width;
height = r->bottom - r->top - ex_height;
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
w = (width + wgs->term->cols/2)/wgs->term->cols;
h = (height + wgs->term->rows/2)/wgs->term->rows;
if ( r->right != r->left + w*wgs->term->cols + ex_width)
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
rv = 1;
if (wParam == WMSZ_LEFT ||
wParam == WMSZ_BOTTOMLEFT || wParam == WMSZ_TOPLEFT)
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
r->left = r->right - w*wgs->term->cols - ex_width;
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
else
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
r->right = r->left + w*wgs->term->cols + ex_width;
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
if (r->bottom != r->top + h*wgs->term->rows + ex_height)
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
rv = 1;
if (wParam == WMSZ_TOP ||
wParam == WMSZ_TOPRIGHT || wParam == WMSZ_TOPLEFT)
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
r->top = r->bottom - h*wgs->term->rows - ex_height;
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
else
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
r->bottom = r->top + h*wgs->term->rows + ex_height;
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
return rv;
}
/* break; (never reached) */
FIFTH ATTEMPT at getting full-screen mode right. This new attempt (which I'll comment at some stage) should combine the believable semantics of RDB's fullscreen-by-maximise mode with the multi- monitor friendliness of Wez Furlong's approach while also working on Win98. If we're lucky. [originally from svn r1464]
2001-12-07 21:21:03 +00:00
case WM_FULLSCR_ON_MAX:
windows/window.c: move more variables into WinGuiSeat. In commit f9e572595bb8cb6 I claimed that I'd removed very nearly all the global and static variables from windows/window.c. It turns out that this was wildly overoptimistic - I missed quite a few of them! I'm not quite sure how I managed that; my best guess is that I used an underpowered 'nm' command that failed to find some classes of variable. Some of the remaining function-scope statics were removed completely by commit afb3dab1e97a09f just now. In this commit, I've swept up some more and turn them into fields of WinGuiSeat, where they should have been moved last September. The (hopefully complete this time) list of remaining variables, generated by running this rune in the Windows build directory: nm windows/CMakeFiles/putty.dir/window.c.obj | grep -E '^([^ ]+)? *[bBcCdDgGsS] [^\.]' consists of the following variables which are legitimately global across the whole process and not related to a particular window: - 'hinst' and 'hprev', instance handles for Windows loadable modules - 'classname' in the terminal_window_class_a() and terminal_window_class_w() functions, which allocate a window class reusably - some pointers to Windows API functions retrieved via the DECL_WINDOWS_FUNCTION / GET_WINDOWS_FUNCTION system, such as p_AdjustWindowRectExForDpi and p_FlashWindowEx - some pointers to Windows API functions set up by assigning them at startup to the right one of the ANSI or Unicode version depending on the Windows version, e.g. sw_DefWindowProc and sw_DispatchMessage - 'unicode_window', a boolean flag set at the same time as those sw_Foo function pointers - 'sesslist', storing the last-retrieved version of the saved sessions menu - 'cursor_visible' in show_mouseptr() and 'forced_visible' in update_mouse_pointer(), each of which tracks the cumulative number of times that function has shown or hidden the mouse pointer, so as to manage its effect on the global state updated by ShowCursor - 'trust_icon', loaded from the executable's resources - 'wgslisthead', the list of all active WinGuiSeats - 'wm_mousewheel', the window-message id we use for mouse wheel events and the following which are nothing to do with our code: - '_OptionsStorage' in __local_stdio_printf_options() and __local_stdio_scanf_options(), which I'd never noticed before, but apparently are internal to a standard library header.
2023-05-27 13:59:20 +00:00
wgs->fullscr_on_max = true;
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
break;
This should fix the busy-wait problem with the IME. [originally from svn r1512]
2001-12-20 14:18:01 +00:00
case WM_MOVE:
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
term_notify_window_pos(wgs->term, LOWORD(lParam), HIWORD(lParam));
sys_cursor_update(wgs);
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
break;
Initial checkin: beta 0.43 [originally from svn r11]
1999-01-08 13:02:13 +00:00
case WM_SIZE:
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
resize_action = conf_get_int(wgs->conf, CONF_resize_action);
term_notify_minimised(wgs->term, wParam == SIZE_MINIMIZED);
Flip direction of window pos/size queries. Similarly to other recent changes, the frontend now proactively keeps Terminal up to date with the current position and size of the terminal window, so that escape-sequence queries can be answered immediately from the Terminal's own internal data structures without needing a call back to the frontend. Mostly this has let me remove explicit window-system API calls that retrieve the window position and size, in favour of having the front ends listen for WM_MOVE / WM_SIZE / ConfigureNotify events and track the position and size that way. One exception is that the window pixel size is still requested by Seat via a callback, to put in the wire-encoded termios settings. That won't be happening very much, so I'm leaving it this way round for the moment.
2021-02-07 19:59:21 +00:00
{
/*
* WM_SIZE's lParam tells us the size of the client area.
* But historic PuTTY practice is that we want to tell the
* terminal the size of the overall window.
*/
RECT r;
GetWindowRect(hwnd, &r);
term_notify_window_size_pixels(
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
wgs->term, r.right - r.left, r.bottom - r.top);
Flip direction of window pos/size queries. Similarly to other recent changes, the frontend now proactively keeps Terminal up to date with the current position and size of the terminal window, so that escape-sequence queries can be answered immediately from the Terminal's own internal data structures without needing a call back to the frontend. Mostly this has let me remove explicit window-system API calls that retrieve the window position and size, in favour of having the front ends listen for WM_MOVE / WM_SIZE / ConfigureNotify events and track the position and size that way. One exception is that the window pixel size is still requested by Seat via a callback, to put in the wire-encoded termios settings. That won't be happening very much, so I'm leaving it this way round for the moment.
2021-02-07 19:59:21 +00:00
}
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
if (wParam == SIZE_MINIMIZED)
Windows: runtime switch between Unicode and ANSI windows. Turns out that PuTTY hasn't run successfully on legacy Windows since 0.66, in spite of an ongoing intention to keep it working. Among the reasons for this is that CreateWindowExW simply fails with ERROR_CALL_NOT_IMPLEMENTED: apparently Win95 and its ilk just didn't have fully-Unicode windows as an option. Fixed by resurrecting the previous code from the git history (in particular, code removed by commit 67e5ceb9a8e6bc2 was useful), and including it as a runtime alternative. One subtlety was that I found I had to name the A and W window classes differently (by appending ".ansi" to the A one): apparently they occupy the same namespace even though the names are in different character sets, so if you somehow manage to register both classes, they'll collide with each other without that tweak.
2022-03-12 06:43:59 +00:00
sw_SetWindowText(hwnd,
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
conf_get_bool(wgs->conf, CONF_win_name_always) ?
wgs->window_name : wgs->icon_name);
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
if (wParam == SIZE_RESTORED || wParam == SIZE_MAXIMIZED)
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
sw_SetWindowText(hwnd, wgs->window_name);
Fix resize handling when enabling and disabling full-screen mode. I'm not sure whether I broke this in the recent revamp or whether it was always broken, but: transitions in and out of full-screen mode work by first maximising or restoring the window, which triggers a WM_SIZE, whose handler then fiddles with the window style to disable or re-enable all the furniture, which in turn triggers a recursive WM_SIZE. The trouble is, after returning from the handler for the inner WM_SIZE, the rest of the outer handler runs, and its client area size is now out of date. So I've added a flag which is set when a resize is handled 'properly', so that after returning from the inner WM_SIZE handler the outer one knows not to try to redo badly work that's already been done well. [originally from svn r9056]
2010-12-27 12:58:39 +00:00
if (wParam == SIZE_RESTORED) {
windows/window.c: move more variables into WinGuiSeat. In commit f9e572595bb8cb6 I claimed that I'd removed very nearly all the global and static variables from windows/window.c. It turns out that this was wildly overoptimistic - I missed quite a few of them! I'm not quite sure how I managed that; my best guess is that I used an underpowered 'nm' command that failed to find some classes of variable. Some of the remaining function-scope statics were removed completely by commit afb3dab1e97a09f just now. In this commit, I've swept up some more and turn them into fields of WinGuiSeat, where they should have been moved last September. The (hopefully complete this time) list of remaining variables, generated by running this rune in the Windows build directory: nm windows/CMakeFiles/putty.dir/window.c.obj | grep -E '^([^ ]+)? *[bBcCdDgGsS] [^\.]' consists of the following variables which are legitimately global across the whole process and not related to a particular window: - 'hinst' and 'hprev', instance handles for Windows loadable modules - 'classname' in the terminal_window_class_a() and terminal_window_class_w() functions, which allocate a window class reusably - some pointers to Windows API functions retrieved via the DECL_WINDOWS_FUNCTION / GET_WINDOWS_FUNCTION system, such as p_AdjustWindowRectExForDpi and p_FlashWindowEx - some pointers to Windows API functions set up by assigning them at startup to the right one of the ANSI or Unicode version depending on the Windows version, e.g. sw_DefWindowProc and sw_DispatchMessage - 'unicode_window', a boolean flag set at the same time as those sw_Foo function pointers - 'sesslist', storing the last-retrieved version of the saved sessions menu - 'cursor_visible' in show_mouseptr() and 'forced_visible' in update_mouse_pointer(), each of which tracks the cumulative number of times that function has shown or hidden the mouse pointer, so as to manage its effect on the global state updated by ShowCursor - 'trust_icon', loaded from the executable's resources - 'wgslisthead', the list of all active WinGuiSeats - 'wm_mousewheel', the window-message id we use for mouse wheel events and the following which are nothing to do with our code: - '_OptionsStorage' in __local_stdio_printf_options() and __local_stdio_scanf_options(), which I'd never noticed before, but apparently are internal to a standard library header.
2023-05-27 13:59:20 +00:00
wgs->processed_resize = false;
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
clear_full_screen(wgs);
windows/window.c: move more variables into WinGuiSeat. In commit f9e572595bb8cb6 I claimed that I'd removed very nearly all the global and static variables from windows/window.c. It turns out that this was wildly overoptimistic - I missed quite a few of them! I'm not quite sure how I managed that; my best guess is that I used an underpowered 'nm' command that failed to find some classes of variable. Some of the remaining function-scope statics were removed completely by commit afb3dab1e97a09f just now. In this commit, I've swept up some more and turn them into fields of WinGuiSeat, where they should have been moved last September. The (hopefully complete this time) list of remaining variables, generated by running this rune in the Windows build directory: nm windows/CMakeFiles/putty.dir/window.c.obj | grep -E '^([^ ]+)? *[bBcCdDgGsS] [^\.]' consists of the following variables which are legitimately global across the whole process and not related to a particular window: - 'hinst' and 'hprev', instance handles for Windows loadable modules - 'classname' in the terminal_window_class_a() and terminal_window_class_w() functions, which allocate a window class reusably - some pointers to Windows API functions retrieved via the DECL_WINDOWS_FUNCTION / GET_WINDOWS_FUNCTION system, such as p_AdjustWindowRectExForDpi and p_FlashWindowEx - some pointers to Windows API functions set up by assigning them at startup to the right one of the ANSI or Unicode version depending on the Windows version, e.g. sw_DefWindowProc and sw_DispatchMessage - 'unicode_window', a boolean flag set at the same time as those sw_Foo function pointers - 'sesslist', storing the last-retrieved version of the saved sessions menu - 'cursor_visible' in show_mouseptr() and 'forced_visible' in update_mouse_pointer(), each of which tracks the cumulative number of times that function has shown or hidden the mouse pointer, so as to manage its effect on the global state updated by ShowCursor - 'trust_icon', loaded from the executable's resources - 'wgslisthead', the list of all active WinGuiSeats - 'wm_mousewheel', the window-message id we use for mouse wheel events and the following which are nothing to do with our code: - '_OptionsStorage' in __local_stdio_printf_options() and __local_stdio_scanf_options(), which I'd never noticed before, but apparently are internal to a standard library header.
2023-05-27 13:59:20 +00:00
if (wgs->processed_resize) {
Fix resize handling when enabling and disabling full-screen mode. I'm not sure whether I broke this in the recent revamp or whether it was always broken, but: transitions in and out of full-screen mode work by first maximising or restoring the window, which triggers a WM_SIZE, whose handler then fiddles with the window style to disable or re-enable all the furniture, which in turn triggers a recursive WM_SIZE. The trouble is, after returning from the handler for the inner WM_SIZE, the rest of the outer handler runs, and its client area size is now out of date. So I've added a flag which is set when a resize is handled 'properly', so that after returning from the inner WM_SIZE handler the outer one knows not to try to redo badly work that's already been done well. [originally from svn r9056]
2010-12-27 12:58:39 +00:00
/*
* Inhibit normal processing of this WM_SIZE; a
* secondary one was triggered just now by
* clear_full_screen which contained the correct
* client area size.
*/
return 0;
}
}
windows/window.c: move more variables into WinGuiSeat. In commit f9e572595bb8cb6 I claimed that I'd removed very nearly all the global and static variables from windows/window.c. It turns out that this was wildly overoptimistic - I missed quite a few of them! I'm not quite sure how I managed that; my best guess is that I used an underpowered 'nm' command that failed to find some classes of variable. Some of the remaining function-scope statics were removed completely by commit afb3dab1e97a09f just now. In this commit, I've swept up some more and turn them into fields of WinGuiSeat, where they should have been moved last September. The (hopefully complete this time) list of remaining variables, generated by running this rune in the Windows build directory: nm windows/CMakeFiles/putty.dir/window.c.obj | grep -E '^([^ ]+)? *[bBcCdDgGsS] [^\.]' consists of the following variables which are legitimately global across the whole process and not related to a particular window: - 'hinst' and 'hprev', instance handles for Windows loadable modules - 'classname' in the terminal_window_class_a() and terminal_window_class_w() functions, which allocate a window class reusably - some pointers to Windows API functions retrieved via the DECL_WINDOWS_FUNCTION / GET_WINDOWS_FUNCTION system, such as p_AdjustWindowRectExForDpi and p_FlashWindowEx - some pointers to Windows API functions set up by assigning them at startup to the right one of the ANSI or Unicode version depending on the Windows version, e.g. sw_DefWindowProc and sw_DispatchMessage - 'unicode_window', a boolean flag set at the same time as those sw_Foo function pointers - 'sesslist', storing the last-retrieved version of the saved sessions menu - 'cursor_visible' in show_mouseptr() and 'forced_visible' in update_mouse_pointer(), each of which tracks the cumulative number of times that function has shown or hidden the mouse pointer, so as to manage its effect on the global state updated by ShowCursor - 'trust_icon', loaded from the executable's resources - 'wgslisthead', the list of all active WinGuiSeats - 'wm_mousewheel', the window-message id we use for mouse wheel events and the following which are nothing to do with our code: - '_OptionsStorage' in __local_stdio_printf_options() and __local_stdio_scanf_options(), which I'd never noticed before, but apparently are internal to a standard library header.
2023-05-27 13:59:20 +00:00
if (wParam == SIZE_MAXIMIZED && wgs->fullscr_on_max) {
wgs->fullscr_on_max = false;
wgs->processed_resize = false;
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
make_full_screen(wgs);
windows/window.c: move more variables into WinGuiSeat. In commit f9e572595bb8cb6 I claimed that I'd removed very nearly all the global and static variables from windows/window.c. It turns out that this was wildly overoptimistic - I missed quite a few of them! I'm not quite sure how I managed that; my best guess is that I used an underpowered 'nm' command that failed to find some classes of variable. Some of the remaining function-scope statics were removed completely by commit afb3dab1e97a09f just now. In this commit, I've swept up some more and turn them into fields of WinGuiSeat, where they should have been moved last September. The (hopefully complete this time) list of remaining variables, generated by running this rune in the Windows build directory: nm windows/CMakeFiles/putty.dir/window.c.obj | grep -E '^([^ ]+)? *[bBcCdDgGsS] [^\.]' consists of the following variables which are legitimately global across the whole process and not related to a particular window: - 'hinst' and 'hprev', instance handles for Windows loadable modules - 'classname' in the terminal_window_class_a() and terminal_window_class_w() functions, which allocate a window class reusably - some pointers to Windows API functions retrieved via the DECL_WINDOWS_FUNCTION / GET_WINDOWS_FUNCTION system, such as p_AdjustWindowRectExForDpi and p_FlashWindowEx - some pointers to Windows API functions set up by assigning them at startup to the right one of the ANSI or Unicode version depending on the Windows version, e.g. sw_DefWindowProc and sw_DispatchMessage - 'unicode_window', a boolean flag set at the same time as those sw_Foo function pointers - 'sesslist', storing the last-retrieved version of the saved sessions menu - 'cursor_visible' in show_mouseptr() and 'forced_visible' in update_mouse_pointer(), each of which tracks the cumulative number of times that function has shown or hidden the mouse pointer, so as to manage its effect on the global state updated by ShowCursor - 'trust_icon', loaded from the executable's resources - 'wgslisthead', the list of all active WinGuiSeats - 'wm_mousewheel', the window-message id we use for mouse wheel events and the following which are nothing to do with our code: - '_OptionsStorage' in __local_stdio_printf_options() and __local_stdio_scanf_options(), which I'd never noticed before, but apparently are internal to a standard library header.
2023-05-27 13:59:20 +00:00
if (wgs->processed_resize) {
Fix resize handling when enabling and disabling full-screen mode. I'm not sure whether I broke this in the recent revamp or whether it was always broken, but: transitions in and out of full-screen mode work by first maximising or restoring the window, which triggers a WM_SIZE, whose handler then fiddles with the window style to disable or re-enable all the furniture, which in turn triggers a recursive WM_SIZE. The trouble is, after returning from the handler for the inner WM_SIZE, the rest of the outer handler runs, and its client area size is now out of date. So I've added a flag which is set when a resize is handled 'properly', so that after returning from the inner WM_SIZE handler the outer one knows not to try to redo badly work that's already been done well. [originally from svn r9056]
2010-12-27 12:58:39 +00:00
/*
* Inhibit normal processing of this WM_SIZE; a
* secondary one was triggered just now by
* make_full_screen which contained the correct client
* area size.
*/
return 0;
}
Fixes to full-screen mode. There were various problems when you went full-screen, then selected Change Settings and then changed the resize behaviour, ranging from the window staying FS but acquiring borders to the window restoring its previous size and _failing_ to acquire borders. Should now all be fixed. [originally from svn r1470]
2001-12-11 18:47:55 +00:00
}
Three more patches from RDB: one to make Atomica work right, one to fiddle with the widths of characters in DBCS screen fonts, and (the big one) one to enable a mode in which resizing the window locks the terminal size and lets the font change, instead of vice versa. That should shut up a few feature requests! [originally from svn r1269]
2001-09-15 15:54:24 +00:00
windows/window.c: move more variables into WinGuiSeat. In commit f9e572595bb8cb6 I claimed that I'd removed very nearly all the global and static variables from windows/window.c. It turns out that this was wildly overoptimistic - I missed quite a few of them! I'm not quite sure how I managed that; my best guess is that I used an underpowered 'nm' command that failed to find some classes of variable. Some of the remaining function-scope statics were removed completely by commit afb3dab1e97a09f just now. In this commit, I've swept up some more and turn them into fields of WinGuiSeat, where they should have been moved last September. The (hopefully complete this time) list of remaining variables, generated by running this rune in the Windows build directory: nm windows/CMakeFiles/putty.dir/window.c.obj | grep -E '^([^ ]+)? *[bBcCdDgGsS] [^\.]' consists of the following variables which are legitimately global across the whole process and not related to a particular window: - 'hinst' and 'hprev', instance handles for Windows loadable modules - 'classname' in the terminal_window_class_a() and terminal_window_class_w() functions, which allocate a window class reusably - some pointers to Windows API functions retrieved via the DECL_WINDOWS_FUNCTION / GET_WINDOWS_FUNCTION system, such as p_AdjustWindowRectExForDpi and p_FlashWindowEx - some pointers to Windows API functions set up by assigning them at startup to the right one of the ANSI or Unicode version depending on the Windows version, e.g. sw_DefWindowProc and sw_DispatchMessage - 'unicode_window', a boolean flag set at the same time as those sw_Foo function pointers - 'sesslist', storing the last-retrieved version of the saved sessions menu - 'cursor_visible' in show_mouseptr() and 'forced_visible' in update_mouse_pointer(), each of which tracks the cumulative number of times that function has shown or hidden the mouse pointer, so as to manage its effect on the global state updated by ShowCursor - 'trust_icon', loaded from the executable's resources - 'wgslisthead', the list of all active WinGuiSeats - 'wm_mousewheel', the window-message id we use for mouse wheel events and the following which are nothing to do with our code: - '_OptionsStorage' in __local_stdio_printf_options() and __local_stdio_scanf_options(), which I'd never noticed before, but apparently are internal to a standard library header.
2023-05-27 13:59:20 +00:00
wgs->processed_resize = true;
Fix resize handling when enabling and disabling full-screen mode. I'm not sure whether I broke this in the recent revamp or whether it was always broken, but: transitions in and out of full-screen mode work by first maximising or restoring the window, which triggers a WM_SIZE, whose handler then fiddles with the window style to disable or re-enable all the furniture, which in turn triggers a recursive WM_SIZE. The trouble is, after returning from the handler for the inner WM_SIZE, the rest of the outer handler runs, and its client area size is now out of date. So I've added a flag which is set when a resize is handled 'properly', so that after returning from the inner WM_SIZE handler the outer one knows not to try to redo badly work that's already been done well. [originally from svn r9056]
2010-12-27 12:58:39 +00:00
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
if (resize_action == RESIZE_DISABLED) {
/* A resize, well it better be a minimize. */
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
reset_window(wgs, -1);
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
} else {
Windows: fix resizing of a maximised window. The RESIZE_EITHER resizing mode responds to a window resize by changing the logical terminal size if the window is shown normally, or by changing the font size to keep the terminal size the same if the resize is a transition between normal and maximised state. But a user pointed out that it's also possible for a window to receive a WM_SIZE message while _remaining_ in maximised state, and that PuTTY's resize logic didn't allow for that possibility. It occurs when there's a change in the amount of available screen space for the window to be maximised _in_: e.g. when the video resolution is reconfigured, or when you reconnect to a Remote Desktop session using a client window of a different size, or even when you toggle the 'Automatically hide the taskbar' option in the Windows taskbar settings. In that situation, the right thing seems to be for PuTTY to continue to go with the policy of changing the font size rather than the logical terminal size. In other words, we prefer to change the font size when the resize is _from_ maximised state, _to_ maximised state, _or both_. That's easily implemented by removing the check of the 'was_zoomed' flag, in the case where we've received a WM_SIZE message with the state SIZE_MAXIMIZED: once we know the transition is _to_ maximised state, it doesn't matter whether or not it was also _from_ it. (But we still set the was_zoomed flag to the most recent maximised status, so that we can recognise transitions _out_ of maximised mode.)
2019-09-08 12:40:14 +00:00
if (wParam == SIZE_MAXIMIZED) {
windows/window.c: move more variables into WinGuiSeat. In commit f9e572595bb8cb6 I claimed that I'd removed very nearly all the global and static variables from windows/window.c. It turns out that this was wildly overoptimistic - I missed quite a few of them! I'm not quite sure how I managed that; my best guess is that I used an underpowered 'nm' command that failed to find some classes of variable. Some of the remaining function-scope statics were removed completely by commit afb3dab1e97a09f just now. In this commit, I've swept up some more and turn them into fields of WinGuiSeat, where they should have been moved last September. The (hopefully complete this time) list of remaining variables, generated by running this rune in the Windows build directory: nm windows/CMakeFiles/putty.dir/window.c.obj | grep -E '^([^ ]+)? *[bBcCdDgGsS] [^\.]' consists of the following variables which are legitimately global across the whole process and not related to a particular window: - 'hinst' and 'hprev', instance handles for Windows loadable modules - 'classname' in the terminal_window_class_a() and terminal_window_class_w() functions, which allocate a window class reusably - some pointers to Windows API functions retrieved via the DECL_WINDOWS_FUNCTION / GET_WINDOWS_FUNCTION system, such as p_AdjustWindowRectExForDpi and p_FlashWindowEx - some pointers to Windows API functions set up by assigning them at startup to the right one of the ANSI or Unicode version depending on the Windows version, e.g. sw_DefWindowProc and sw_DispatchMessage - 'unicode_window', a boolean flag set at the same time as those sw_Foo function pointers - 'sesslist', storing the last-retrieved version of the saved sessions menu - 'cursor_visible' in show_mouseptr() and 'forced_visible' in update_mouse_pointer(), each of which tracks the cumulative number of times that function has shown or hidden the mouse pointer, so as to manage its effect on the global state updated by ShowCursor - 'trust_icon', loaded from the executable's resources - 'wgslisthead', the list of all active WinGuiSeats - 'wm_mousewheel', the window-message id we use for mouse wheel events and the following which are nothing to do with our code: - '_OptionsStorage' in __local_stdio_printf_options() and __local_stdio_scanf_options(), which I'd never noticed before, but apparently are internal to a standard library header.
2023-05-27 13:59:20 +00:00
wgs->was_zoomed = true;
wgs->prev_rows = wgs->term->rows;
wgs->prev_cols = wgs->term->cols;
Windows: make the need_backend_resize mechanism consistent. There were three separate clauses in the WM_SIZE message handler which potentially called term_size() to resize the actual Terminal object. Two of them (for maximisation and normal non-maximised resizing drags) first checked if an interactive resize was in progress, and if so, instead set the need_backend_resize, to defer the term_size call to the end of the interactive operation. But the third, for _un_-maximising a window, didn't have that check. As a result, if you start with a maximised window, drag its title bar downward from the top of the screen (which unmaximises it), and without letting go, drag it back up again (which maximises it), the effect would be that you'd get one call to term_size in the middle of the drag, and a second at the end. This isn't what I intended, and it can also cause a redraw failure in full-screen applications on the server (such as a terminal-based text editor - I reproduced this with emacs), in which after the second term_size the terminal doesn't manage to redraw itself. Now I've pulled out the common logic that was in two of those three pieces of code (and should have been in all three) into a subroutine wm_size_resize_term, and arranged to call that in all three cases. This fixes the inconsistency, and also fixes the emacs redraw problem in the edge case I describe above.
2021-02-07 19:59:21 +00:00
if (resize_action == RESIZE_TERM)
Re-fix retention of window border on maximise. The fix in commit 31ab5b8e3083d66 was incomplete. It works when you maximise the window by pressing the maximise button in the title bar, but not when you drag the window to the very top of the screen. In the latter case, the resize at the instant of maximisation works right, but then we get a WM_EXITSIZEMOVE when the drag is released, triggering one final resize which ignored the window border again. That was because wm_size_resize_term() was being given a flag on purpose telling it to ignore the border: apparently at some point in the past, ignoring the border for even a normally maximised window (not even full-screen) was done on purpose. But for the reasons in the previous commit, I'm changing that.
2024-11-23 11:17:07 +00:00
wm_size_resize_term(wgs, lParam);
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
reset_window(wgs, 0);
windows/window.c: move more variables into WinGuiSeat. In commit f9e572595bb8cb6 I claimed that I'd removed very nearly all the global and static variables from windows/window.c. It turns out that this was wildly overoptimistic - I missed quite a few of them! I'm not quite sure how I managed that; my best guess is that I used an underpowered 'nm' command that failed to find some classes of variable. Some of the remaining function-scope statics were removed completely by commit afb3dab1e97a09f just now. In this commit, I've swept up some more and turn them into fields of WinGuiSeat, where they should have been moved last September. The (hopefully complete this time) list of remaining variables, generated by running this rune in the Windows build directory: nm windows/CMakeFiles/putty.dir/window.c.obj | grep -E '^([^ ]+)? *[bBcCdDgGsS] [^\.]' consists of the following variables which are legitimately global across the whole process and not related to a particular window: - 'hinst' and 'hprev', instance handles for Windows loadable modules - 'classname' in the terminal_window_class_a() and terminal_window_class_w() functions, which allocate a window class reusably - some pointers to Windows API functions retrieved via the DECL_WINDOWS_FUNCTION / GET_WINDOWS_FUNCTION system, such as p_AdjustWindowRectExForDpi and p_FlashWindowEx - some pointers to Windows API functions set up by assigning them at startup to the right one of the ANSI or Unicode version depending on the Windows version, e.g. sw_DefWindowProc and sw_DispatchMessage - 'unicode_window', a boolean flag set at the same time as those sw_Foo function pointers - 'sesslist', storing the last-retrieved version of the saved sessions menu - 'cursor_visible' in show_mouseptr() and 'forced_visible' in update_mouse_pointer(), each of which tracks the cumulative number of times that function has shown or hidden the mouse pointer, so as to manage its effect on the global state updated by ShowCursor - 'trust_icon', loaded from the executable's resources - 'wgslisthead', the list of all active WinGuiSeats - 'wm_mousewheel', the window-message id we use for mouse wheel events and the following which are nothing to do with our code: - '_OptionsStorage' in __local_stdio_printf_options() and __local_stdio_scanf_options(), which I'd never noticed before, but apparently are internal to a standard library header.
2023-05-27 13:59:20 +00:00
} else if (wParam == SIZE_RESTORED && wgs->was_zoomed) {
wgs->was_zoomed = false;
Post-release destabilisation! Completely remove the struct type 'Config' in putty.h, which stores all PuTTY's settings and includes an arbitrary length limit on every single one of those settings which is stored in string form. In place of it is 'Conf', an opaque data type everywhere outside the new file conf.c, which stores a list of (key, value) pairs in which every key contains an integer identifying a configuration setting, and for some of those integers the key also contains extra parts (so that, for instance, CONF_environmt is a string-to-string mapping). Everywhere that a Config was previously used, a Conf is now; everywhere there was a Config structure copy, conf_copy() is called; every lookup, adjustment, load and save operation on a Config has been rewritten; and there's a mechanism for serialising a Conf into a binary blob and back for use with Duplicate Session. User-visible effects of this change _should_ be minimal, though I don't doubt I've introduced one or two bugs here and there which will eventually be found. The _intended_ visible effects of this change are that all arbitrary limits on configuration strings and lists (e.g. limit on number of port forwardings) should now disappear; that list boxes in the configuration will now be displayed in a sorted order rather than the arbitrary order in which they were added to the list (since the underlying data structure is now a sorted tree234 rather than an ad-hoc comma-separated string); and one more specific change, which is that local and dynamic port forwardings on the same port number are now mutually exclusive in the configuration (putting 'D' in the key rather than the value was a mistake in the first place). One other reorganisation as a result of this is that I've moved all the dialog.c standard handlers (dlg_stdeditbox_handler and friends) out into config.c, because I can't really justify calling them generic any more. When they took a pointer to an arbitrary structure type and the offset of a field within that structure, they were independent of whether that structure was a Config or something completely different, but now they really do expect to talk to a Conf, which can _only_ be used for PuTTY configuration, so I've renamed them all things like conf_editbox_handler and moved them out of the nominally independent dialog-box management module into the PuTTY-specific config.c. [originally from svn r9214]
2011-07-14 18:52:21 +00:00
if (resize_action == RESIZE_TERM) {
Re-fix retention of window border on maximise. The fix in commit 31ab5b8e3083d66 was incomplete. It works when you maximise the window by pressing the maximise button in the title bar, but not when you drag the window to the very top of the screen. In the latter case, the resize at the instant of maximisation works right, but then we get a WM_EXITSIZEMOVE when the drag is released, triggering one final resize which ignored the window border again. That was because wm_size_resize_term() was being given a flag on purpose telling it to ignore the border: apparently at some point in the past, ignoring the border for even a normally maximised window (not even full-screen) was done on purpose. But for the reasons in the previous commit, I'm changing that.
2024-11-23 11:17:07 +00:00
wm_size_resize_term(wgs, lParam);
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
reset_window(wgs, 2);
Post-release destabilisation! Completely remove the struct type 'Config' in putty.h, which stores all PuTTY's settings and includes an arbitrary length limit on every single one of those settings which is stored in string form. In place of it is 'Conf', an opaque data type everywhere outside the new file conf.c, which stores a list of (key, value) pairs in which every key contains an integer identifying a configuration setting, and for some of those integers the key also contains extra parts (so that, for instance, CONF_environmt is a string-to-string mapping). Everywhere that a Config was previously used, a Conf is now; everywhere there was a Config structure copy, conf_copy() is called; every lookup, adjustment, load and save operation on a Config has been rewritten; and there's a mechanism for serialising a Conf into a binary blob and back for use with Duplicate Session. User-visible effects of this change _should_ be minimal, though I don't doubt I've introduced one or two bugs here and there which will eventually be found. The _intended_ visible effects of this change are that all arbitrary limits on configuration strings and lists (e.g. limit on number of port forwardings) should now disappear; that list boxes in the configuration will now be displayed in a sorted order rather than the arbitrary order in which they were added to the list (since the underlying data structure is now a sorted tree234 rather than an ad-hoc comma-separated string); and one more specific change, which is that local and dynamic port forwardings on the same port number are now mutually exclusive in the configuration (putting 'D' in the key rather than the value was a mistake in the first place). One other reorganisation as a result of this is that I've moved all the dialog.c standard handlers (dlg_stdeditbox_handler and friends) out into config.c, because I can't really justify calling them generic any more. When they took a pointer to an arbitrary structure type and the offset of a field within that structure, they were independent of whether that structure was a Config or something completely different, but now they really do expect to talk to a Conf, which can _only_ be used for PuTTY configuration, so I've renamed them all things like conf_editbox_handler and moved them out of the nominally independent dialog-box management module into the PuTTY-specific config.c. [originally from svn r9214]
2011-07-14 18:52:21 +00:00
} else if (resize_action != RESIZE_FONT)
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
reset_window(wgs, 2);
Reorganise handling of WM_SIZE to fix two generality problems. Firstly, maximise and restore events were expected never to occur during an interactive resize process (i.e. between WM_ENTERSIZEMOVE and WM_EXITSIZEMOVE), but in fact Aero now allows this to happen if you move the pointer to the top of the screen while dragging the window. Secondly, plain old WM_SIZE events were expected never to occur _outside_ interactive resizes, but Aero permits that too (e.g. Windows-left and Windows-right), and also third-party window repositioning tools will send these. [originally from svn r9040]
2010-12-22 15:49:33 +00:00
else
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
reset_window(wgs, 0);
Reorganise handling of WM_SIZE to fix two generality problems. Firstly, maximise and restore events were expected never to occur during an interactive resize process (i.e. between WM_ENTERSIZEMOVE and WM_EXITSIZEMOVE), but in fact Aero now allows this to happen if you move the pointer to the top of the screen while dragging the window. Secondly, plain old WM_SIZE events were expected never to occur _outside_ interactive resizes, but Aero permits that too (e.g. Windows-left and Windows-right), and also third-party window repositioning tools will send these. [originally from svn r9040]
2010-12-22 15:49:33 +00:00
} else if (wParam == SIZE_MINIMIZED) {
/* do nothing */
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
} else if (resize_action == RESIZE_TERM ||
Post-release destabilisation! Completely remove the struct type 'Config' in putty.h, which stores all PuTTY's settings and includes an arbitrary length limit on every single one of those settings which is stored in string form. In place of it is 'Conf', an opaque data type everywhere outside the new file conf.c, which stores a list of (key, value) pairs in which every key contains an integer identifying a configuration setting, and for some of those integers the key also contains extra parts (so that, for instance, CONF_environmt is a string-to-string mapping). Everywhere that a Config was previously used, a Conf is now; everywhere there was a Config structure copy, conf_copy() is called; every lookup, adjustment, load and save operation on a Config has been rewritten; and there's a mechanism for serialising a Conf into a binary blob and back for use with Duplicate Session. User-visible effects of this change _should_ be minimal, though I don't doubt I've introduced one or two bugs here and there which will eventually be found. The _intended_ visible effects of this change are that all arbitrary limits on configuration strings and lists (e.g. limit on number of port forwardings) should now disappear; that list boxes in the configuration will now be displayed in a sorted order rather than the arbitrary order in which they were added to the list (since the underlying data structure is now a sorted tree234 rather than an ad-hoc comma-separated string); and one more specific change, which is that local and dynamic port forwardings on the same port number are now mutually exclusive in the configuration (putting 'D' in the key rather than the value was a mistake in the first place). One other reorganisation as a result of this is that I've moved all the dialog.c standard handlers (dlg_stdeditbox_handler and friends) out into config.c, because I can't really justify calling them generic any more. When they took a pointer to an arbitrary structure type and the offset of a field within that structure, they were independent of whether that structure was a Config or something completely different, but now they really do expect to talk to a Conf, which can _only_ be used for PuTTY configuration, so I've renamed them all things like conf_editbox_handler and moved them out of the nominally independent dialog-box management module into the PuTTY-specific config.c. [originally from svn r9214]
2011-07-14 18:52:21 +00:00
(resize_action == RESIZE_EITHER &&
The special treatment of Alt-resize (to cause resizing to affect the font instead of the terminal size) should only be active in RESIZE_EITHER mode - in RESIZE_TERM it is worse than useless. [originally from svn r9045]
2010-12-23 17:16:19 +00:00
!is_alt_pressed())) {
Re-fix retention of window border on maximise. The fix in commit 31ab5b8e3083d66 was incomplete. It works when you maximise the window by pressing the maximise button in the title bar, but not when you drag the window to the very top of the screen. In the latter case, the resize at the instant of maximisation works right, but then we get a WM_EXITSIZEMOVE when the drag is released, triggering one final resize which ignored the window border again. That was because wm_size_resize_term() was being given a flag on purpose telling it to ignore the border: apparently at some point in the past, ignoring the border for even a normally maximised window (not even full-screen) was done on purpose. But for the reasons in the previous commit, I'm changing that.
2024-11-23 11:17:07 +00:00
wm_size_resize_term(wgs, lParam);
Fix missing recalculation of window border. If you open a Windows PuTTY session and press Win+Right, Windows auto-sizes the terminal window to cover the right-hand half of the screen. Then if you press Win+Up it will be auto-sized again, this time to the top right quadrant. In the second resize (if you don't have font-based resize handling turned on), the WM_SIZE handler code will find a path through the twisty maze of ifs on which the border between the text and the client-area edges is not recomputed, or invalidated, or redrawn. So you can end up with half a line of text from the previous window size still visible at the bottom of the new window. Fixed by factoring out the offset-recomputation code from the large and complicated reset_window(), so that I can call just that snippet on the dangerous code path.
2021-02-12 17:50:47 +00:00
/*
* Sometimes, we can get a spontaneous resize event
* outside a WM_SIZING interactive drag which wants to
* set us to a new specific SIZE_RESTORED size. An
* example is what happens if you press Windows+Right
* and then Windows+Up: the first operation fits the
* window to the right-hand half of the screen, and
* the second one changes that for the top right
* quadrant. In that situation, if we've responded
* here by resizing the terminal, we may still need to
* recompute the border around the window and do a
* full redraw to clear the new border.
*/
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
if (!wgs->resizing)
recompute_window_offset(wgs);
Reorganise handling of WM_SIZE to fix two generality problems. Firstly, maximise and restore events were expected never to occur during an interactive resize process (i.e. between WM_ENTERSIZEMOVE and WM_EXITSIZEMOVE), but in fact Aero now allows this to happen if you move the pointer to the top of the screen while dragging the window. Secondly, plain old WM_SIZE events were expected never to occur _outside_ interactive resizes, but Aero permits that too (e.g. Windows-left and Windows-right), and also third-party window repositioning tools will send these. [originally from svn r9040]
2010-12-22 15:49:33 +00:00
} else {
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
reset_window(wgs, 0);
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
}
}
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
sys_cursor_update(wgs);
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
return 0;
Windows 10: add per monitor DPI awareness support. On a system with 2 or more displays with different DPI settings, moving the PuTTY window from one display to another will make Windows resize the window using its "bitmap" strategy, stretching/compressing the text, making it fuzzy and harder to read. This change makes PuTTY resize its window and font size to accurately fit the DPI of the display it is on. We process the WM_DPICHANGED message, saving the new DPI, window size and position. We proceed to then reset the window, recreating the fonts using the new DPI and calculate the new window size and position based on the new font size, user display options (ie. with/without scrollbar) and the suggested window position provided by Windows. The suggested window size is usually not a perfect fit, therefore we must add a small offset to the new window position in order to avoid issues with repeated DPI changes while dragging the window from one display to another.
2021-03-29 15:31:13 +00:00
case WM_DPICHANGED:
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
wgs->dpi_info.cur_dpi.x = LOWORD(wParam);
wgs->dpi_info.cur_dpi.y = HIWORD(wParam);
wgs->dpi_info.new_wnd_rect = *(RECT*)(lParam);
reset_window(wgs, 3);
Windows 10: add per monitor DPI awareness support. On a system with 2 or more displays with different DPI settings, moving the PuTTY window from one display to another will make Windows resize the window using its "bitmap" strategy, stretching/compressing the text, making it fuzzy and harder to read. This change makes PuTTY resize its window and font size to accurately fit the DPI of the display it is on. We process the WM_DPICHANGED message, saving the new DPI, window size and position. We proceed to then reset the window, recreating the fonts using the new DPI and calculate the new window size and position based on the new font size, user display options (ie. with/without scrollbar) and the suggested window position provided by Windows. The suggested window size is usually not a perfect fit, therefore we must add a small offset to the new window position in order to avoid issues with repeated DPI changes while dragging the window from one display to another.
2021-03-29 15:31:13 +00:00
return 0;
Initial checkin: beta 0.43 [originally from svn r11]
1999-01-08 13:02:13 +00:00
case WM_VSCROLL:
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
switch (LOWORD(wParam)) {
case SB_BOTTOM:
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
term_scroll(wgs->term, -1, 0);
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
break;
case SB_TOP:
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
term_scroll(wgs->term, +1, 0);
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
break;
case SB_LINEDOWN:
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
term_scroll(wgs->term, 0, +1);
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
break;
case SB_LINEUP:
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
term_scroll(wgs->term, 0, -1);
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
break;
case SB_PAGEDOWN:
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
term_scroll(wgs->term, 0, +wgs->term->rows / 2);
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
break;
case SB_PAGEUP:
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
term_scroll(wgs->term, 0, -wgs->term->rows / 2);
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
break;
case SB_THUMBPOSITION:
Formatting change to braces around one case of a switch. Sometimes, within a switch statement, you want to declare local variables specific to the handler for one particular case. Until now I've mostly been writing this in the form switch (discriminant) { case SIMPLE: do stuff; break; case COMPLICATED: { declare variables; do stuff; } break; } which is ugly because the two pieces of essentially similar code appear at different indent levels, and also inconvenient because you have less horizontal space available to write the complicated case handler in - particuarly undesirable because _complicated_ case handlers are the ones most likely to need all the space they can get! After encountering a rather nicer idiom in the LLVM source code, and after a bit of hackery this morning figuring out how to persuade Emacs's auto-indent to do what I wanted with it, I've decided to move to an idiom in which the open brace comes right after the case statement, and the code within it is indented the same as it would have been without the brace. Then the whole case handler (including the break) lives inside those braces, and you get something that looks more like this: switch (discriminant) { case SIMPLE: do stuff; break; case COMPLICATED: { declare variables; do stuff; break; } } This commit is a big-bang change that reformats all the complicated case handlers I could find into the new layout. This is particularly nice in the Pageant main function, in which almost _every_ case handler had a bundle of variables and was long and complicated. (In fact that's what motivated me to get round to this.) Some of the innermost parts of the terminal escape-sequence handling are also breathing a bit easier now the horizontal pressure on them is relieved. (Also, in a few cases, I was able to remove the extra braces completely, because the only variable local to the case handler was a loop variable which our new C99 policy allows me to move into the initialiser clause of its for statement.) Viewed with whitespace ignored, this is not too disruptive a change. Downstream patches that conflict with it may need to be reapplied using --ignore-whitespace or similar.
2020-02-16 07:49:52 +00:00
case SB_THUMBTRACK: {
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
/*
* Use GetScrollInfo instead of HIWORD(wParam) to get
* 32-bit scroll position.
*/
Formatting change to braces around one case of a switch. Sometimes, within a switch statement, you want to declare local variables specific to the handler for one particular case. Until now I've mostly been writing this in the form switch (discriminant) { case SIMPLE: do stuff; break; case COMPLICATED: { declare variables; do stuff; } break; } which is ugly because the two pieces of essentially similar code appear at different indent levels, and also inconvenient because you have less horizontal space available to write the complicated case handler in - particuarly undesirable because _complicated_ case handlers are the ones most likely to need all the space they can get! After encountering a rather nicer idiom in the LLVM source code, and after a bit of hackery this morning figuring out how to persuade Emacs's auto-indent to do what I wanted with it, I've decided to move to an idiom in which the open brace comes right after the case statement, and the code within it is indented the same as it would have been without the brace. Then the whole case handler (including the break) lives inside those braces, and you get something that looks more like this: switch (discriminant) { case SIMPLE: do stuff; break; case COMPLICATED: { declare variables; do stuff; break; } } This commit is a big-bang change that reformats all the complicated case handlers I could find into the new layout. This is particularly nice in the Pageant main function, in which almost _every_ case handler had a bundle of variables and was long and complicated. (In fact that's what motivated me to get round to this.) Some of the innermost parts of the terminal escape-sequence handling are also breathing a bit easier now the horizontal pressure on them is relieved. (Also, in a few cases, I was able to remove the extra braces completely, because the only variable local to the case handler was a loop variable which our new C99 policy allows me to move into the initialiser clause of its for statement.) Viewed with whitespace ignored, this is not too disruptive a change. Downstream patches that conflict with it may need to be reapplied using --ignore-whitespace or similar.
2020-02-16 07:49:52 +00:00
SCROLLINFO si;
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
Formatting change to braces around one case of a switch. Sometimes, within a switch statement, you want to declare local variables specific to the handler for one particular case. Until now I've mostly been writing this in the form switch (discriminant) { case SIMPLE: do stuff; break; case COMPLICATED: { declare variables; do stuff; } break; } which is ugly because the two pieces of essentially similar code appear at different indent levels, and also inconvenient because you have less horizontal space available to write the complicated case handler in - particuarly undesirable because _complicated_ case handlers are the ones most likely to need all the space they can get! After encountering a rather nicer idiom in the LLVM source code, and after a bit of hackery this morning figuring out how to persuade Emacs's auto-indent to do what I wanted with it, I've decided to move to an idiom in which the open brace comes right after the case statement, and the code within it is indented the same as it would have been without the brace. Then the whole case handler (including the break) lives inside those braces, and you get something that looks more like this: switch (discriminant) { case SIMPLE: do stuff; break; case COMPLICATED: { declare variables; do stuff; break; } } This commit is a big-bang change that reformats all the complicated case handlers I could find into the new layout. This is particularly nice in the Pageant main function, in which almost _every_ case handler had a bundle of variables and was long and complicated. (In fact that's what motivated me to get round to this.) Some of the innermost parts of the terminal escape-sequence handling are also breathing a bit easier now the horizontal pressure on them is relieved. (Also, in a few cases, I was able to remove the extra braces completely, because the only variable local to the case handler was a loop variable which our new C99 policy allows me to move into the initialiser clause of its for statement.) Viewed with whitespace ignored, this is not too disruptive a change. Downstream patches that conflict with it may need to be reapplied using --ignore-whitespace or similar.
2020-02-16 07:49:52 +00:00
si.cbSize = sizeof(si);
si.fMask = SIF_TRACKPOS;
if (GetScrollInfo(hwnd, SB_VERT, &si) == 0)
si.nTrackPos = HIWORD(wParam);
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
term_scroll(wgs->term, 1, si.nTrackPos);
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
break;
Formatting change to braces around one case of a switch. Sometimes, within a switch statement, you want to declare local variables specific to the handler for one particular case. Until now I've mostly been writing this in the form switch (discriminant) { case SIMPLE: do stuff; break; case COMPLICATED: { declare variables; do stuff; } break; } which is ugly because the two pieces of essentially similar code appear at different indent levels, and also inconvenient because you have less horizontal space available to write the complicated case handler in - particuarly undesirable because _complicated_ case handlers are the ones most likely to need all the space they can get! After encountering a rather nicer idiom in the LLVM source code, and after a bit of hackery this morning figuring out how to persuade Emacs's auto-indent to do what I wanted with it, I've decided to move to an idiom in which the open brace comes right after the case statement, and the code within it is indented the same as it would have been without the brace. Then the whole case handler (including the break) lives inside those braces, and you get something that looks more like this: switch (discriminant) { case SIMPLE: do stuff; break; case COMPLICATED: { declare variables; do stuff; break; } } This commit is a big-bang change that reformats all the complicated case handlers I could find into the new layout. This is particularly nice in the Pageant main function, in which almost _every_ case handler had a bundle of variables and was long and complicated. (In fact that's what motivated me to get round to this.) Some of the innermost parts of the terminal escape-sequence handling are also breathing a bit easier now the horizontal pressure on them is relieved. (Also, in a few cases, I was able to remove the extra braces completely, because the only variable local to the case handler was a loop variable which our new C99 policy allows me to move into the initialiser clause of its for statement.) Viewed with whitespace ignored, this is not too disruptive a change. Downstream patches that conflict with it may need to be reapplied using --ignore-whitespace or similar.
2020-02-16 07:49:52 +00:00
}
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
}
Restore missing screen updates from scrollbar buttons. In commit f69cf86a61a8109, I added a call to term_update that happens when we receive WM_VSCROLL / SB_THUMBPOSITION in the subsidiary message loop that Windows creates during the handling of WM_SYSCOMMAND / SC_VSCROLL. The effect was that interactive dragging of the scrollbar now redraws the window at every step, whereas previously it didn't. A user just pointed out that if you click on one of the scrollbar end buttons and hold it down until it begins emulating key repeat, the same bug occurs: the window isn't redrawn until you release the mouse button and the subsidiary message loop ends. This commit extends the previous fix to cover all of the WM_VSCROLL subtypes, instead of just SB_THUMBPOSITION and SB_THUMBTRACK. Redraws while holding down those scrollbar buttons now work again.
2021-07-01 17:25:56 +00:00
windows/window.c: move more variables into WinGuiSeat. In commit f9e572595bb8cb6 I claimed that I'd removed very nearly all the global and static variables from windows/window.c. It turns out that this was wildly overoptimistic - I missed quite a few of them! I'm not quite sure how I managed that; my best guess is that I used an underpowered 'nm' command that failed to find some classes of variable. Some of the remaining function-scope statics were removed completely by commit afb3dab1e97a09f just now. In this commit, I've swept up some more and turn them into fields of WinGuiSeat, where they should have been moved last September. The (hopefully complete this time) list of remaining variables, generated by running this rune in the Windows build directory: nm windows/CMakeFiles/putty.dir/window.c.obj | grep -E '^([^ ]+)? *[bBcCdDgGsS] [^\.]' consists of the following variables which are legitimately global across the whole process and not related to a particular window: - 'hinst' and 'hprev', instance handles for Windows loadable modules - 'classname' in the terminal_window_class_a() and terminal_window_class_w() functions, which allocate a window class reusably - some pointers to Windows API functions retrieved via the DECL_WINDOWS_FUNCTION / GET_WINDOWS_FUNCTION system, such as p_AdjustWindowRectExForDpi and p_FlashWindowEx - some pointers to Windows API functions set up by assigning them at startup to the right one of the ANSI or Unicode version depending on the Windows version, e.g. sw_DefWindowProc and sw_DispatchMessage - 'unicode_window', a boolean flag set at the same time as those sw_Foo function pointers - 'sesslist', storing the last-retrieved version of the saved sessions menu - 'cursor_visible' in show_mouseptr() and 'forced_visible' in update_mouse_pointer(), each of which tracks the cumulative number of times that function has shown or hidden the mouse pointer, so as to manage its effect on the global state updated by ShowCursor - 'trust_icon', loaded from the executable's resources - 'wgslisthead', the list of all active WinGuiSeats - 'wm_mousewheel', the window-message id we use for mouse wheel events and the following which are nothing to do with our code: - '_OptionsStorage' in __local_stdio_printf_options() and __local_stdio_scanf_options(), which I'd never noticed before, but apparently are internal to a standard library header.
2023-05-27 13:59:20 +00:00
if (wgs->in_scrollbar_loop) {
Restore missing screen updates from scrollbar buttons. In commit f69cf86a61a8109, I added a call to term_update that happens when we receive WM_VSCROLL / SB_THUMBPOSITION in the subsidiary message loop that Windows creates during the handling of WM_SYSCOMMAND / SC_VSCROLL. The effect was that interactive dragging of the scrollbar now redraws the window at every step, whereas previously it didn't. A user just pointed out that if you click on one of the scrollbar end buttons and hold it down until it begins emulating key repeat, the same bug occurs: the window isn't redrawn until you release the mouse button and the subsidiary message loop ends. This commit extends the previous fix to cover all of the WM_VSCROLL subtypes, instead of just SB_THUMBPOSITION and SB_THUMBTRACK. Redraws while holding down those scrollbar buttons now work again.
2021-07-01 17:25:56 +00:00
/*
* Allow window updates to happen during interactive
* scroll.
*
* When the user takes hold of our window's scrollbar and
* wobbles it interactively back and forth, or presses on
* one of the arrow buttons at the ends, the first thing
* that happens is that this window procedure receives
* WM_SYSCOMMAND / SC_VSCROLL. [1] The default handler for
* that window message starts a subsidiary message loop,
* which continues to run until the user lets go of the
* scrollbar again. All WM_VSCROLL / SB_THUMBTRACK
* messages are generated by the handlers within that
* subsidiary message loop.
*
* So, during that time, _our_ message loop is not
* running, which means toplevel callbacks and timers and
* so forth are not happening, which means that when we
* redraw the window and set a timer to clear the cooldown
* flag 20ms later, that timer never fires, and we aren't
* able to keep redrawing the window.
*
* The 'obvious' answer would be to seize that SYSCOMMAND
* ourselves and inhibit the default handler, so that our
* message loop carries on running. But that would mean
* we'd have to reimplement the whole of the scrollbar
* handler!
*
* So instead we apply a bodge: set a static variable that
* indicates that we're _in_ that sub-loop, and if so,
* decide it's OK to manually call term_update() proper,
* bypassing the timer and cooldown and rate-limiting
* systems completely, whenever we see an SB_THUMBTRACK.
* This shouldn't cause a rate overload, because we're
* only doing it once per UI event!
*
* [1] Actually, there's an extra oddity where SC_HSCROLL
* and SC_VSCROLL have their documented values the wrong
* way round. Many people on the Internet have noticed
* this, e.g. https://stackoverflow.com/q/55528397
*/
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
term_update(wgs->term);
Restore missing screen updates from scrollbar buttons. In commit f69cf86a61a8109, I added a call to term_update that happens when we receive WM_VSCROLL / SB_THUMBPOSITION in the subsidiary message loop that Windows creates during the handling of WM_SYSCOMMAND / SC_VSCROLL. The effect was that interactive dragging of the scrollbar now redraws the window at every step, whereas previously it didn't. A user just pointed out that if you click on one of the scrollbar end buttons and hold it down until it begins emulating key repeat, the same bug occurs: the window isn't redrawn until you release the mouse button and the subsidiary message loop ends. This commit extends the previous fix to cover all of the WM_VSCROLL subtypes, instead of just SB_THUMBPOSITION and SB_THUMBTRACK. Redraws while holding down those scrollbar buttons now work again.
2021-07-01 17:25:56 +00:00
}
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
break;
Run entire source base through GNU indent to tidy up the varying coding styles of the various contributors! Woohoo! [originally from svn r1098]
2001-05-06 14:35:20 +00:00
case WM_PALETTECHANGED:
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
if ((HWND) wParam != hwnd && wgs->pal != NULL) {
HDC hdc = make_hdc(wgs);
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
if (hdc) {
if (RealizePalette(hdc) > 0)
UpdateColors(hdc);
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
free_hdc(wgs, hdc);
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
}
}
break;
Initial checkin: beta 0.43 [originally from svn r11]
1999-01-08 13:02:13 +00:00
case WM_QUERYNEWPALETTE:
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
if (wgs->pal != NULL) {
HDC hdc = make_hdc(wgs);
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
if (hdc) {
if (RealizePalette(hdc) > 0)
UpdateColors(hdc);
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
free_hdc(wgs, hdc);
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
return true;
}
}
return false;
Initial checkin: beta 0.43 [originally from svn r11]
1999-01-08 13:02:13 +00:00
case WM_KEYDOWN:
case WM_SYSKEYDOWN:
Robert de Bath's Big Patch, part 1 [originally from svn r516]
2000-07-26 12:13:51 +00:00
case WM_KEYUP:
case WM_SYSKEYUP:
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
/*
* Add the scan code and keypress timing to the random
* number noise.
*/
noise_ultralight(NOISE_SOURCE_KEY, lParam);
/*
* We don't do TranslateMessage since it disassociates the
* resulting CHAR message from the KEYDOWN that sparked it,
* which we occasionally don't want. Instead, we process
* KEYDOWN, and call the Win32 translator functions so that
* we get the translations under _our_ control.
*/
{
unsigned char buf[20];
int len;
if (wParam == VK_PROCESSKEY || /* IME PROCESS key */
wParam == VK_PACKET) { /* 'this key is a Unicode char' */
if (message == WM_KEYDOWN) {
MSG m;
m.hwnd = hwnd;
m.message = WM_KEYDOWN;
m.wParam = wParam;
m.lParam = lParam & 0xdfff;
TranslateMessage(&m);
} else break; /* pass to Windows for default processing */
} else {
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
len = TranslateKey(wgs, message, wParam, lParam, buf);
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
if (len == -1)
Windows: runtime switch between Unicode and ANSI windows. Turns out that PuTTY hasn't run successfully on legacy Windows since 0.66, in spite of an ongoing intention to keep it working. Among the reasons for this is that CreateWindowExW simply fails with ERROR_CALL_NOT_IMPLEMENTED: apparently Win95 and its ilk just didn't have fully-Unicode windows as an option. Fixed by resurrecting the previous code from the git history (in particular, code removed by commit 67e5ceb9a8e6bc2 was useful), and including it as a runtime alternative. One subtlety was that I found I had to name the A and W window classes differently (by appending ".ansi" to the A one): apparently they occupy the same namespace even though the names are in different character sets, so if you somehow manage to register both classes, they'll collide with each other without that tweak.
2022-03-12 06:43:59 +00:00
return sw_DefWindowProc(hwnd, message, wParam, lParam);
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
if (len != 0) {
/*
* We need not bother about stdin backlogs
* here, because in GUI PuTTY we can't do
* anything about it anyway; there's no means
* of asking Windows to hold off on KEYDOWN
* messages. We _have_ to buffer everything
* we're sent.
*/
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
term_keyinput(wgs->term, -1, buf, len);
show_mouseptr(wgs, false);
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
}
}
}
return 0;
case WM_INPUTLANGCHANGE:
/* wParam == Font number */
/* lParam == Locale */
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
set_input_locale(wgs, (HKL)lParam);
sys_cursor_update(wgs);
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
break;
Formatting change to braces around one case of a switch. Sometimes, within a switch statement, you want to declare local variables specific to the handler for one particular case. Until now I've mostly been writing this in the form switch (discriminant) { case SIMPLE: do stuff; break; case COMPLICATED: { declare variables; do stuff; } break; } which is ugly because the two pieces of essentially similar code appear at different indent levels, and also inconvenient because you have less horizontal space available to write the complicated case handler in - particuarly undesirable because _complicated_ case handlers are the ones most likely to need all the space they can get! After encountering a rather nicer idiom in the LLVM source code, and after a bit of hackery this morning figuring out how to persuade Emacs's auto-indent to do what I wanted with it, I've decided to move to an idiom in which the open brace comes right after the case statement, and the code within it is indented the same as it would have been without the brace. Then the whole case handler (including the break) lives inside those braces, and you get something that looks more like this: switch (discriminant) { case SIMPLE: do stuff; break; case COMPLICATED: { declare variables; do stuff; break; } } This commit is a big-bang change that reformats all the complicated case handlers I could find into the new layout. This is particularly nice in the Pageant main function, in which almost _every_ case handler had a bundle of variables and was long and complicated. (In fact that's what motivated me to get round to this.) Some of the innermost parts of the terminal escape-sequence handling are also breathing a bit easier now the horizontal pressure on them is relieved. (Also, in a few cases, I was able to remove the extra braces completely, because the only variable local to the case handler was a loop variable which our new C99 policy allows me to move into the initialiser clause of its for statement.) Viewed with whitespace ignored, this is not too disruptive a change. Downstream patches that conflict with it may need to be reapplied using --ignore-whitespace or similar.
2020-02-16 07:49:52 +00:00
case WM_IME_STARTCOMPOSITION: {
HIMC hImc = ImmGetContext(hwnd);
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
ImmSetCompositionFont(hImc, &wgs->lfont);
Formatting change to braces around one case of a switch. Sometimes, within a switch statement, you want to declare local variables specific to the handler for one particular case. Until now I've mostly been writing this in the form switch (discriminant) { case SIMPLE: do stuff; break; case COMPLICATED: { declare variables; do stuff; } break; } which is ugly because the two pieces of essentially similar code appear at different indent levels, and also inconvenient because you have less horizontal space available to write the complicated case handler in - particuarly undesirable because _complicated_ case handlers are the ones most likely to need all the space they can get! After encountering a rather nicer idiom in the LLVM source code, and after a bit of hackery this morning figuring out how to persuade Emacs's auto-indent to do what I wanted with it, I've decided to move to an idiom in which the open brace comes right after the case statement, and the code within it is indented the same as it would have been without the brace. Then the whole case handler (including the break) lives inside those braces, and you get something that looks more like this: switch (discriminant) { case SIMPLE: do stuff; break; case COMPLICATED: { declare variables; do stuff; break; } } This commit is a big-bang change that reformats all the complicated case handlers I could find into the new layout. This is particularly nice in the Pageant main function, in which almost _every_ case handler had a bundle of variables and was long and complicated. (In fact that's what motivated me to get round to this.) Some of the innermost parts of the terminal escape-sequence handling are also breathing a bit easier now the horizontal pressure on them is relieved. (Also, in a few cases, I was able to remove the extra braces completely, because the only variable local to the case handler was a loop variable which our new C99 policy allows me to move into the initialiser clause of its for statement.) Viewed with whitespace ignored, this is not too disruptive a change. Downstream patches that conflict with it may need to be reapplied using --ignore-whitespace or similar.
2020-02-16 07:49:52 +00:00
ImmReleaseContext(hwnd, hImc);
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
break;
Formatting change to braces around one case of a switch. Sometimes, within a switch statement, you want to declare local variables specific to the handler for one particular case. Until now I've mostly been writing this in the form switch (discriminant) { case SIMPLE: do stuff; break; case COMPLICATED: { declare variables; do stuff; } break; } which is ugly because the two pieces of essentially similar code appear at different indent levels, and also inconvenient because you have less horizontal space available to write the complicated case handler in - particuarly undesirable because _complicated_ case handlers are the ones most likely to need all the space they can get! After encountering a rather nicer idiom in the LLVM source code, and after a bit of hackery this morning figuring out how to persuade Emacs's auto-indent to do what I wanted with it, I've decided to move to an idiom in which the open brace comes right after the case statement, and the code within it is indented the same as it would have been without the brace. Then the whole case handler (including the break) lives inside those braces, and you get something that looks more like this: switch (discriminant) { case SIMPLE: do stuff; break; case COMPLICATED: { declare variables; do stuff; break; } } This commit is a big-bang change that reformats all the complicated case handlers I could find into the new layout. This is particularly nice in the Pageant main function, in which almost _every_ case handler had a bundle of variables and was long and complicated. (In fact that's what motivated me to get round to this.) Some of the innermost parts of the terminal escape-sequence handling are also breathing a bit easier now the horizontal pressure on them is relieved. (Also, in a few cases, I was able to remove the extra braces completely, because the only variable local to the case handler was a loop variable which our new C99 policy allows me to move into the initialiser clause of its for statement.) Viewed with whitespace ignored, this is not too disruptive a change. Downstream patches that conflict with it may need to be reapplied using --ignore-whitespace or similar.
2020-02-16 07:49:52 +00:00
}
case WM_IME_COMPOSITION: {
HIMC hIMC;
int n;
char *buff;
if (osPlatformId == VER_PLATFORM_WIN32_WINDOWS ||
osPlatformId == VER_PLATFORM_WIN32s)
break; /* no Unicode */
if ((lParam & GCS_RESULTSTR) == 0) /* Composition unfinished. */
break; /* fall back to DefWindowProc */
hIMC = ImmGetContext(hwnd);
n = ImmGetCompositionStringW(hIMC, GCS_RESULTSTR, NULL, 0);
if (n > 0) {
Formatting: normalise back to 4-space indentation. In several pieces of development recently I've run across the occasional code block in the middle of a function which suddenly switched to 2-space indent from this code base's usual 4. I decided I was tired of it, so I ran the whole code base through a re-indenter, which made a huge mess, and then manually sifted out the changes that actually made sense from that pass. Indeed, this caught quite a few large sections with 2-space indent level, a couple with 8, and a handful of even weirder things like 3 spaces or 12. This commit fixes them all.
2022-08-03 19:48:46 +00:00
int i;
buff = snewn(n, char);
ImmGetCompositionStringW(hIMC, GCS_RESULTSTR, buff, n);
/*
* Jaeyoun Chung reports that Korean character
* input doesn't work correctly if we do a single
* term_keyinputw covering the whole of buff. So
* instead we send the characters one by one.
*/
/* don't divide SURROGATE PAIR */
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
if (wgs->ldisc) {
Formatting: normalise back to 4-space indentation. In several pieces of development recently I've run across the occasional code block in the middle of a function which suddenly switched to 2-space indent from this code base's usual 4. I decided I was tired of it, so I ran the whole code base through a re-indenter, which made a huge mess, and then manually sifted out the changes that actually made sense from that pass. Indeed, this caught quite a few large sections with 2-space indent level, a couple with 8, and a handful of even weirder things like 3 spaces or 12. This commit fixes them all.
2022-08-03 19:48:46 +00:00
for (i = 0; i < n; i += 2) {
WCHAR hs = *(unsigned short *)(buff+i);
if (IS_HIGH_SURROGATE(hs) && i+2 < n) {
WCHAR ls = *(unsigned short *)(buff+i+2);
if (IS_LOW_SURROGATE(ls)) {
term_keyinputw(
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
wgs->term, (unsigned short *)(buff+i), 2);
Formatting: normalise back to 4-space indentation. In several pieces of development recently I've run across the occasional code block in the middle of a function which suddenly switched to 2-space indent from this code base's usual 4. I decided I was tired of it, so I ran the whole code base through a re-indenter, which made a huge mess, and then manually sifted out the changes that actually made sense from that pass. Indeed, this caught quite a few large sections with 2-space indent level, a couple with 8, and a handful of even weirder things like 3 spaces or 12. This commit fixes them all.
2022-08-03 19:48:46 +00:00
i += 2;
continue;
}
}
term_keyinputw(
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
wgs->term, (unsigned short *)(buff+i), 1);
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
}
}
Formatting: normalise back to 4-space indentation. In several pieces of development recently I've run across the occasional code block in the middle of a function which suddenly switched to 2-space indent from this code base's usual 4. I decided I was tired of it, so I ran the whole code base through a re-indenter, which made a huge mess, and then manually sifted out the changes that actually made sense from that pass. Indeed, this caught quite a few large sections with 2-space indent level, a couple with 8, and a handful of even weirder things like 3 spaces or 12. This commit fixes them all.
2022-08-03 19:48:46 +00:00
free(buff);
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
}
Formatting change to braces around one case of a switch. Sometimes, within a switch statement, you want to declare local variables specific to the handler for one particular case. Until now I've mostly been writing this in the form switch (discriminant) { case SIMPLE: do stuff; break; case COMPLICATED: { declare variables; do stuff; } break; } which is ugly because the two pieces of essentially similar code appear at different indent levels, and also inconvenient because you have less horizontal space available to write the complicated case handler in - particuarly undesirable because _complicated_ case handlers are the ones most likely to need all the space they can get! After encountering a rather nicer idiom in the LLVM source code, and after a bit of hackery this morning figuring out how to persuade Emacs's auto-indent to do what I wanted with it, I've decided to move to an idiom in which the open brace comes right after the case statement, and the code within it is indented the same as it would have been without the brace. Then the whole case handler (including the break) lives inside those braces, and you get something that looks more like this: switch (discriminant) { case SIMPLE: do stuff; break; case COMPLICATED: { declare variables; do stuff; break; } } This commit is a big-bang change that reformats all the complicated case handlers I could find into the new layout. This is particularly nice in the Pageant main function, in which almost _every_ case handler had a bundle of variables and was long and complicated. (In fact that's what motivated me to get round to this.) Some of the innermost parts of the terminal escape-sequence handling are also breathing a bit easier now the horizontal pressure on them is relieved. (Also, in a few cases, I was able to remove the extra braces completely, because the only variable local to the case handler was a loop variable which our new C99 policy allows me to move into the initialiser clause of its for statement.) Viewed with whitespace ignored, this is not too disruptive a change. Downstream patches that conflict with it may need to be reapplied using --ignore-whitespace or similar.
2020-02-16 07:49:52 +00:00
ImmReleaseContext(hwnd, hIMC);
return 1;
}
Glenn Maynard's IME patch [originally from svn r1172]
2001-08-04 15:15:07 +00:00
RDB's Unicode patch. Fonts are now used in Unicode mode where possible and we have a single unified means of trying to display any Unicode code point. Instead of the various ad-hoc translation modes we had before, we now have a single `codepage' option which allows us to treat the incoming (and outgoing) text as any given character set, and locally we map that to Unicode and back. [originally from svn r1110]
2001-05-10 08:34:20 +00:00
case WM_IME_CHAR:
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
if (wParam & 0xFF00) {
char buf[2];
Chinese support patch from zmx@cdpa.nsysu.edu.tw [originally from svn r740]
2000-10-20 18:36:15 +00:00
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
buf[1] = wParam;
buf[0] = wParam >> 8;
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
term_keyinput(wgs->term, wgs->kbd_codepage, buf, 2);
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
} else {
char c = (unsigned char) wParam;
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
term_seen_key_event(wgs->term);
term_keyinput(wgs->term, wgs->kbd_codepage, &c, 1);
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
}
return (0);
Initial checkin: beta 0.43 [originally from svn r11]
1999-01-08 13:02:13 +00:00
case WM_CHAR:
case WM_SYSCHAR:
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
/*
* Nevertheless, we are prepared to deal with WM_CHAR
* messages, should they crop up. So if someone wants to
* post the things to us as part of a macro manoeuvre,
* we're ready to cope.
*/
Windows: runtime switch between Unicode and ANSI windows. Turns out that PuTTY hasn't run successfully on legacy Windows since 0.66, in spite of an ongoing intention to keep it working. Among the reasons for this is that CreateWindowExW simply fails with ERROR_CALL_NOT_IMPLEMENTED: apparently Win95 and its ilk just didn't have fully-Unicode windows as an option. Fixed by resurrecting the previous code from the git history (in particular, code removed by commit 67e5ceb9a8e6bc2 was useful), and including it as a runtime alternative. One subtlety was that I found I had to name the A and W window classes differently (by appending ".ansi" to the A one): apparently they occupy the same namespace even though the names are in different character sets, so if you somehow manage to register both classes, they'll collide with each other without that tweak.
2022-03-12 06:43:59 +00:00
if (unicode_window) {
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
wchar_t c = wParam;
Turn the Windows PuTTY main window into a Unicode window. This causes WM_CHAR messages sent to us to have a wParam containing a 16-bit value encoded in UTF-16, rather than an 8-bit value encoded in the system code page. As far as I can tell, there aren't many other knock-on effects - e.g. you can still interact with the window using ordinary char-based API functions such as SetWindowText, and the Windows API will do the necessary conversions behind the scenes. However, even so, I'm half expecting some sort of unforeseen bug to show up as a result of this.
2015-07-27 19:06:02 +00:00
if (IS_HIGH_SURROGATE(c)) {
windows/window.c: move more variables into WinGuiSeat. In commit f9e572595bb8cb6 I claimed that I'd removed very nearly all the global and static variables from windows/window.c. It turns out that this was wildly overoptimistic - I missed quite a few of them! I'm not quite sure how I managed that; my best guess is that I used an underpowered 'nm' command that failed to find some classes of variable. Some of the remaining function-scope statics were removed completely by commit afb3dab1e97a09f just now. In this commit, I've swept up some more and turn them into fields of WinGuiSeat, where they should have been moved last September. The (hopefully complete this time) list of remaining variables, generated by running this rune in the Windows build directory: nm windows/CMakeFiles/putty.dir/window.c.obj | grep -E '^([^ ]+)? *[bBcCdDgGsS] [^\.]' consists of the following variables which are legitimately global across the whole process and not related to a particular window: - 'hinst' and 'hprev', instance handles for Windows loadable modules - 'classname' in the terminal_window_class_a() and terminal_window_class_w() functions, which allocate a window class reusably - some pointers to Windows API functions retrieved via the DECL_WINDOWS_FUNCTION / GET_WINDOWS_FUNCTION system, such as p_AdjustWindowRectExForDpi and p_FlashWindowEx - some pointers to Windows API functions set up by assigning them at startup to the right one of the ANSI or Unicode version depending on the Windows version, e.g. sw_DefWindowProc and sw_DispatchMessage - 'unicode_window', a boolean flag set at the same time as those sw_Foo function pointers - 'sesslist', storing the last-retrieved version of the saved sessions menu - 'cursor_visible' in show_mouseptr() and 'forced_visible' in update_mouse_pointer(), each of which tracks the cumulative number of times that function has shown or hidden the mouse pointer, so as to manage its effect on the global state updated by ShowCursor - 'trust_icon', loaded from the executable's resources - 'wgslisthead', the list of all active WinGuiSeats - 'wm_mousewheel', the window-message id we use for mouse wheel events and the following which are nothing to do with our code: - '_OptionsStorage' in __local_stdio_printf_options() and __local_stdio_scanf_options(), which I'd never noticed before, but apparently are internal to a standard library header.
2023-05-27 13:59:20 +00:00
wgs->pending_surrogate = c;
} else if (IS_SURROGATE_PAIR(wgs->pending_surrogate, c)) {
Turn the Windows PuTTY main window into a Unicode window. This causes WM_CHAR messages sent to us to have a wParam containing a 16-bit value encoded in UTF-16, rather than an 8-bit value encoded in the system code page. As far as I can tell, there aren't many other knock-on effects - e.g. you can still interact with the window using ordinary char-based API functions such as SetWindowText, and the Windows API will do the necessary conversions behind the scenes. However, even so, I'm half expecting some sort of unforeseen bug to show up as a result of this.
2015-07-27 19:06:02 +00:00
wchar_t pair[2];
windows/window.c: move more variables into WinGuiSeat. In commit f9e572595bb8cb6 I claimed that I'd removed very nearly all the global and static variables from windows/window.c. It turns out that this was wildly overoptimistic - I missed quite a few of them! I'm not quite sure how I managed that; my best guess is that I used an underpowered 'nm' command that failed to find some classes of variable. Some of the remaining function-scope statics were removed completely by commit afb3dab1e97a09f just now. In this commit, I've swept up some more and turn them into fields of WinGuiSeat, where they should have been moved last September. The (hopefully complete this time) list of remaining variables, generated by running this rune in the Windows build directory: nm windows/CMakeFiles/putty.dir/window.c.obj | grep -E '^([^ ]+)? *[bBcCdDgGsS] [^\.]' consists of the following variables which are legitimately global across the whole process and not related to a particular window: - 'hinst' and 'hprev', instance handles for Windows loadable modules - 'classname' in the terminal_window_class_a() and terminal_window_class_w() functions, which allocate a window class reusably - some pointers to Windows API functions retrieved via the DECL_WINDOWS_FUNCTION / GET_WINDOWS_FUNCTION system, such as p_AdjustWindowRectExForDpi and p_FlashWindowEx - some pointers to Windows API functions set up by assigning them at startup to the right one of the ANSI or Unicode version depending on the Windows version, e.g. sw_DefWindowProc and sw_DispatchMessage - 'unicode_window', a boolean flag set at the same time as those sw_Foo function pointers - 'sesslist', storing the last-retrieved version of the saved sessions menu - 'cursor_visible' in show_mouseptr() and 'forced_visible' in update_mouse_pointer(), each of which tracks the cumulative number of times that function has shown or hidden the mouse pointer, so as to manage its effect on the global state updated by ShowCursor - 'trust_icon', loaded from the executable's resources - 'wgslisthead', the list of all active WinGuiSeats - 'wm_mousewheel', the window-message id we use for mouse wheel events and the following which are nothing to do with our code: - '_OptionsStorage' in __local_stdio_printf_options() and __local_stdio_scanf_options(), which I'd never noticed before, but apparently are internal to a standard library header.
2023-05-27 13:59:20 +00:00
pair[0] = wgs->pending_surrogate;
Turn the Windows PuTTY main window into a Unicode window. This causes WM_CHAR messages sent to us to have a wParam containing a 16-bit value encoded in UTF-16, rather than an 8-bit value encoded in the system code page. As far as I can tell, there aren't many other knock-on effects - e.g. you can still interact with the window using ordinary char-based API functions such as SetWindowText, and the Windows API will do the necessary conversions behind the scenes. However, even so, I'm half expecting some sort of unforeseen bug to show up as a result of this.
2015-07-27 19:06:02 +00:00
pair[1] = c;
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
term_keyinputw(wgs->term, pair, 2);
Turn the Windows PuTTY main window into a Unicode window. This causes WM_CHAR messages sent to us to have a wParam containing a 16-bit value encoded in UTF-16, rather than an 8-bit value encoded in the system code page. As far as I can tell, there aren't many other knock-on effects - e.g. you can still interact with the window using ordinary char-based API functions such as SetWindowText, and the Windows API will do the necessary conversions behind the scenes. However, even so, I'm half expecting some sort of unforeseen bug to show up as a result of this.
2015-07-27 19:06:02 +00:00
} else if (!IS_SURROGATE(c)) {
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
term_keyinputw(wgs->term, &c, 1);
Turn the Windows PuTTY main window into a Unicode window. This causes WM_CHAR messages sent to us to have a wParam containing a 16-bit value encoded in UTF-16, rather than an 8-bit value encoded in the system code page. As far as I can tell, there aren't many other knock-on effects - e.g. you can still interact with the window using ordinary char-based API functions such as SetWindowText, and the Windows API will do the necessary conversions behind the scenes. However, even so, I'm half expecting some sort of unforeseen bug to show up as a result of this.
2015-07-27 19:06:02 +00:00
}
Windows: runtime switch between Unicode and ANSI windows. Turns out that PuTTY hasn't run successfully on legacy Windows since 0.66, in spite of an ongoing intention to keep it working. Among the reasons for this is that CreateWindowExW simply fails with ERROR_CALL_NOT_IMPLEMENTED: apparently Win95 and its ilk just didn't have fully-Unicode windows as an option. Fixed by resurrecting the previous code from the git history (in particular, code removed by commit 67e5ceb9a8e6bc2 was useful), and including it as a runtime alternative. One subtlety was that I found I had to name the A and W window classes differently (by appending ".ansi" to the A one): apparently they occupy the same namespace even though the names are in different character sets, so if you somehow manage to register both classes, they'll collide with each other without that tweak.
2022-03-12 06:43:59 +00:00
} else {
char c = (unsigned char)wParam;
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
term_seen_key_event(wgs->term);
if (wgs->ldisc)
term_keyinput(wgs->term, CP_ACP, &c, 1);
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
}
return 0;
Handle WM_SYSCOLORCHANGE if using system colours. (Resets the whole palette, whereas ideally it would restrict itself to the affected colour slots.) [originally from svn r4505]
2004-08-27 12:24:08 +00:00
case WM_SYSCOLORCHANGE:
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
if (conf_get_bool(wgs->conf, CONF_system_colour)) {
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
/* Refresh palette from system colours. */
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
term_notify_palette_changed(wgs->term);
init_palette(wgs);
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
/* Force a repaint of the terminal window. */
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
term_invalidate(wgs->term);
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
}
break;
Move the code that reads the Windows clipboard into a trivial subthread, so that it won't deadlock if fetching the content of the clipboard turns out to depend on a network connection forwarded through PuTTY. [originally from svn r8338]
2008-11-28 18:28:23 +00:00
case WM_GOT_CLIPDATA:
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
process_clipdata(wgs, (HGLOBAL)lParam, wParam);
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
return 0;
A contributor tells me that WM_MOUSEWHEEL is not supported in Win95, and offers a patch that uses RegisterMessage() to acquire the correct dynamic message number to use instead. [originally from svn r1499]
2001-12-15 14:30:58 +00:00
default:
Support horizontal scroll events in mouse tracking. Horizontal scroll events aren't generated by the traditional mouse wheel, but they can be generated by trackpad gestures, though this isn't always configured on. The cross-platform and Windows parts of this patch is due to Christopher Plewright; I added the GTK support.
2022-11-22 18:36:23 +00:00
if (message == wm_mousewheel || message == WM_MOUSEWHEEL
|| message == WM_MOUSEHWHEEL) {
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
bool shift_pressed = false, control_pressed = false;
Support horizontal scroll events in mouse tracking. Horizontal scroll events aren't generated by the traditional mouse wheel, but they can be generated by trackpad gestures, though this isn't always configured on. The cross-platform and Windows parts of this patch is due to Christopher Plewright; I added the GTK support.
2022-11-22 18:36:23 +00:00
if (message == WM_MOUSEWHEEL || message == WM_MOUSEHWHEEL) {
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
wgs->wheel_accumulator += (short)HIWORD(wParam);
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
shift_pressed=LOWORD(wParam) & MK_SHIFT;
control_pressed=LOWORD(wParam) & MK_CONTROL;
} else {
BYTE keys[256];
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
wgs->wheel_accumulator += (int)wParam;
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
if (GetKeyboardState(keys)!=0) {
shift_pressed=keys[VK_SHIFT]&0x80;
control_pressed=keys[VK_CONTROL]&0x80;
}
}
/* process events when the threshold is reached */
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
while (abs(wgs->wheel_accumulator) >= WHEEL_DELTA) {
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
int b;
/* reduce amount for next time */
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
if (wgs->wheel_accumulator > 0) {
Support horizontal scroll events in mouse tracking. Horizontal scroll events aren't generated by the traditional mouse wheel, but they can be generated by trackpad gestures, though this isn't always configured on. The cross-platform and Windows parts of this patch is due to Christopher Plewright; I added the GTK support.
2022-11-22 18:36:23 +00:00
b = message == WM_MOUSEHWHEEL ? MBT_WHEEL_RIGHT : MBT_WHEEL_UP;
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
wgs->wheel_accumulator -= WHEEL_DELTA;
} else if (wgs->wheel_accumulator < 0) {
Support horizontal scroll events in mouse tracking. Horizontal scroll events aren't generated by the traditional mouse wheel, but they can be generated by trackpad gestures, though this isn't always configured on. The cross-platform and Windows parts of this patch is due to Christopher Plewright; I added the GTK support.
2022-11-22 18:36:23 +00:00
b = message == WM_MOUSEHWHEEL ? MBT_WHEEL_LEFT : MBT_WHEEL_DOWN;
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
wgs->wheel_accumulator += WHEEL_DELTA;
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
} else
break;
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
if (wgs->send_raw_mouse &&
!(conf_get_bool(wgs->conf, CONF_mouse_override) &&
Sumudu Fernando points out that in the big r9214 destabilisation I mistakenly rearranged the logic in an if statement in window.c, with the effect that scroll-wheel events are no longer sent via xterm mouse tracking. Put it back to the way it was. [originally from svn r9679] [r9214 == a1f3b7a358adaa7c2a98359cd0373aa823eeb14b]
2012-10-02 19:31:33 +00:00
shift_pressed)) {
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
/* Mouse wheel position is in screen coordinates for
* some reason */
POINT p;
p.x = X_POS(lParam); p.y = Y_POS(lParam);
if (ScreenToClient(hwnd, &p)) {
/* send a mouse-down followed by a mouse up */
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
term_mouse(wgs->term, b, translate_button(wgs, b),
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
MA_CLICK,
TO_CHR_X(p.x),
TO_CHR_Y(p.y), shift_pressed,
control_pressed, is_alt_pressed());
} /* else: not sure when this can fail */
Support horizontal scroll events in mouse tracking. Horizontal scroll events aren't generated by the traditional mouse wheel, but they can be generated by trackpad gestures, though this isn't always configured on. The cross-platform and Windows parts of this patch is due to Christopher Plewright; I added the GTK support.
2022-11-22 18:36:23 +00:00
} else if (message != WM_MOUSEHWHEEL) {
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
/* trigger a scroll */
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
term_scroll(wgs->term, 0,
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
b == MBT_WHEEL_UP ?
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
-wgs->term->rows / 2 : wgs->term->rows / 2);
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
}
}
return 0;
}
Initial checkin: beta 0.43 [originally from svn r11]
1999-01-08 13:02:13 +00:00
}
Add comments about default processing in DialogProc/WindowProc, since I often forget the rules. [originally from svn r5532]
2005-03-20 22:28:13 +00:00
/*
* Any messages we don't process completely above are passed through to
* DefWindowProc() for default processing.
*/
Windows: runtime switch between Unicode and ANSI windows. Turns out that PuTTY hasn't run successfully on legacy Windows since 0.66, in spite of an ongoing intention to keep it working. Among the reasons for this is that CreateWindowExW simply fails with ERROR_CALL_NOT_IMPLEMENTED: apparently Win95 and its ilk just didn't have fully-Unicode windows as an option. Fixed by resurrecting the previous code from the git history (in particular, code removed by commit 67e5ceb9a8e6bc2 was useful), and including it as a runtime alternative. One subtlety was that I found I had to name the A and W window classes differently (by appending ".ansi" to the A one): apparently they occupy the same namespace even though the names are in different character sets, so if you somehow manage to register both classes, they'll collide with each other without that tweak.
2022-03-12 06:43:59 +00:00
return sw_DefWindowProc(hwnd, message, wParam, lParam);
Initial checkin: beta 0.43 [originally from svn r11]
1999-01-08 13:02:13 +00:00
}
Add an invisible System Caret for blind-helper-software to track [originally from svn r627]
2000-09-25 16:17:53 +00:00
/*
* Move the system caret. (We maintain one, even though it's
* invisible, for the benefit of blind people: apparently some
* helper software tracks the system caret, so we should arrange to
* have one.)
*/
Remove the 'Frontend' type and replace it with a vtable. After the recent Seat and LogContext revamps, _nearly_ all the remaining uses of the type 'Frontend' were in terminal.c, which needs all sorts of interactions with the GUI window the terminal lives in, from the obvious (actually drawing text on the window, reading and writing the clipboard) to the obscure (minimising, maximising and moving the window in response to particular escape sequences). All of those functions are now provided by an abstraction called TermWin. The few remaining uses of Frontend after _that_ are internal to a particular platform directory, so as to spread the implementation of that particular kind of Frontend between multiple source files; so I've renamed all of those so that they take a more specifically named type that refers to the particular implementation rather than the general abstraction. So now the name 'Frontend' no longer exists in the code base at all, and everywhere one used to be used, it's completely clear whether it was operating in one of Frontend's three abstract roles (and if so, which), or whether it was specific to a particular implementation. Another type that's disappeared is 'Context', which used to be a typedef defined to something different on each platform, describing whatever short-lived resources were necessary to draw on the terminal window: the front end would provide a ready-made one when calling term_paint, and the terminal could request one with get_ctx/free_ctx if it wanted to do proactive window updates. Now that drawing context lives inside the TermWin itself, because there was never any need to have two of those contexts live at the same time. (Another minor API change is that the window-title functions - both reading and writing - have had a missing 'const' added to their char * parameters / return values.) I don't expect this change to enable any particularly interesting new functionality (in particular, I have no plans that need more than one implementation of TermWin in the same application). But it completes the tidying-up that began with the Seat and LogContext rework.
2018-10-25 17:44:04 +00:00
static void wintw_set_cursor_pos(TermWin *tw, int x, int y)
This should fix the busy-wait problem with the IME. [originally from svn r1512]
2001-12-20 14:18:01 +00:00
{
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
WinGuiSeat *wgs = container_of(tw, WinGuiSeat, termwin);
This should fix the busy-wait problem with the IME. [originally from svn r1512]
2001-12-20 14:18:01 +00:00
int cx, cy;
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
if (!wgs->term->has_focus) return;
This should fix the busy-wait problem with the IME. [originally from svn r1512]
2001-12-20 14:18:01 +00:00
/*
* Avoid gratuitously re-updating the cursor position and IMM
* window if there's no actual change required.
*/
windows/window.c: move more variables into WinGuiSeat. In commit f9e572595bb8cb6 I claimed that I'd removed very nearly all the global and static variables from windows/window.c. It turns out that this was wildly overoptimistic - I missed quite a few of them! I'm not quite sure how I managed that; my best guess is that I used an underpowered 'nm' command that failed to find some classes of variable. Some of the remaining function-scope statics were removed completely by commit afb3dab1e97a09f just now. In this commit, I've swept up some more and turn them into fields of WinGuiSeat, where they should have been moved last September. The (hopefully complete this time) list of remaining variables, generated by running this rune in the Windows build directory: nm windows/CMakeFiles/putty.dir/window.c.obj | grep -E '^([^ ]+)? *[bBcCdDgGsS] [^\.]' consists of the following variables which are legitimately global across the whole process and not related to a particular window: - 'hinst' and 'hprev', instance handles for Windows loadable modules - 'classname' in the terminal_window_class_a() and terminal_window_class_w() functions, which allocate a window class reusably - some pointers to Windows API functions retrieved via the DECL_WINDOWS_FUNCTION / GET_WINDOWS_FUNCTION system, such as p_AdjustWindowRectExForDpi and p_FlashWindowEx - some pointers to Windows API functions set up by assigning them at startup to the right one of the ANSI or Unicode version depending on the Windows version, e.g. sw_DefWindowProc and sw_DispatchMessage - 'unicode_window', a boolean flag set at the same time as those sw_Foo function pointers - 'sesslist', storing the last-retrieved version of the saved sessions menu - 'cursor_visible' in show_mouseptr() and 'forced_visible' in update_mouse_pointer(), each of which tracks the cumulative number of times that function has shown or hidden the mouse pointer, so as to manage its effect on the global state updated by ShowCursor - 'trust_icon', loaded from the executable's resources - 'wgslisthead', the list of all active WinGuiSeats - 'wm_mousewheel', the window-message id we use for mouse wheel events and the following which are nothing to do with our code: - '_OptionsStorage' in __local_stdio_printf_options() and __local_stdio_scanf_options(), which I'd never noticed before, but apparently are internal to a standard library header.
2023-05-27 13:59:20 +00:00
cx = x * wgs->font_width + wgs->offset_width;
cy = y * wgs->font_height + wgs->offset_height;
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
if (cx == wgs->caret_x && cy == wgs->caret_y)
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
return;
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
wgs->caret_x = cx;
wgs->caret_y = cy;
This should fix the busy-wait problem with the IME. [originally from svn r1512]
2001-12-20 14:18:01 +00:00
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
sys_cursor_update(wgs);
This should fix the busy-wait problem with the IME. [originally from svn r1512]
2001-12-20 14:18:01 +00:00
}
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
static void sys_cursor_update(WinGuiSeat *wgs)
Run entire source base through GNU indent to tidy up the varying coding styles of the various contributors! Woohoo! [originally from svn r1098]
2001-05-06 14:35:20 +00:00
{
Glenn Maynard's IME patch [originally from svn r1172]
2001-08-04 15:15:07 +00:00
COMPOSITIONFORM cf;
HIMC hIMC;
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
if (!wgs->term->has_focus) return;
This should fix the busy-wait problem with the IME. [originally from svn r1512]
2001-12-20 14:18:01 +00:00
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
if (wgs->caret_x < 0 || wgs->caret_y < 0)
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
return;
This should fix the busy-wait problem with the IME. [originally from svn r1512]
2001-12-20 14:18:01 +00:00
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
SetCaretPos(wgs->caret_x, wgs->caret_y);
Glenn Maynard's IME patch [originally from svn r1172]
2001-08-04 15:15:07 +00:00
/* IMM calls on Win98 and beyond only */
Fix Windows warning about GetVersionEx deprecation. Rather than squelching the warning, I'm actually paying attention to the deprecation, in that I'm allowing for the possibility that the function might stop existing or stop returning success.
2018-06-03 14:05:44 +00:00
if (osPlatformId == VER_PLATFORM_WIN32s) return; /* 3.11 */
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
Fix Windows warning about GetVersionEx deprecation. Rather than squelching the warning, I'm actually paying attention to the deprecation, in that I'm allowing for the possibility that the function might stop existing or stop returning success.
2018-06-03 14:05:44 +00:00
if (osPlatformId == VER_PLATFORM_WIN32_WINDOWS &&
osMinorVersion == 0) return; /* 95 */
Glenn Maynard's IME patch [originally from svn r1172]
2001-08-04 15:15:07 +00:00
/* we should have the IMM functions */
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
hIMC = ImmGetContext(wgs->term_hwnd);
Glenn Maynard's IME patch [originally from svn r1172]
2001-08-04 15:15:07 +00:00
cf.dwStyle = CFS_POINT;
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
cf.ptCurrentPos.x = wgs->caret_x;
cf.ptCurrentPos.y = wgs->caret_y;
Glenn Maynard's IME patch [originally from svn r1172]
2001-08-04 15:15:07 +00:00
ImmSetCompositionWindow(hIMC, &cf);
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
ImmReleaseContext(wgs->term_hwnd, hIMC);
Add an invisible System Caret for blind-helper-software to track [originally from svn r627]
2000-09-25 16:17:53 +00:00
}
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
static void draw_horizontal_line_on_text(
WinGuiSeat *wgs, int y, int lattr, RECT line_box, COLORREF colour)
Support SGR 9 for strikethrough effect on text. This is mostly easy: it's just like drawing an underline, except that you put it at a different height in the character cell. The only question is _where_ in the character cell. Pango, and Windows GetOutlineTextMetrics, will tell you exactly where the font wants to have it. Following xterm, I fall back to 3/8 of the font's ascent (above the baseline) if either of those is unavailable.
2020-08-13 20:08:53 +00:00
{
if (lattr == LATTR_TOP || lattr == LATTR_BOT) {
y *= 2;
if (lattr == LATTR_BOT)
windows/window.c: move more variables into WinGuiSeat. In commit f9e572595bb8cb6 I claimed that I'd removed very nearly all the global and static variables from windows/window.c. It turns out that this was wildly overoptimistic - I missed quite a few of them! I'm not quite sure how I managed that; my best guess is that I used an underpowered 'nm' command that failed to find some classes of variable. Some of the remaining function-scope statics were removed completely by commit afb3dab1e97a09f just now. In this commit, I've swept up some more and turn them into fields of WinGuiSeat, where they should have been moved last September. The (hopefully complete this time) list of remaining variables, generated by running this rune in the Windows build directory: nm windows/CMakeFiles/putty.dir/window.c.obj | grep -E '^([^ ]+)? *[bBcCdDgGsS] [^\.]' consists of the following variables which are legitimately global across the whole process and not related to a particular window: - 'hinst' and 'hprev', instance handles for Windows loadable modules - 'classname' in the terminal_window_class_a() and terminal_window_class_w() functions, which allocate a window class reusably - some pointers to Windows API functions retrieved via the DECL_WINDOWS_FUNCTION / GET_WINDOWS_FUNCTION system, such as p_AdjustWindowRectExForDpi and p_FlashWindowEx - some pointers to Windows API functions set up by assigning them at startup to the right one of the ANSI or Unicode version depending on the Windows version, e.g. sw_DefWindowProc and sw_DispatchMessage - 'unicode_window', a boolean flag set at the same time as those sw_Foo function pointers - 'sesslist', storing the last-retrieved version of the saved sessions menu - 'cursor_visible' in show_mouseptr() and 'forced_visible' in update_mouse_pointer(), each of which tracks the cumulative number of times that function has shown or hidden the mouse pointer, so as to manage its effect on the global state updated by ShowCursor - 'trust_icon', loaded from the executable's resources - 'wgslisthead', the list of all active WinGuiSeats - 'wm_mousewheel', the window-message id we use for mouse wheel events and the following which are nothing to do with our code: - '_OptionsStorage' in __local_stdio_printf_options() and __local_stdio_scanf_options(), which I'd never noticed before, but apparently are internal to a standard library header.
2023-05-27 13:59:20 +00:00
y -= wgs->font_height;
Support SGR 9 for strikethrough effect on text. This is mostly easy: it's just like drawing an underline, except that you put it at a different height in the character cell. The only question is _where_ in the character cell. Pango, and Windows GetOutlineTextMetrics, will tell you exactly where the font wants to have it. Following xterm, I fall back to 3/8 of the font's ascent (above the baseline) if either of those is unavailable.
2020-08-13 20:08:53 +00:00
}
windows/window.c: move more variables into WinGuiSeat. In commit f9e572595bb8cb6 I claimed that I'd removed very nearly all the global and static variables from windows/window.c. It turns out that this was wildly overoptimistic - I missed quite a few of them! I'm not quite sure how I managed that; my best guess is that I used an underpowered 'nm' command that failed to find some classes of variable. Some of the remaining function-scope statics were removed completely by commit afb3dab1e97a09f just now. In this commit, I've swept up some more and turn them into fields of WinGuiSeat, where they should have been moved last September. The (hopefully complete this time) list of remaining variables, generated by running this rune in the Windows build directory: nm windows/CMakeFiles/putty.dir/window.c.obj | grep -E '^([^ ]+)? *[bBcCdDgGsS] [^\.]' consists of the following variables which are legitimately global across the whole process and not related to a particular window: - 'hinst' and 'hprev', instance handles for Windows loadable modules - 'classname' in the terminal_window_class_a() and terminal_window_class_w() functions, which allocate a window class reusably - some pointers to Windows API functions retrieved via the DECL_WINDOWS_FUNCTION / GET_WINDOWS_FUNCTION system, such as p_AdjustWindowRectExForDpi and p_FlashWindowEx - some pointers to Windows API functions set up by assigning them at startup to the right one of the ANSI or Unicode version depending on the Windows version, e.g. sw_DefWindowProc and sw_DispatchMessage - 'unicode_window', a boolean flag set at the same time as those sw_Foo function pointers - 'sesslist', storing the last-retrieved version of the saved sessions menu - 'cursor_visible' in show_mouseptr() and 'forced_visible' in update_mouse_pointer(), each of which tracks the cumulative number of times that function has shown or hidden the mouse pointer, so as to manage its effect on the global state updated by ShowCursor - 'trust_icon', loaded from the executable's resources - 'wgslisthead', the list of all active WinGuiSeats - 'wm_mousewheel', the window-message id we use for mouse wheel events and the following which are nothing to do with our code: - '_OptionsStorage' in __local_stdio_printf_options() and __local_stdio_scanf_options(), which I'd never noticed before, but apparently are internal to a standard library header.
2023-05-27 13:59:20 +00:00
if (!(0 <= y && y < wgs->font_height))
Support SGR 9 for strikethrough effect on text. This is mostly easy: it's just like drawing an underline, except that you put it at a different height in the character cell. The only question is _where_ in the character cell. Pango, and Windows GetOutlineTextMetrics, will tell you exactly where the font wants to have it. Following xterm, I fall back to 3/8 of the font's ascent (above the baseline) if either of those is unavailable.
2020-08-13 20:08:53 +00:00
return;
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
HPEN oldpen = SelectObject(wgs->wintw_hdc, CreatePen(PS_SOLID, 0, colour));
MoveToEx(wgs->wintw_hdc, line_box.left, line_box.top + y, NULL);
LineTo(wgs->wintw_hdc, line_box.right, line_box.top + y);
oldpen = SelectObject(wgs->wintw_hdc, oldpen);
Support SGR 9 for strikethrough effect on text. This is mostly easy: it's just like drawing an underline, except that you put it at a different height in the character cell. The only question is _where_ in the character cell. Pango, and Windows GetOutlineTextMetrics, will tell you exactly where the font wants to have it. Following xterm, I fall back to 3/8 of the font's ascent (above the baseline) if either of those is unavailable.
2020-08-13 20:08:53 +00:00
DeleteObject(oldpen);
}
Initial checkin: beta 0.43 [originally from svn r11]
1999-01-08 13:02:13 +00:00
/*
* Draw a line of text in the window, at given character
* coordinates, in given attributes.
*
* We are allowed to fiddle with the contents of `text'.
*/
Remove the 'Frontend' type and replace it with a vtable. After the recent Seat and LogContext revamps, _nearly_ all the remaining uses of the type 'Frontend' were in terminal.c, which needs all sorts of interactions with the GUI window the terminal lives in, from the obvious (actually drawing text on the window, reading and writing the clipboard) to the obscure (minimising, maximising and moving the window in response to particular escape sequences). All of those functions are now provided by an abstraction called TermWin. The few remaining uses of Frontend after _that_ are internal to a particular platform directory, so as to spread the implementation of that particular kind of Frontend between multiple source files; so I've renamed all of those so that they take a more specifically named type that refers to the particular implementation rather than the general abstraction. So now the name 'Frontend' no longer exists in the code base at all, and everywhere one used to be used, it's completely clear whether it was operating in one of Frontend's three abstract roles (and if so, which), or whether it was specific to a particular implementation. Another type that's disappeared is 'Context', which used to be a typedef defined to something different on each platform, describing whatever short-lived resources were necessary to draw on the terminal window: the front end would provide a ready-made one when calling term_paint, and the terminal could request one with get_ctx/free_ctx if it wanted to do proactive window updates. Now that drawing context lives inside the TermWin itself, because there was never any need to have two of those contexts live at the same time. (Another minor API change is that the window-title functions - both reading and writing - have had a missing 'const' added to their char * parameters / return values.) I don't expect this change to enable any particularly interesting new functionality (in particular, I have no plans that need more than one implementation of TermWin in the same application). But it completes the tidying-up that began with the Seat and LogContext rework.
2018-10-25 17:44:04 +00:00
static void do_text_internal(
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
WinGuiSeat *wgs, int x, int y, wchar_t *text, int len,
Remove the 'Frontend' type and replace it with a vtable. After the recent Seat and LogContext revamps, _nearly_ all the remaining uses of the type 'Frontend' were in terminal.c, which needs all sorts of interactions with the GUI window the terminal lives in, from the obvious (actually drawing text on the window, reading and writing the clipboard) to the obscure (minimising, maximising and moving the window in response to particular escape sequences). All of those functions are now provided by an abstraction called TermWin. The few remaining uses of Frontend after _that_ are internal to a particular platform directory, so as to spread the implementation of that particular kind of Frontend between multiple source files; so I've renamed all of those so that they take a more specifically named type that refers to the particular implementation rather than the general abstraction. So now the name 'Frontend' no longer exists in the code base at all, and everywhere one used to be used, it's completely clear whether it was operating in one of Frontend's three abstract roles (and if so, which), or whether it was specific to a particular implementation. Another type that's disappeared is 'Context', which used to be a typedef defined to something different on each platform, describing whatever short-lived resources were necessary to draw on the terminal window: the front end would provide a ready-made one when calling term_paint, and the terminal could request one with get_ctx/free_ctx if it wanted to do proactive window updates. Now that drawing context lives inside the TermWin itself, because there was never any need to have two of those contexts live at the same time. (Another minor API change is that the window-title functions - both reading and writing - have had a missing 'const' added to their char * parameters / return values.) I don't expect this change to enable any particularly interesting new functionality (in particular, I have no plans that need more than one implementation of TermWin in the same application). But it completes the tidying-up that began with the Seat and LogContext rework.
2018-10-25 17:44:04 +00:00
unsigned long attr, int lattr, truecolour truecolour)
Run entire source base through GNU indent to tidy up the varying coding styles of the various contributors! Woohoo! [originally from svn r1098]
2001-05-06 14:35:20 +00:00
{
Initial checkin: beta 0.43 [originally from svn r11]
1999-01-08 13:02:13 +00:00
COLORREF fg, bg, t;
int nfg, nbg, nfont;
RDB's patch: - use WM_TIMER for various things (blinking cursor; updates while moving/sizing; coping with overloading influx of netevents) - clip text output to avoid underlines outside character cell - even more careful font selection (we can now do OEMANSI by default) - a few extra keyboard mappings from the VTxxx terminals [originally from svn r418]
2000-03-17 10:34:41 +00:00
RECT line_box;
Convert a lot of 'int' variables to 'bool'. My normal habit these days, in new code, is to treat int and bool as _almost_ completely separate types. I'm still willing to use C's implicit test for zero on an integer (e.g. 'if (!blob.len)' is fine, no need to spell it out as blob.len != 0), but generally, if a variable is going to be conceptually a boolean, I like to declare it bool and assign to it using 'true' or 'false' rather than 0 or 1. PuTTY is an exception, because it predates the C99 bool, and I've stuck to its existing coding style even when adding new code to it. But it's been annoying me more and more, so now that I've decided C99 bool is an acceptable thing to require from our toolchain in the first place, here's a quite thorough trawl through the source doing 'boolification'. Many variables and function parameters are now typed as bool rather than int; many assignments of 0 or 1 to those variables are now spelled 'true' or 'false'. I managed this thorough conversion with the help of a custom clang plugin that I wrote to trawl the AST and apply heuristics to point out where things might want changing. So I've even managed to do a decent job on parts of the code I haven't looked at in years! To make the plugin's work easier, I pushed platform front ends generally in the direction of using standard 'bool' in preference to platform-specific boolean types like Windows BOOL or GTK's gboolean; I've left the platform booleans in places they _have_ to be for the platform APIs to work right, but variables only used by my own code have been converted wherever I found them. In a few places there are int values that look very like booleans in _most_ of the places they're used, but have a rarely-used third value, or a distinction between different nonzero values that most users don't care about. In these cases, I've _removed_ uses of 'true' and 'false' for the return values, to emphasise that there's something more subtle going on than a simple boolean answer: - the 'multisel' field in dialog.h's list box structure, for which the GTK front end in particular recognises a difference between 1 and 2 but nearly everything else treats as boolean - the 'urgent' parameter to plug_receive, where 1 vs 2 tells you something about the specific location of the urgent pointer, but most clients only care about 0 vs 'something nonzero' - the return value of wc_match, where -1 indicates a syntax error in the wildcard. - the return values from SSH-1 RSA-key loading functions, which use -1 for 'wrong passphrase' and 0 for all other failures (so any caller which already knows it's not loading an _encrypted private_ key can treat them as boolean) - term->esc_query, and the 'query' parameter in toggle_mode in terminal.c, which _usually_ hold 0 for ESC[123h or 1 for ESC[?123h, but can also hold -1 for some other intervening character that we don't support. In a few places there's an integer that I haven't turned into a bool even though it really _can_ only take values 0 or 1 (and, as above, tried to make the call sites consistent in not calling those values true and false), on the grounds that I thought it would make it more confusing to imply that the 0 value was in some sense 'negative' or bad and the 1 positive or good: - the return value of plug_accepting uses the POSIXish convention of 0=success and nonzero=error; I think if I made it bool then I'd also want to reverse its sense, and that's a job for a separate piece of work. - the 'screen' parameter to lineptr() in terminal.c, where 0 and 1 represent the default and alternate screens. There's no obvious reason why one of those should be considered 'true' or 'positive' or 'success' - they're just indices - so I've left it as int. ssh_scp_recv had particularly confusing semantics for its previous int return value: its call sites used '<= 0' to check for error, but it never actually returned a negative number, just 0 or 1. Now the function and its call sites agree that it's a bool. In a couple of places I've renamed variables called 'ret', because I don't like that name any more - it's unclear whether it means the return value (in preparation) for the _containing_ function or the return value received from a subroutine call, and occasionally I've accidentally used the same variable for both and introduced a bug. So where one of those got in my way, I've renamed it to 'toret' or 'retd' (the latter short for 'returned') in line with my usual modern practice, but I haven't done a thorough job of finding all of them. Finally, one amusing side effect of doing this is that I've had to separate quite a few chained assignments. It used to be perfectly fine to write 'a = b = c = TRUE' when a,b,c were int and TRUE was just a the 'true' defined by stdbool.h, that idiom provokes a warning from gcc: 'suggest parentheses around assignment used as truth value'!
2018-11-02 19:23:19 +00:00
bool force_manual_underline = false;
Re-engineering of terminal emulator, phase 1. The active terminal screen is no longer an array of `unsigned long' encoding 16-bit Unicode plus 16 attribute bits. Now it's an array of `termchar' structures, which currently have 32-bit Unicode and 32 attribute bits but which will probably expand further in future. To prevent bloat of the memory footprint, I've introduced a mostly RLE-like compression scheme for storing scrollback: each line is compressed into a compact (but hard to modify) form when it moves into the term->scrollback tree, and is temporarily decompressed when the user wants to scroll back over it. My initial tests suggest that this compression averages about 1/4 of the previous (32 bits per character cell) data size in typical output, which means this is an improvement even without counting the new ability to extend the information stored in each character cell. Another beneficial side effect is that the insane format in which Unicode was passed to front ends through do_text() has now been rendered sane. Testing is incomplete; this _may_ still have instabilities. Windows and Unix front ends both seem to work as far as I've looked, but I haven't yet looked very hard. The Mac front end I've edited (it seemed obvious how to change it) but I can't compile or test it. As an immediate functional effect, the terminal emulator now supports full 32-bit Unicode to whatever extent the host platform allows it to. For example, if you output a 4-or-more-byte UTF-8 character in Unix pterm, it will not display it properly, but it will correctly paste it back out in a UTF8_STRING selection. Windows is more restricted, sadly. [originally from svn r4609]
2004-10-13 11:50:16 +00:00
int fnt_width, char_width;
RDB's Unicode patch. Fonts are now used in Unicode mode where possible and we have a single unified means of trying to display any Unicode code point. Instead of the various ad-hoc translation modes we had before, we now have a single `codepage' option which allows us to treat the incoming (and outgoing) text as any given character set, and locally we map that to Unicode and back. [originally from svn r1110]
2001-05-10 08:34:20 +00:00
int text_adjust = 0;
Support for using variable-pitch fonts for the terminal on Windows. Done in much the same way as it is in the GTK front end: the character cell width is determined using the font's digits (which seems to give generally not-too-offensive spacing in most cases, at the expense of Ms and Ws typically overhanging a bit into adjacent cells) and each character is centred in its cell. Overhangs never leave permanent droppings on the window, because the existing work done in r5003 handles them just fine even in this stressful scenario. There's a hacky new checkbox in the Appearance panel to make variable-pitch fonts appear in the font selector (they still don't by default, because I still think it's _usually_ not What You Want); the checkbox state is not actually stored as part of a saved session, but it should be automatically ticked when reloading a session that's got a variable pitch font selected. (I'm half-expecting a potential flurry of requests for this feature in the wake of http://xkcd.com/840/ , so I thought I'd pre-empt them :-) [originally from svn r9063] [r5003 == ba470dec5e37ffbde05425f48e7e9a64219aec2e]
2010-12-29 14:11:25 +00:00
int xoffset = 0;
Convert a lot of 'int' variables to 'bool'. My normal habit these days, in new code, is to treat int and bool as _almost_ completely separate types. I'm still willing to use C's implicit test for zero on an integer (e.g. 'if (!blob.len)' is fine, no need to spell it out as blob.len != 0), but generally, if a variable is going to be conceptually a boolean, I like to declare it bool and assign to it using 'true' or 'false' rather than 0 or 1. PuTTY is an exception, because it predates the C99 bool, and I've stuck to its existing coding style even when adding new code to it. But it's been annoying me more and more, so now that I've decided C99 bool is an acceptable thing to require from our toolchain in the first place, here's a quite thorough trawl through the source doing 'boolification'. Many variables and function parameters are now typed as bool rather than int; many assignments of 0 or 1 to those variables are now spelled 'true' or 'false'. I managed this thorough conversion with the help of a custom clang plugin that I wrote to trawl the AST and apply heuristics to point out where things might want changing. So I've even managed to do a decent job on parts of the code I haven't looked at in years! To make the plugin's work easier, I pushed platform front ends generally in the direction of using standard 'bool' in preference to platform-specific boolean types like Windows BOOL or GTK's gboolean; I've left the platform booleans in places they _have_ to be for the platform APIs to work right, but variables only used by my own code have been converted wherever I found them. In a few places there are int values that look very like booleans in _most_ of the places they're used, but have a rarely-used third value, or a distinction between different nonzero values that most users don't care about. In these cases, I've _removed_ uses of 'true' and 'false' for the return values, to emphasise that there's something more subtle going on than a simple boolean answer: - the 'multisel' field in dialog.h's list box structure, for which the GTK front end in particular recognises a difference between 1 and 2 but nearly everything else treats as boolean - the 'urgent' parameter to plug_receive, where 1 vs 2 tells you something about the specific location of the urgent pointer, but most clients only care about 0 vs 'something nonzero' - the return value of wc_match, where -1 indicates a syntax error in the wildcard. - the return values from SSH-1 RSA-key loading functions, which use -1 for 'wrong passphrase' and 0 for all other failures (so any caller which already knows it's not loading an _encrypted private_ key can treat them as boolean) - term->esc_query, and the 'query' parameter in toggle_mode in terminal.c, which _usually_ hold 0 for ESC[123h or 1 for ESC[?123h, but can also hold -1 for some other intervening character that we don't support. In a few places there's an integer that I haven't turned into a bool even though it really _can_ only take values 0 or 1 (and, as above, tried to make the call sites consistent in not calling those values true and false), on the grounds that I thought it would make it more confusing to imply that the 0 value was in some sense 'negative' or bad and the 1 positive or good: - the return value of plug_accepting uses the POSIXish convention of 0=success and nonzero=error; I think if I made it bool then I'd also want to reverse its sense, and that's a job for a separate piece of work. - the 'screen' parameter to lineptr() in terminal.c, where 0 and 1 represent the default and alternate screens. There's no obvious reason why one of those should be considered 'true' or 'positive' or 'success' - they're just indices - so I've left it as int. ssh_scp_recv had particularly confusing semantics for its previous int return value: its call sites used '<= 0' to check for error, but it never actually returned a negative number, just 0 or 1. Now the function and its call sites agree that it's a bool. In a couple of places I've renamed variables called 'ret', because I don't like that name any more - it's unclear whether it means the return value (in preparation) for the _containing_ function or the return value received from a subroutine call, and occasionally I've accidentally used the same variable for both and introduced a bug. So where one of those got in my way, I've renamed it to 'toret' or 'retd' (the latter short for 'returned') in line with my usual modern practice, but I haven't done a thorough job of finding all of them. Finally, one amusing side effect of doing this is that I've had to separate quite a few chained assignments. It used to be perfectly fine to write 'a = b = c = TRUE' when a,b,c were int and TRUE was just a the 'true' defined by stdbool.h, that idiom provokes a warning from gcc: 'suggest parentheses around assignment used as truth value'!
2018-11-02 19:23:19 +00:00
int maxlen, remaining;
bool opaque;
bool is_cursor = false;
Remove some pointless 'static' qualifiers. In windows/window.c, a few variables inside functions were declared as static, with no particular purpose that I can see: they don't seem to have any reason to persist between calls to the function. So it makes more sense to have them be ordinary stack-allocated automatic variables. Static variables removed by this commit: - 'RECT ss' in reset_window. - 'WORD keys[3]' and 'BYTE keysb[3]' in TranslateKey. - several (buffer, length) pairs in do_text_internal. - keys_unicode[] in TranslateKey. All of these variables were originally introduced in patches credited to Robert de Bath, which means I can't even try to reconstruct my original thought processes, because they weren't _my_ thoughts anyway. The arrays in do_text_internal are the easiest to understand: they're reallocated larger as necessary, and making them static means the allocation from a previous call can be reused, saving a malloc (though I don't think that's a good enough reason to bother, these days). The fixed-size static arrays and RECT are harder to explain. I suspect they might originally have been that way because of 1990s attitudes to performance: in x86-32 it's probably marginally faster to give your variables constant addresses than sp-relative ones, and in the 1990s computers were much slower, so there's an argument for making things static if you have no _need_ to make them automatic. These days, the difference is negligible, and persistent state is much more widely recognised as a risk! But keys_unicode[] is by far the strangest, because there was code that clearly _did_ expect it to persist between calls, namely three assignments to keys_unicode[0] near the end of the function after it's finished being used for any other purpose, and a conditioned-out set of debug() calls at the top of the function that print its contents before anything has yet written to it. But as far as I can see, the persistent data in the array is otherwise completely unused. In any call to the function, if keys_unicode is used at all, then it's either written directly by a call to ToAsciiEx, or else (for pre-NT platforms) converted from ToAsciiEx's output via MultiByteToWideChar. In both cases, the integer variable 'r' indicates how many array elements were written, and subsequent accesses only ever read those elements. So the assignments to keys_unicode[0] at the end of the previous call will be overwritten before anything at all can depend on them - with the exception of those debug statements. I don't really understand what was going on here. It's tempting to guess that those final assignments must have once done something useful, and the code that used them was later removed. But the source control history doesn't bear that out: a static array of three elements (under its original name 'keys') was introduced in commit 0d5d39064a0d078, and then commits 953b7775b321a60 and 26f1085038d7cd9 added the other two assignments. And as far as I can see, even as of the original commit 0d5d39064a0d078, the code already had the property that there was a final assignment to keys[0] which would inevitably be overwritten in the next call before it could affect anything. So I'm totally confused about what those assignments were _ever_ useful for. But an email thread from the time suggests that some of those patches were being rebased repeatedly past other work (or rather, the much less reliable CVS analogue of rebasing), so my best guess is that that's where the confusion crept in - perhaps in RDB's original version of the code they did do something useful. Regardless of that, I'm pretty convinced that persistent array can't be doing anything useful _now_. So I'm taking it out. But if anyone reports a bug resulting from this change, then I'll eat my words - and with any luck the details of the bug report will give us a clue what's going on, and then we can put back some equivalent functionality with much better comments!
2023-05-27 13:56:31 +00:00
int *lpDx = NULL;
size_t lpDx_len = 0;
do_text_internal: fix bug in the lpDx_maybe mechanism. lpDx_maybe was a pointer defined to point at either lpDx itself or NULL, depending on whether the code decided it needed to pass the lpDx array of per-character pixel offsets to various functions during drawing (based in turn on whether the font was variable-pitch). lpDx is reallocated as necessary, which means lpDx_maybe must be kept up to date. This was achieved by resetting it to lpDx if it was already non-NULL. But lpDx starts out as NULL before the first reallocation, so that this can't work - it'll be initialised to NULL even if we _did_ want to use it, and then at the first realloc, it won't be updated! Before the previous commit turned lpDx from a static into an automatic variable, this would have been a rare bug affecting only the first call to the function. Now it will happen all the time, which is better, because we can notice and fix it. Replaced lpDx_maybe completely with a boolean flag indicating whether we should pass lpDx to drawing functions.
2023-05-27 14:26:38 +00:00
bool use_lpDx;
Remove some pointless 'static' qualifiers. In windows/window.c, a few variables inside functions were declared as static, with no particular purpose that I can see: they don't seem to have any reason to persist between calls to the function. So it makes more sense to have them be ordinary stack-allocated automatic variables. Static variables removed by this commit: - 'RECT ss' in reset_window. - 'WORD keys[3]' and 'BYTE keysb[3]' in TranslateKey. - several (buffer, length) pairs in do_text_internal. - keys_unicode[] in TranslateKey. All of these variables were originally introduced in patches credited to Robert de Bath, which means I can't even try to reconstruct my original thought processes, because they weren't _my_ thoughts anyway. The arrays in do_text_internal are the easiest to understand: they're reallocated larger as necessary, and making them static means the allocation from a previous call can be reused, saving a malloc (though I don't think that's a good enough reason to bother, these days). The fixed-size static arrays and RECT are harder to explain. I suspect they might originally have been that way because of 1990s attitudes to performance: in x86-32 it's probably marginally faster to give your variables constant addresses than sp-relative ones, and in the 1990s computers were much slower, so there's an argument for making things static if you have no _need_ to make them automatic. These days, the difference is negligible, and persistent state is much more widely recognised as a risk! But keys_unicode[] is by far the strangest, because there was code that clearly _did_ expect it to persist between calls, namely three assignments to keys_unicode[0] near the end of the function after it's finished being used for any other purpose, and a conditioned-out set of debug() calls at the top of the function that print its contents before anything has yet written to it. But as far as I can see, the persistent data in the array is otherwise completely unused. In any call to the function, if keys_unicode is used at all, then it's either written directly by a call to ToAsciiEx, or else (for pre-NT platforms) converted from ToAsciiEx's output via MultiByteToWideChar. In both cases, the integer variable 'r' indicates how many array elements were written, and subsequent accesses only ever read those elements. So the assignments to keys_unicode[0] at the end of the previous call will be overwritten before anything at all can depend on them - with the exception of those debug statements. I don't really understand what was going on here. It's tempting to guess that those final assignments must have once done something useful, and the code that used them was later removed. But the source control history doesn't bear that out: a static array of three elements (under its original name 'keys') was introduced in commit 0d5d39064a0d078, and then commits 953b7775b321a60 and 26f1085038d7cd9 added the other two assignments. And as far as I can see, even as of the original commit 0d5d39064a0d078, the code already had the property that there was a final assignment to keys[0] which would inevitably be overwritten in the next call before it could affect anything. So I'm totally confused about what those assignments were _ever_ useful for. But an email thread from the time suggests that some of those patches were being rebased repeatedly past other work (or rather, the much less reliable CVS analogue of rebasing), so my best guess is that that's where the confusion crept in - perhaps in RDB's original version of the code they did do something useful. Regardless of that, I'm pretty convinced that persistent array can't be doing anything useful _now_. So I'm taking it out. But if anyone reports a bug resulting from this change, then I'll eat my words - and with any luck the details of the bug report will give us a clue what's going on, and then we can put back some equivalent functionality with much better comments!
2023-05-27 13:56:31 +00:00
wchar_t *wbuf = NULL;
char *cbuf = NULL;
size_t wbuflen = 0, cbuflen = 0;
Patch from Yoshida Masato to fill in the missing pieces of Windows UTF-16 support. High Unicode characters in the terminal are now converted back into surrogates during copy and draw operations, and the Windows drawing code takes account of that when splitting up the UTF-16 string for display. Meanwhile, accidental uses of wchar_t have been replaced with 32-bit integers in parts of the cross-platform code which were expecting not to have to deal with UTF-16. [originally from svn r9409]
2012-02-17 19:28:55 +00:00
int len2; /* for SURROGATE PAIR */
RDB's Unicode patch. Fonts are now used in Unicode mode where possible and we have a single unified means of trying to display any Unicode code point. Instead of the various ad-hoc translation modes we had before, we now have a single `codepage' option which allows us to treat the incoming (and outgoing) text as any given character set, and locally we map that to Unicode and back. [originally from svn r1110]
2001-05-10 08:34:20 +00:00
Re-engineering of terminal emulator, phase 1. The active terminal screen is no longer an array of `unsigned long' encoding 16-bit Unicode plus 16 attribute bits. Now it's an array of `termchar' structures, which currently have 32-bit Unicode and 32 attribute bits but which will probably expand further in future. To prevent bloat of the memory footprint, I've introduced a mostly RLE-like compression scheme for storing scrollback: each line is compressed into a compact (but hard to modify) form when it moves into the term->scrollback tree, and is temporarily decompressed when the user wants to scroll back over it. My initial tests suggest that this compression averages about 1/4 of the previous (32 bits per character cell) data size in typical output, which means this is an improvement even without counting the new ability to extend the information stored in each character cell. Another beneficial side effect is that the insane format in which Unicode was passed to front ends through do_text() has now been rendered sane. Testing is incomplete; this _may_ still have instabilities. Windows and Unix front ends both seem to work as far as I've looked, but I haven't yet looked very hard. The Mac front end I've edited (it seemed obvious how to change it) but I can't compile or test it. As an immediate functional effect, the terminal emulator now supports full 32-bit Unicode to whatever extent the host platform allows it to. For example, if you output a 4-or-more-byte UTF-8 character in Unix pterm, it will not display it properly, but it will correctly paste it back out in a UTF8_STRING selection. Windows is more restricted, sadly. [originally from svn r4609]
2004-10-13 11:50:16 +00:00
lattr &= LATTR_MODE;
windows/window.c: move more variables into WinGuiSeat. In commit f9e572595bb8cb6 I claimed that I'd removed very nearly all the global and static variables from windows/window.c. It turns out that this was wildly overoptimistic - I missed quite a few of them! I'm not quite sure how I managed that; my best guess is that I used an underpowered 'nm' command that failed to find some classes of variable. Some of the remaining function-scope statics were removed completely by commit afb3dab1e97a09f just now. In this commit, I've swept up some more and turn them into fields of WinGuiSeat, where they should have been moved last September. The (hopefully complete this time) list of remaining variables, generated by running this rune in the Windows build directory: nm windows/CMakeFiles/putty.dir/window.c.obj | grep -E '^([^ ]+)? *[bBcCdDgGsS] [^\.]' consists of the following variables which are legitimately global across the whole process and not related to a particular window: - 'hinst' and 'hprev', instance handles for Windows loadable modules - 'classname' in the terminal_window_class_a() and terminal_window_class_w() functions, which allocate a window class reusably - some pointers to Windows API functions retrieved via the DECL_WINDOWS_FUNCTION / GET_WINDOWS_FUNCTION system, such as p_AdjustWindowRectExForDpi and p_FlashWindowEx - some pointers to Windows API functions set up by assigning them at startup to the right one of the ANSI or Unicode version depending on the Windows version, e.g. sw_DefWindowProc and sw_DispatchMessage - 'unicode_window', a boolean flag set at the same time as those sw_Foo function pointers - 'sesslist', storing the last-retrieved version of the saved sessions menu - 'cursor_visible' in show_mouseptr() and 'forced_visible' in update_mouse_pointer(), each of which tracks the cumulative number of times that function has shown or hidden the mouse pointer, so as to manage its effect on the global state updated by ShowCursor - 'trust_icon', loaded from the executable's resources - 'wgslisthead', the list of all active WinGuiSeats - 'wm_mousewheel', the window-message id we use for mouse wheel events and the following which are nothing to do with our code: - '_OptionsStorage' in __local_stdio_printf_options() and __local_stdio_scanf_options(), which I'd never noticed before, but apparently are internal to a standard library header.
2023-05-27 13:59:20 +00:00
char_width = fnt_width = wgs->font_width * (1 + (lattr != LATTR_NORM));
Re-engineering of terminal emulator, phase 1. The active terminal screen is no longer an array of `unsigned long' encoding 16-bit Unicode plus 16 attribute bits. Now it's an array of `termchar' structures, which currently have 32-bit Unicode and 32 attribute bits but which will probably expand further in future. To prevent bloat of the memory footprint, I've introduced a mostly RLE-like compression scheme for storing scrollback: each line is compressed into a compact (but hard to modify) form when it moves into the term->scrollback tree, and is temporarily decompressed when the user wants to scroll back over it. My initial tests suggest that this compression averages about 1/4 of the previous (32 bits per character cell) data size in typical output, which means this is an improvement even without counting the new ability to extend the information stored in each character cell. Another beneficial side effect is that the insane format in which Unicode was passed to front ends through do_text() has now been rendered sane. Testing is incomplete; this _may_ still have instabilities. Windows and Unix front ends both seem to work as far as I've looked, but I haven't yet looked very hard. The Mac front end I've edited (it seemed obvious how to change it) but I can't compile or test it. As an immediate functional effect, the terminal emulator now supports full 32-bit Unicode to whatever extent the host platform allows it to. For example, if you output a 4-or-more-byte UTF-8 character in Unix pterm, it will not display it properly, but it will correctly paste it back out in a UTF8_STRING selection. Windows is more restricted, sadly. [originally from svn r4609]
2004-10-13 11:50:16 +00:00
RDB's Unicode patch. Fonts are now used in Unicode mode where possible and we have a single unified means of trying to display any Unicode code point. Instead of the various ad-hoc translation modes we had before, we now have a single `codepage' option which allows us to treat the incoming (and outgoing) text as any given character set, and locally we map that to Unicode and back. [originally from svn r1110]
2001-05-10 08:34:20 +00:00
if (attr & ATTR_WIDE)
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
char_width *= 2;
RDB's patch: - use WM_TIMER for various things (blinking cursor; updates while moving/sizing; coping with overloading influx of netevents) - clip text output to avoid underlines outside character cell - even more careful font selection (we can now do OEMANSI by default) - a few extra keyboard mappings from the VTxxx terminals [originally from svn r418]
2000-03-17 10:34:41 +00:00
Three more patches from RDB: one to make Atomica work right, one to fiddle with the widths of characters in DBCS screen fonts, and (the big one) one to enable a mode in which resizing the window locks the terminal size and lets the font change, instead of vice versa. That should shut up a few feature requests! [originally from svn r1269]
2001-09-15 15:54:24 +00:00
/* Only want the left half of double width lines */
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
if (lattr != LATTR_NORM && x*2 >= wgs->term->cols)
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
return;
Three more patches from RDB: one to make Atomica work right, one to fiddle with the widths of characters in DBCS screen fonts, and (the big one) one to enable a mode in which resizing the window locks the terminal size and lets the font change, instead of vice versa. That should shut up a few feature requests! [originally from svn r1269]
2001-09-15 15:54:24 +00:00
Robert de Bath's Big Patch, part 1 [originally from svn r516]
2000-07-26 12:13:51 +00:00
x *= fnt_width;
windows/window.c: move more variables into WinGuiSeat. In commit f9e572595bb8cb6 I claimed that I'd removed very nearly all the global and static variables from windows/window.c. It turns out that this was wildly overoptimistic - I missed quite a few of them! I'm not quite sure how I managed that; my best guess is that I used an underpowered 'nm' command that failed to find some classes of variable. Some of the remaining function-scope statics were removed completely by commit afb3dab1e97a09f just now. In this commit, I've swept up some more and turn them into fields of WinGuiSeat, where they should have been moved last September. The (hopefully complete this time) list of remaining variables, generated by running this rune in the Windows build directory: nm windows/CMakeFiles/putty.dir/window.c.obj | grep -E '^([^ ]+)? *[bBcCdDgGsS] [^\.]' consists of the following variables which are legitimately global across the whole process and not related to a particular window: - 'hinst' and 'hprev', instance handles for Windows loadable modules - 'classname' in the terminal_window_class_a() and terminal_window_class_w() functions, which allocate a window class reusably - some pointers to Windows API functions retrieved via the DECL_WINDOWS_FUNCTION / GET_WINDOWS_FUNCTION system, such as p_AdjustWindowRectExForDpi and p_FlashWindowEx - some pointers to Windows API functions set up by assigning them at startup to the right one of the ANSI or Unicode version depending on the Windows version, e.g. sw_DefWindowProc and sw_DispatchMessage - 'unicode_window', a boolean flag set at the same time as those sw_Foo function pointers - 'sesslist', storing the last-retrieved version of the saved sessions menu - 'cursor_visible' in show_mouseptr() and 'forced_visible' in update_mouse_pointer(), each of which tracks the cumulative number of times that function has shown or hidden the mouse pointer, so as to manage its effect on the global state updated by ShowCursor - 'trust_icon', loaded from the executable's resources - 'wgslisthead', the list of all active WinGuiSeats - 'wm_mousewheel', the window-message id we use for mouse wheel events and the following which are nothing to do with our code: - '_OptionsStorage' in __local_stdio_printf_options() and __local_stdio_scanf_options(), which I'd never noticed before, but apparently are internal to a standard library header.
2023-05-27 13:59:20 +00:00
y *= wgs->font_height;
x += wgs->offset_width;
y += wgs->offset_height;
Initial checkin: beta 0.43 [originally from svn r11]
1999-01-08 13:02:13 +00:00
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
if ((attr & TATTR_ACTCURS) &&
Cleanup: make an enum for the values of CONF_cursor_type. These have been magic numbers 0, 1 and 2 in the source for ages. I think it's about time they had actual names, to make all the points of use clearer.
2023-05-29 14:51:17 +00:00
(wgs->cursor_type == CURSOR_BLOCK || wgs->term->big_cursor)) {
Make the cursor colour override true colour. Otherwise, moving the cursor (at least in active, filled-cell mode) on to a true-coloured character cell causes it to vanish completely because the cell's colours override the thing that differentiates the cursor.
2017-10-05 19:30:04 +00:00
truecolour.fg = truecolour.bg = optionalrgb_none;
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
attr &= ~(ATTR_REVERSE|ATTR_BLINK|ATTR_COLOURS|ATTR_DIM);
/* cursor fg and bg */
attr |= (260 << ATTR_FGSHIFT) | (261 << ATTR_BGSHIFT);
Adopt C99 <stdbool.h>'s true/false. This commit includes <stdbool.h> from defs.h and deletes my traditional definitions of TRUE and FALSE, but other than that, it's a 100% mechanical search-and-replace transforming all uses of TRUE and FALSE into the C99-standardised lowercase spellings. No actual types are changed in this commit; that will come next. This is just getting the noise out of the way, so that subsequent commits can have a higher proportion of signal.
2018-10-29 19:50:29 +00:00
is_cursor = true;
Initial checkin: beta 0.43 [originally from svn r11]
1999-01-08 13:02:13 +00:00
}
nfont = 0;
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
if (wgs->vtmode == VT_POORMAN && lattr != LATTR_NORM) {
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
/* Assume a poorman font is borken in other ways too. */
lattr = LATTR_WIDE;
RDB's Unicode patch. Fonts are now used in Unicode mode where possible and we have a single unified means of trying to display any Unicode code point. Instead of the various ad-hoc translation modes we had before, we now have a single `codepage' option which allows us to treat the incoming (and outgoing) text as any given character set, and locally we map that to Unicode and back. [originally from svn r1110]
2001-05-10 08:34:20 +00:00
} else
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
switch (lattr) {
case LATTR_NORM:
break;
case LATTR_WIDE:
nfont |= FONT_WIDE;
break;
default:
nfont |= FONT_WIDE + FONT_HIGH;
break;
}
Three more patches from RDB: one to make Atomica work right, one to fiddle with the widths of characters in DBCS screen fonts, and (the big one) one to enable a mode in which resizing the window locks the terminal size and lets the font change, instead of vice versa. That should shut up a few feature requests! [originally from svn r1269]
2001-09-15 15:54:24 +00:00
if (attr & ATTR_NARROW)
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
nfont |= FONT_NARROW;
RDB's Unicode patch. Fonts are now used in Unicode mode where possible and we have a single unified means of trying to display any Unicode code point. Instead of the various ad-hoc translation modes we had before, we now have a single `codepage' option which allows us to treat the incoming (and outgoing) text as any given character set, and locally we map that to Unicode and back. [originally from svn r1110]
2001-05-10 08:34:20 +00:00
Patch from Robert de Bath to ifdef out the Windows-specific hack for the offset horizontal line characters in the VT100 line-drawing set (o,p,r,s), so that no trace of it - and hence no pointless performance hit - is compiled into the cross-platform modules on non-Windows platforms. [originally from svn r9467]
2012-04-22 14:22:10 +00:00
#ifdef USES_VTLINE_HACK
RDB's Unicode patch. Fonts are now used in Unicode mode where possible and we have a single unified means of trying to display any Unicode code point. Instead of the various ad-hoc translation modes we had before, we now have a single `codepage' option which allows us to treat the incoming (and outgoing) text as any given character set, and locally we map that to Unicode and back. [originally from svn r1110]
2001-05-10 08:34:20 +00:00
/* Special hack for the VT100 linedraw glyphs. */
Re-engineering of terminal emulator, phase 1. The active terminal screen is no longer an array of `unsigned long' encoding 16-bit Unicode plus 16 attribute bits. Now it's an array of `termchar' structures, which currently have 32-bit Unicode and 32 attribute bits but which will probably expand further in future. To prevent bloat of the memory footprint, I've introduced a mostly RLE-like compression scheme for storing scrollback: each line is compressed into a compact (but hard to modify) form when it moves into the term->scrollback tree, and is temporarily decompressed when the user wants to scroll back over it. My initial tests suggest that this compression averages about 1/4 of the previous (32 bits per character cell) data size in typical output, which means this is an improvement even without counting the new ability to extend the information stored in each character cell. Another beneficial side effect is that the insane format in which Unicode was passed to front ends through do_text() has now been rendered sane. Testing is incomplete; this _may_ still have instabilities. Windows and Unix front ends both seem to work as far as I've looked, but I haven't yet looked very hard. The Mac front end I've edited (it seemed obvious how to change it) but I can't compile or test it. As an immediate functional effect, the terminal emulator now supports full 32-bit Unicode to whatever extent the host platform allows it to. For example, if you output a 4-or-more-byte UTF-8 character in Unix pterm, it will not display it properly, but it will correctly paste it back out in a UTF8_STRING selection. Windows is more restricted, sadly. [originally from svn r4609]
2004-10-13 11:50:16 +00:00
if (text[0] >= 0x23BA && text[0] <= 0x23BD) {
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
switch ((unsigned char) (text[0])) {
case 0xBA:
windows/window.c: move more variables into WinGuiSeat. In commit f9e572595bb8cb6 I claimed that I'd removed very nearly all the global and static variables from windows/window.c. It turns out that this was wildly overoptimistic - I missed quite a few of them! I'm not quite sure how I managed that; my best guess is that I used an underpowered 'nm' command that failed to find some classes of variable. Some of the remaining function-scope statics were removed completely by commit afb3dab1e97a09f just now. In this commit, I've swept up some more and turn them into fields of WinGuiSeat, where they should have been moved last September. The (hopefully complete this time) list of remaining variables, generated by running this rune in the Windows build directory: nm windows/CMakeFiles/putty.dir/window.c.obj | grep -E '^([^ ]+)? *[bBcCdDgGsS] [^\.]' consists of the following variables which are legitimately global across the whole process and not related to a particular window: - 'hinst' and 'hprev', instance handles for Windows loadable modules - 'classname' in the terminal_window_class_a() and terminal_window_class_w() functions, which allocate a window class reusably - some pointers to Windows API functions retrieved via the DECL_WINDOWS_FUNCTION / GET_WINDOWS_FUNCTION system, such as p_AdjustWindowRectExForDpi and p_FlashWindowEx - some pointers to Windows API functions set up by assigning them at startup to the right one of the ANSI or Unicode version depending on the Windows version, e.g. sw_DefWindowProc and sw_DispatchMessage - 'unicode_window', a boolean flag set at the same time as those sw_Foo function pointers - 'sesslist', storing the last-retrieved version of the saved sessions menu - 'cursor_visible' in show_mouseptr() and 'forced_visible' in update_mouse_pointer(), each of which tracks the cumulative number of times that function has shown or hidden the mouse pointer, so as to manage its effect on the global state updated by ShowCursor - 'trust_icon', loaded from the executable's resources - 'wgslisthead', the list of all active WinGuiSeats - 'wm_mousewheel', the window-message id we use for mouse wheel events and the following which are nothing to do with our code: - '_OptionsStorage' in __local_stdio_printf_options() and __local_stdio_scanf_options(), which I'd never noticed before, but apparently are internal to a standard library header.
2023-05-27 13:59:20 +00:00
text_adjust = -2 * wgs->font_height / 5;
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
break;
case 0xBB:
windows/window.c: move more variables into WinGuiSeat. In commit f9e572595bb8cb6 I claimed that I'd removed very nearly all the global and static variables from windows/window.c. It turns out that this was wildly overoptimistic - I missed quite a few of them! I'm not quite sure how I managed that; my best guess is that I used an underpowered 'nm' command that failed to find some classes of variable. Some of the remaining function-scope statics were removed completely by commit afb3dab1e97a09f just now. In this commit, I've swept up some more and turn them into fields of WinGuiSeat, where they should have been moved last September. The (hopefully complete this time) list of remaining variables, generated by running this rune in the Windows build directory: nm windows/CMakeFiles/putty.dir/window.c.obj | grep -E '^([^ ]+)? *[bBcCdDgGsS] [^\.]' consists of the following variables which are legitimately global across the whole process and not related to a particular window: - 'hinst' and 'hprev', instance handles for Windows loadable modules - 'classname' in the terminal_window_class_a() and terminal_window_class_w() functions, which allocate a window class reusably - some pointers to Windows API functions retrieved via the DECL_WINDOWS_FUNCTION / GET_WINDOWS_FUNCTION system, such as p_AdjustWindowRectExForDpi and p_FlashWindowEx - some pointers to Windows API functions set up by assigning them at startup to the right one of the ANSI or Unicode version depending on the Windows version, e.g. sw_DefWindowProc and sw_DispatchMessage - 'unicode_window', a boolean flag set at the same time as those sw_Foo function pointers - 'sesslist', storing the last-retrieved version of the saved sessions menu - 'cursor_visible' in show_mouseptr() and 'forced_visible' in update_mouse_pointer(), each of which tracks the cumulative number of times that function has shown or hidden the mouse pointer, so as to manage its effect on the global state updated by ShowCursor - 'trust_icon', loaded from the executable's resources - 'wgslisthead', the list of all active WinGuiSeats - 'wm_mousewheel', the window-message id we use for mouse wheel events and the following which are nothing to do with our code: - '_OptionsStorage' in __local_stdio_printf_options() and __local_stdio_scanf_options(), which I'd never noticed before, but apparently are internal to a standard library header.
2023-05-27 13:59:20 +00:00
text_adjust = -1 * wgs->font_height / 5;
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
break;
case 0xBC:
windows/window.c: move more variables into WinGuiSeat. In commit f9e572595bb8cb6 I claimed that I'd removed very nearly all the global and static variables from windows/window.c. It turns out that this was wildly overoptimistic - I missed quite a few of them! I'm not quite sure how I managed that; my best guess is that I used an underpowered 'nm' command that failed to find some classes of variable. Some of the remaining function-scope statics were removed completely by commit afb3dab1e97a09f just now. In this commit, I've swept up some more and turn them into fields of WinGuiSeat, where they should have been moved last September. The (hopefully complete this time) list of remaining variables, generated by running this rune in the Windows build directory: nm windows/CMakeFiles/putty.dir/window.c.obj | grep -E '^([^ ]+)? *[bBcCdDgGsS] [^\.]' consists of the following variables which are legitimately global across the whole process and not related to a particular window: - 'hinst' and 'hprev', instance handles for Windows loadable modules - 'classname' in the terminal_window_class_a() and terminal_window_class_w() functions, which allocate a window class reusably - some pointers to Windows API functions retrieved via the DECL_WINDOWS_FUNCTION / GET_WINDOWS_FUNCTION system, such as p_AdjustWindowRectExForDpi and p_FlashWindowEx - some pointers to Windows API functions set up by assigning them at startup to the right one of the ANSI or Unicode version depending on the Windows version, e.g. sw_DefWindowProc and sw_DispatchMessage - 'unicode_window', a boolean flag set at the same time as those sw_Foo function pointers - 'sesslist', storing the last-retrieved version of the saved sessions menu - 'cursor_visible' in show_mouseptr() and 'forced_visible' in update_mouse_pointer(), each of which tracks the cumulative number of times that function has shown or hidden the mouse pointer, so as to manage its effect on the global state updated by ShowCursor - 'trust_icon', loaded from the executable's resources - 'wgslisthead', the list of all active WinGuiSeats - 'wm_mousewheel', the window-message id we use for mouse wheel events and the following which are nothing to do with our code: - '_OptionsStorage' in __local_stdio_printf_options() and __local_stdio_scanf_options(), which I'd never noticed before, but apparently are internal to a standard library header.
2023-05-27 13:59:20 +00:00
text_adjust = wgs->font_height / 5;
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
break;
case 0xBD:
windows/window.c: move more variables into WinGuiSeat. In commit f9e572595bb8cb6 I claimed that I'd removed very nearly all the global and static variables from windows/window.c. It turns out that this was wildly overoptimistic - I missed quite a few of them! I'm not quite sure how I managed that; my best guess is that I used an underpowered 'nm' command that failed to find some classes of variable. Some of the remaining function-scope statics were removed completely by commit afb3dab1e97a09f just now. In this commit, I've swept up some more and turn them into fields of WinGuiSeat, where they should have been moved last September. The (hopefully complete this time) list of remaining variables, generated by running this rune in the Windows build directory: nm windows/CMakeFiles/putty.dir/window.c.obj | grep -E '^([^ ]+)? *[bBcCdDgGsS] [^\.]' consists of the following variables which are legitimately global across the whole process and not related to a particular window: - 'hinst' and 'hprev', instance handles for Windows loadable modules - 'classname' in the terminal_window_class_a() and terminal_window_class_w() functions, which allocate a window class reusably - some pointers to Windows API functions retrieved via the DECL_WINDOWS_FUNCTION / GET_WINDOWS_FUNCTION system, such as p_AdjustWindowRectExForDpi and p_FlashWindowEx - some pointers to Windows API functions set up by assigning them at startup to the right one of the ANSI or Unicode version depending on the Windows version, e.g. sw_DefWindowProc and sw_DispatchMessage - 'unicode_window', a boolean flag set at the same time as those sw_Foo function pointers - 'sesslist', storing the last-retrieved version of the saved sessions menu - 'cursor_visible' in show_mouseptr() and 'forced_visible' in update_mouse_pointer(), each of which tracks the cumulative number of times that function has shown or hidden the mouse pointer, so as to manage its effect on the global state updated by ShowCursor - 'trust_icon', loaded from the executable's resources - 'wgslisthead', the list of all active WinGuiSeats - 'wm_mousewheel', the window-message id we use for mouse wheel events and the following which are nothing to do with our code: - '_OptionsStorage' in __local_stdio_printf_options() and __local_stdio_scanf_options(), which I'd never noticed before, but apparently are internal to a standard library header.
2023-05-27 13:59:20 +00:00
text_adjust = 2 * wgs->font_height / 5;
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
break;
}
if (lattr == LATTR_TOP || lattr == LATTR_BOT)
text_adjust *= 2;
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
text[0] = wgs->ucsdata.unitab_xterm['q'];
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
if (attr & ATTR_UNDER) {
attr &= ~ATTR_UNDER;
force_manual_underline = true;
}
Initial checkin: beta 0.43 [originally from svn r11]
1999-01-08 13:02:13 +00:00
}
Patch from Robert de Bath to ifdef out the Windows-specific hack for the offset horizontal line characters in the VT100 line-drawing set (o,p,r,s), so that no trace of it - and hence no pointless performance hit - is compiled into the cross-platform modules on non-Windows platforms. [originally from svn r9467]
2012-04-22 14:22:10 +00:00
#endif
Initial checkin: beta 0.43 [originally from svn r11]
1999-01-08 13:02:13 +00:00
RDB's Unicode patch. Fonts are now used in Unicode mode where possible and we have a single unified means of trying to display any Unicode code point. Instead of the various ad-hoc translation modes we had before, we now have a single `codepage' option which allows us to treat the incoming (and outgoing) text as any given character set, and locally we map that to Unicode and back. [originally from svn r1110]
2001-05-10 08:34:20 +00:00
/* Anything left as an original character set is unprintable. */
Patch from Yoshida Masato to fill in the missing pieces of Windows UTF-16 support. High Unicode characters in the terminal are now converted back into surrogates during copy and draw operations, and the Windows drawing code takes account of that when splitting up the UTF-16 string for display. Meanwhile, accidental uses of wchar_t have been replaced with 32-bit integers in parts of the cross-platform code which were expecting not to have to deal with UTF-16. [originally from svn r9409]
2012-02-17 19:28:55 +00:00
if (DIRECT_CHAR(text[0]) &&
(len < 2 || !IS_SURROGATE_PAIR(text[0], text[1]))) {
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
int i;
for (i = 0; i < len; i++)
text[i] = 0xFFFD;
RDB's Unicode patch. Fonts are now used in Unicode mode where possible and we have a single unified means of trying to display any Unicode code point. Instead of the various ad-hoc translation modes we had before, we now have a single `codepage' option which allows us to treat the incoming (and outgoing) text as any given character set, and locally we map that to Unicode and back. [originally from svn r1110]
2001-05-10 08:34:20 +00:00
}
/* OEM CP */
Re-engineering of terminal emulator, phase 1. The active terminal screen is no longer an array of `unsigned long' encoding 16-bit Unicode plus 16 attribute bits. Now it's an array of `termchar' structures, which currently have 32-bit Unicode and 32 attribute bits but which will probably expand further in future. To prevent bloat of the memory footprint, I've introduced a mostly RLE-like compression scheme for storing scrollback: each line is compressed into a compact (but hard to modify) form when it moves into the term->scrollback tree, and is temporarily decompressed when the user wants to scroll back over it. My initial tests suggest that this compression averages about 1/4 of the previous (32 bits per character cell) data size in typical output, which means this is an improvement even without counting the new ability to extend the information stored in each character cell. Another beneficial side effect is that the insane format in which Unicode was passed to front ends through do_text() has now been rendered sane. Testing is incomplete; this _may_ still have instabilities. Windows and Unix front ends both seem to work as far as I've looked, but I haven't yet looked very hard. The Mac front end I've edited (it seemed obvious how to change it) but I can't compile or test it. As an immediate functional effect, the terminal emulator now supports full 32-bit Unicode to whatever extent the host platform allows it to. For example, if you output a 4-or-more-byte UTF-8 character in Unix pterm, it will not display it properly, but it will correctly paste it back out in a UTF8_STRING selection. Windows is more restricted, sadly. [originally from svn r4609]
2004-10-13 11:50:16 +00:00
if ((text[0] & CSET_MASK) == CSET_OEMCP)
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
nfont |= FONT_OEM;
RDB's Unicode patch. Fonts are now used in Unicode mode where possible and we have a single unified means of trying to display any Unicode code point. Instead of the various ad-hoc translation modes we had before, we now have a single `codepage' option which allows us to treat the incoming (and outgoing) text as any given character set, and locally we map that to Unicode and back. [originally from svn r1110]
2001-05-10 08:34:20 +00:00
xterm apparently supports ESC[90m through ESC[97m to set bright foreground colours, and ESC[100m through ESC[107m to set bright background colours. Hence, so do we. Bright-foreground is distinguishable from bold, and bright-background distinguishable from blink, when it leaves terminal.c; the front end may then choose to display them in the same way if it's configured to do so. This change makes the xterm backend for Turbo Vision (!!!) work properly. Untested on Mac. [originally from svn r2734]
2003-01-27 23:03:31 +00:00
nfg = ((attr & ATTR_FGMASK) >> ATTR_FGSHIFT);
nbg = ((attr & ATTR_BGMASK) >> ATTR_BGSHIFT);
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
if (wgs->bold_font_mode == BOLD_FONT && (attr & ATTR_BOLD))
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
nfont |= FONT_BOLD;
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
if (wgs->und_mode == UND_FONT && (attr & ATTR_UNDER))
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
nfont |= FONT_UNDERLINE;
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
another_font(wgs, nfont);
if (!wgs->fonts[nfont]) {
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
if (nfont & FONT_UNDERLINE)
force_manual_underline = true;
/* Don't do the same for manual bold, it could be bad news. */
RDB's patch: - use WM_TIMER for various things (blinking cursor; updates while moving/sizing; coping with overloading influx of netevents) - clip text output to avoid underlines outside character cell - even more careful font selection (we can now do OEMANSI by default) - a few extra keyboard mappings from the VTxxx terminals [originally from svn r418]
2000-03-17 10:34:41 +00:00
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
nfont &= ~(FONT_BOLD | FONT_UNDERLINE);
RDB's patch: - use WM_TIMER for various things (blinking cursor; updates while moving/sizing; coping with overloading influx of netevents) - clip text output to avoid underlines outside character cell - even more careful font selection (we can now do OEMANSI by default) - a few extra keyboard mappings from the VTxxx terminals [originally from svn r418]
2000-03-17 10:34:41 +00:00
}
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
another_font(wgs, nfont);
if (!wgs->fonts[nfont])
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
nfont = FONT_NORMAL;
Initial checkin: beta 0.43 [originally from svn r11]
1999-01-08 13:02:13 +00:00
if (attr & ATTR_REVERSE) {
Make reverse video interact correctly with true colour. ATTR_REVERSE was being handled in the front ends, and was causing the foreground and background colours to be switched. (I'm not completely sure why I made that design decision; it might be purely historical, but then again, it might also be because reverse video is one effect on the fg and bg colours that must still be performed even in unusual frontend-specific situations like display-driven monochrome mode.) This affected both explicit reverse video enabled using SGR 7, and also the transient reverse video arising from mouse selection. Thanks to Markus Gans for reporting the bug in the latter, which when I investigated it turned out to affect the former as well.
2017-10-08 12:49:54 +00:00
struct optionalrgb trgb;
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
t = nfg;
nfg = nbg;
nbg = t;
Make reverse video interact correctly with true colour. ATTR_REVERSE was being handled in the front ends, and was causing the foreground and background colours to be switched. (I'm not completely sure why I made that design decision; it might be purely historical, but then again, it might also be because reverse video is one effect on the fg and bg colours that must still be performed even in unusual frontend-specific situations like display-driven monochrome mode.) This affected both explicit reverse video enabled using SGR 7, and also the transient reverse video arising from mouse selection. Thanks to Markus Gans for reporting the bug in the latter, which when I investigated it turned out to affect the former as well.
2017-10-08 12:49:54 +00:00
trgb = truecolour.fg;
truecolour.fg = truecolour.bg;
truecolour.bg = trgb;
Initial checkin: beta 0.43 [originally from svn r11]
1999-01-08 13:02:13 +00:00
}
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
if (wgs->bold_colours && (attr & ATTR_BOLD) && !is_cursor) {
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
if (nfg < 16) nfg |= 8;
else if (nfg >= 256) nfg |= 1;
Implement xterm 256-colour mode. [originally from svn r4917] [this svn revision also touched putty-wishlist]
2004-11-28 15:13:34 +00:00
}
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
if (wgs->bold_colours && (attr & ATTR_BLINK)) {
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
if (nbg < 16) nbg |= 8;
else if (nbg >= 256) nbg |= 1;
Implement xterm 256-colour mode. [originally from svn r4917] [this svn revision also touched putty-wishlist]
2004-11-28 15:13:34 +00:00
}
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
if (!wgs->pal && truecolour.fg.enabled)
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
fg = RGB(truecolour.fg.r, truecolour.fg.g, truecolour.fg.b);
Support ESC[38;2;R;G;Bm for 24-bit true colour. This is a heavily rewritten version of a patch originally by Lorenz Diener; it was tidied up somewhat by Christian Brabandt, and then tidied up more by me. The basic idea is to add to the termchar structure a pair of small structs encoding 24-bit RGB values, each with a flag indicating whether it's turned on; if it is, it overrides any other specification of fg or bg colour for that character cell. I've added a test line to colours.txt containing a few example colours from /usr/share/X11/rgb.txt. In fact it makes quite a good demo to run the whole of rgb.txt through this treatment, with a command such as perl -pe 's!^\s*(\d+)\s+(\d+)\s+(\d+).*$!\e[38;2;$1;$2;$3m$&\e[m!' rgb.txt
2017-09-30 16:32:32 +00:00
else
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
fg = wgs->colours[nfg];
Support ESC[38;2;R;G;Bm for 24-bit true colour. This is a heavily rewritten version of a patch originally by Lorenz Diener; it was tidied up somewhat by Christian Brabandt, and then tidied up more by me. The basic idea is to add to the termchar structure a pair of small structs encoding 24-bit RGB values, each with a flag indicating whether it's turned on; if it is, it overrides any other specification of fg or bg colour for that character cell. I've added a test line to colours.txt containing a few example colours from /usr/share/X11/rgb.txt. In fact it makes quite a good demo to run the whole of rgb.txt through this treatment, with a command such as perl -pe 's!^\s*(\d+)\s+(\d+)\s+(\d+).*$!\e[38;2;$1;$2;$3m$&\e[m!' rgb.txt
2017-09-30 16:32:32 +00:00
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
if (!wgs->pal && truecolour.bg.enabled)
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
bg = RGB(truecolour.bg.r, truecolour.bg.g, truecolour.bg.b);
Support ESC[38;2;R;G;Bm for 24-bit true colour. This is a heavily rewritten version of a patch originally by Lorenz Diener; it was tidied up somewhat by Christian Brabandt, and then tidied up more by me. The basic idea is to add to the termchar structure a pair of small structs encoding 24-bit RGB values, each with a flag indicating whether it's turned on; if it is, it overrides any other specification of fg or bg colour for that character cell. I've added a test line to colours.txt containing a few example colours from /usr/share/X11/rgb.txt. In fact it makes quite a good demo to run the whole of rgb.txt through this treatment, with a command such as perl -pe 's!^\s*(\d+)\s+(\d+)\s+(\d+).*$!\e[38;2;$1;$2;$3m$&\e[m!' rgb.txt
2017-09-30 16:32:32 +00:00
else
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
bg = wgs->colours[nbg];
Support ESC[38;2;R;G;Bm for 24-bit true colour. This is a heavily rewritten version of a patch originally by Lorenz Diener; it was tidied up somewhat by Christian Brabandt, and then tidied up more by me. The basic idea is to add to the termchar structure a pair of small structs encoding 24-bit RGB values, each with a flag indicating whether it's turned on; if it is, it overrides any other specification of fg or bg colour for that character cell. I've added a test line to colours.txt containing a few example colours from /usr/share/X11/rgb.txt. In fact it makes quite a good demo to run the whole of rgb.txt through this treatment, with a command such as perl -pe 's!^\s*(\d+)\s+(\d+)\s+(\d+).*$!\e[38;2;$1;$2;$3m$&\e[m!' rgb.txt
2017-09-30 16:32:32 +00:00
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
if (!wgs->pal && (attr & ATTR_DIM)) {
Support SGR 2 to dim the foreground colour. I've done this on a 'where possible' basis: in Windows paletted mode (in case anyone is still using an old enough graphics card to need that!) I simply haven't bothered, and will completely ignore the dim flag.
2017-10-05 20:02:56 +00:00
fg = RGB(GetRValue(fg) * 2 / 3,
GetGValue(fg) * 2 / 3,
GetBValue(fg) * 2 / 3);
}
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
SelectObject(wgs->wintw_hdc, wgs->fonts[nfont]);
SetTextColor(wgs->wintw_hdc, fg);
SetBkColor(wgs->wintw_hdc, bg);
First-stage support for Unicode combining characters. The `chars' array of each `termline' structure now contains optional additional entries after the normal number of columns, which are used to chain a linked list of combining characters off any primary termchar that needs it. This means we support arbitrarily many combining characters per cell (unlike xterm's hard limit of 2). Cut and paste works correctly (selecting a character cell containing multiple code points causes all those code points to be cut and pasted). Display works by simply overlaying all the relevant characters on top of one another; this is good enough for Unix (xterm does the same thing), and mostly seems OK for Windows except that the Windows Unicode fonts have a nasty habit of not containing most of the combining characters and thus overlaying an unknown-code-point box on your perfectly good base glyph. I had no idea how to add support in the Mac do_text(), so I've simply stuck in an assertion that will trigger the first time a combining character is displayed, and hopefully this will bite someone with the clue to fix it. [originally from svn r4622]
2004-10-14 16:42:43 +00:00
if (attr & TATTR_COMBINING)
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
SetBkMode(wgs->wintw_hdc, TRANSPARENT);
First-stage support for Unicode combining characters. The `chars' array of each `termline' structure now contains optional additional entries after the normal number of columns, which are used to chain a linked list of combining characters off any primary termchar that needs it. This means we support arbitrarily many combining characters per cell (unlike xterm's hard limit of 2). Cut and paste works correctly (selecting a character cell containing multiple code points causes all those code points to be cut and pasted). Display works by simply overlaying all the relevant characters on top of one another; this is good enough for Unix (xterm does the same thing), and mostly seems OK for Windows except that the Windows Unicode fonts have a nasty habit of not containing most of the combining characters and thus overlaying an unknown-code-point box on your perfectly good base glyph. I had no idea how to add support in the Mac do_text(), so I've simply stuck in an assertion that will trigger the first time a combining character is displayed, and hopefully this will bite someone with the clue to fix it. [originally from svn r4622]
2004-10-14 16:42:43 +00:00
else
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
SetBkMode(wgs->wintw_hdc, OPAQUE);
Run entire source base through GNU indent to tidy up the varying coding styles of the various contributors! Woohoo! [originally from svn r1098]
2001-05-06 14:35:20 +00:00
line_box.left = x;
line_box.top = y;
RDB's Unicode patch. Fonts are now used in Unicode mode where possible and we have a single unified means of trying to display any Unicode code point. Instead of the various ad-hoc translation modes we had before, we now have a single `codepage' option which allows us to treat the incoming (and outgoing) text as any given character set, and locally we map that to Unicode and back. [originally from svn r1110]
2001-05-10 08:34:20 +00:00
line_box.right = x + char_width * len;
windows/window.c: move more variables into WinGuiSeat. In commit f9e572595bb8cb6 I claimed that I'd removed very nearly all the global and static variables from windows/window.c. It turns out that this was wildly overoptimistic - I missed quite a few of them! I'm not quite sure how I managed that; my best guess is that I used an underpowered 'nm' command that failed to find some classes of variable. Some of the remaining function-scope statics were removed completely by commit afb3dab1e97a09f just now. In this commit, I've swept up some more and turn them into fields of WinGuiSeat, where they should have been moved last September. The (hopefully complete this time) list of remaining variables, generated by running this rune in the Windows build directory: nm windows/CMakeFiles/putty.dir/window.c.obj | grep -E '^([^ ]+)? *[bBcCdDgGsS] [^\.]' consists of the following variables which are legitimately global across the whole process and not related to a particular window: - 'hinst' and 'hprev', instance handles for Windows loadable modules - 'classname' in the terminal_window_class_a() and terminal_window_class_w() functions, which allocate a window class reusably - some pointers to Windows API functions retrieved via the DECL_WINDOWS_FUNCTION / GET_WINDOWS_FUNCTION system, such as p_AdjustWindowRectExForDpi and p_FlashWindowEx - some pointers to Windows API functions set up by assigning them at startup to the right one of the ANSI or Unicode version depending on the Windows version, e.g. sw_DefWindowProc and sw_DispatchMessage - 'unicode_window', a boolean flag set at the same time as those sw_Foo function pointers - 'sesslist', storing the last-retrieved version of the saved sessions menu - 'cursor_visible' in show_mouseptr() and 'forced_visible' in update_mouse_pointer(), each of which tracks the cumulative number of times that function has shown or hidden the mouse pointer, so as to manage its effect on the global state updated by ShowCursor - 'trust_icon', loaded from the executable's resources - 'wgslisthead', the list of all active WinGuiSeats - 'wm_mousewheel', the window-message id we use for mouse wheel events and the following which are nothing to do with our code: - '_OptionsStorage' in __local_stdio_printf_options() and __local_stdio_scanf_options(), which I'd never noticed before, but apparently are internal to a standard library header.
2023-05-27 13:59:20 +00:00
line_box.bottom = y + wgs->font_height;
Patch from Yoshida Masato to fill in the missing pieces of Windows UTF-16 support. High Unicode characters in the terminal are now converted back into surrogates during copy and draw operations, and the Windows drawing code takes account of that when splitting up the UTF-16 string for display. Meanwhile, accidental uses of wchar_t have been replaced with 32-bit integers in parts of the cross-platform code which were expecting not to have to deal with UTF-16. [originally from svn r9409]
2012-02-17 19:28:55 +00:00
/* adjust line_box.right for SURROGATE PAIR & VARIATION SELECTOR */
{
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
int i;
int rc_width = 0;
for (i = 0; i < len ; i++) {
if (i+1 < len && IS_HIGH_VARSEL(text[i], text[i+1])) {
i++;
} else if (i+1 < len && IS_SURROGATE_PAIR(text[i], text[i+1])) {
rc_width += char_width;
i++;
} else if (IS_LOW_VARSEL(text[i])) {
/* do nothing */
Patch from Yoshida Masato to fill in the missing pieces of Windows UTF-16 support. High Unicode characters in the terminal are now converted back into surrogates during copy and draw operations, and the Windows drawing code takes account of that when splitting up the UTF-16 string for display. Meanwhile, accidental uses of wchar_t have been replaced with 32-bit integers in parts of the cross-platform code which were expecting not to have to deal with UTF-16. [originally from svn r9409]
2012-02-17 19:28:55 +00:00
} else {
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
rc_width += char_width;
Patch from Yoshida Masato to fill in the missing pieces of Windows UTF-16 support. High Unicode characters in the terminal are now converted back into surrogates during copy and draw operations, and the Windows drawing code takes account of that when splitting up the UTF-16 string for display. Meanwhile, accidental uses of wchar_t have been replaced with 32-bit integers in parts of the cross-platform code which were expecting not to have to deal with UTF-16. [originally from svn r9409]
2012-02-17 19:28:55 +00:00
}
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
}
line_box.right = line_box.left + rc_width;
Patch from Yoshida Masato to fill in the missing pieces of Windows UTF-16 support. High Unicode characters in the terminal are now converted back into surrogates during copy and draw operations, and the Windows drawing code takes account of that when splitting up the UTF-16 string for display. Meanwhile, accidental uses of wchar_t have been replaced with 32-bit integers in parts of the cross-platform code which were expecting not to have to deal with UTF-16. [originally from svn r9409]
2012-02-17 19:28:55 +00:00
}
RDB's Unicode patch. Fonts are now used in Unicode mode where possible and we have a single unified means of trying to display any Unicode code point. Instead of the various ad-hoc translation modes we had before, we now have a single `codepage' option which allows us to treat the incoming (and outgoing) text as any given character set, and locally we map that to Unicode and back. [originally from svn r1110]
2001-05-10 08:34:20 +00:00
Three more patches from RDB: one to make Atomica work right, one to fiddle with the widths of characters in DBCS screen fonts, and (the big one) one to enable a mode in which resizing the window locks the terminal size and lets the font change, instead of vice versa. That should shut up a few feature requests! [originally from svn r1269]
2001-09-15 15:54:24 +00:00
/* Only want the left half of double width lines */
windows/window.c: move more variables into WinGuiSeat. In commit f9e572595bb8cb6 I claimed that I'd removed very nearly all the global and static variables from windows/window.c. It turns out that this was wildly overoptimistic - I missed quite a few of them! I'm not quite sure how I managed that; my best guess is that I used an underpowered 'nm' command that failed to find some classes of variable. Some of the remaining function-scope statics were removed completely by commit afb3dab1e97a09f just now. In this commit, I've swept up some more and turn them into fields of WinGuiSeat, where they should have been moved last September. The (hopefully complete this time) list of remaining variables, generated by running this rune in the Windows build directory: nm windows/CMakeFiles/putty.dir/window.c.obj | grep -E '^([^ ]+)? *[bBcCdDgGsS] [^\.]' consists of the following variables which are legitimately global across the whole process and not related to a particular window: - 'hinst' and 'hprev', instance handles for Windows loadable modules - 'classname' in the terminal_window_class_a() and terminal_window_class_w() functions, which allocate a window class reusably - some pointers to Windows API functions retrieved via the DECL_WINDOWS_FUNCTION / GET_WINDOWS_FUNCTION system, such as p_AdjustWindowRectExForDpi and p_FlashWindowEx - some pointers to Windows API functions set up by assigning them at startup to the right one of the ANSI or Unicode version depending on the Windows version, e.g. sw_DefWindowProc and sw_DispatchMessage - 'unicode_window', a boolean flag set at the same time as those sw_Foo function pointers - 'sesslist', storing the last-retrieved version of the saved sessions menu - 'cursor_visible' in show_mouseptr() and 'forced_visible' in update_mouse_pointer(), each of which tracks the cumulative number of times that function has shown or hidden the mouse pointer, so as to manage its effect on the global state updated by ShowCursor - 'trust_icon', loaded from the executable's resources - 'wgslisthead', the list of all active WinGuiSeats - 'wm_mousewheel', the window-message id we use for mouse wheel events and the following which are nothing to do with our code: - '_OptionsStorage' in __local_stdio_printf_options() and __local_stdio_scanf_options(), which I'd never noticed before, but apparently are internal to a standard library header.
2023-05-27 13:59:20 +00:00
if (line_box.right > wgs->font_width*wgs->term->cols+wgs->offset_width)
line_box.right = wgs->font_width*wgs->term->cols+wgs->offset_width;
Three more patches from RDB: one to make Atomica work right, one to fiddle with the widths of characters in DBCS screen fonts, and (the big one) one to enable a mode in which resizing the window locks the terminal size and lets the font change, instead of vice versa. That should shut up a few feature requests! [originally from svn r1269]
2001-09-15 15:54:24 +00:00
windows/window.c: move more variables into WinGuiSeat. In commit f9e572595bb8cb6 I claimed that I'd removed very nearly all the global and static variables from windows/window.c. It turns out that this was wildly overoptimistic - I missed quite a few of them! I'm not quite sure how I managed that; my best guess is that I used an underpowered 'nm' command that failed to find some classes of variable. Some of the remaining function-scope statics were removed completely by commit afb3dab1e97a09f just now. In this commit, I've swept up some more and turn them into fields of WinGuiSeat, where they should have been moved last September. The (hopefully complete this time) list of remaining variables, generated by running this rune in the Windows build directory: nm windows/CMakeFiles/putty.dir/window.c.obj | grep -E '^([^ ]+)? *[bBcCdDgGsS] [^\.]' consists of the following variables which are legitimately global across the whole process and not related to a particular window: - 'hinst' and 'hprev', instance handles for Windows loadable modules - 'classname' in the terminal_window_class_a() and terminal_window_class_w() functions, which allocate a window class reusably - some pointers to Windows API functions retrieved via the DECL_WINDOWS_FUNCTION / GET_WINDOWS_FUNCTION system, such as p_AdjustWindowRectExForDpi and p_FlashWindowEx - some pointers to Windows API functions set up by assigning them at startup to the right one of the ANSI or Unicode version depending on the Windows version, e.g. sw_DefWindowProc and sw_DispatchMessage - 'unicode_window', a boolean flag set at the same time as those sw_Foo function pointers - 'sesslist', storing the last-retrieved version of the saved sessions menu - 'cursor_visible' in show_mouseptr() and 'forced_visible' in update_mouse_pointer(), each of which tracks the cumulative number of times that function has shown or hidden the mouse pointer, so as to manage its effect on the global state updated by ShowCursor - 'trust_icon', loaded from the executable's resources - 'wgslisthead', the list of all active WinGuiSeats - 'wm_mousewheel', the window-message id we use for mouse wheel events and the following which are nothing to do with our code: - '_OptionsStorage' in __local_stdio_printf_options() and __local_stdio_scanf_options(), which I'd never noticed before, but apparently are internal to a standard library header.
2023-05-27 13:59:20 +00:00
if (wgs->font_varpitch) {
Support for using variable-pitch fonts for the terminal on Windows. Done in much the same way as it is in the GTK front end: the character cell width is determined using the font's digits (which seems to give generally not-too-offensive spacing in most cases, at the expense of Ms and Ws typically overhanging a bit into adjacent cells) and each character is centred in its cell. Overhangs never leave permanent droppings on the window, because the existing work done in r5003 handles them just fine even in this stressful scenario. There's a hacky new checkbox in the Appearance panel to make variable-pitch fonts appear in the font selector (they still don't by default, because I still think it's _usually_ not What You Want); the checkbox state is not actually stored as part of a saved session, but it should be automatically ticked when reloading a session that's got a variable pitch font selected. (I'm half-expecting a potential flurry of requests for this feature in the wake of http://xkcd.com/840/ , so I thought I'd pre-empt them :-) [originally from svn r9063] [r5003 == ba470dec5e37ffbde05425f48e7e9a64219aec2e]
2010-12-29 14:11:25 +00:00
/*
* If we're using a variable-pitch font, we unconditionally
* draw the glyphs one at a time and centre them in their
* character cells (which means in particular that we must
Rationalise the mechanism in do_text_internal for providing the 'lpDx' array to ExtTextOut: - move it inside the new big loop (this should fix a potential bug whereby the DBCS handling altered some elements of it but the loop did not actually step along it) - initialise it more sensibly - rename it to lpDx rather than IpDx, since as far as I can tell the latter name was derived from a misreading of the former in the Windows API docs. [originally from svn r9066]
2010-12-29 23:48:54 +00:00
* disable the lpDx mechanism). This gives slightly odd but
Support for using variable-pitch fonts for the terminal on Windows. Done in much the same way as it is in the GTK front end: the character cell width is determined using the font's digits (which seems to give generally not-too-offensive spacing in most cases, at the expense of Ms and Ws typically overhanging a bit into adjacent cells) and each character is centred in its cell. Overhangs never leave permanent droppings on the window, because the existing work done in r5003 handles them just fine even in this stressful scenario. There's a hacky new checkbox in the Appearance panel to make variable-pitch fonts appear in the font selector (they still don't by default, because I still think it's _usually_ not What You Want); the checkbox state is not actually stored as part of a saved session, but it should be automatically ticked when reloading a session that's got a variable pitch font selected. (I'm half-expecting a potential flurry of requests for this feature in the wake of http://xkcd.com/840/ , so I thought I'd pre-empt them :-) [originally from svn r9063] [r5003 == ba470dec5e37ffbde05425f48e7e9a64219aec2e]
2010-12-29 14:11:25 +00:00
* generally reasonable results.
*/
xoffset = char_width / 2;
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
SetTextAlign(wgs->wintw_hdc, TA_TOP | TA_CENTER | TA_NOUPDATECP);
do_text_internal: fix bug in the lpDx_maybe mechanism. lpDx_maybe was a pointer defined to point at either lpDx itself or NULL, depending on whether the code decided it needed to pass the lpDx array of per-character pixel offsets to various functions during drawing (based in turn on whether the font was variable-pitch). lpDx is reallocated as necessary, which means lpDx_maybe must be kept up to date. This was achieved by resetting it to lpDx if it was already non-NULL. But lpDx starts out as NULL before the first reallocation, so that this can't work - it'll be initialised to NULL even if we _did_ want to use it, and then at the first realloc, it won't be updated! Before the previous commit turned lpDx from a static into an automatic variable, this would have been a rare bug affecting only the first call to the function. Now it will happen all the time, which is better, because we can notice and fix it. Replaced lpDx_maybe completely with a boolean flag indicating whether we should pass lpDx to drawing functions.
2023-05-27 14:26:38 +00:00
use_lpDx = false;
Support for using variable-pitch fonts for the terminal on Windows. Done in much the same way as it is in the GTK front end: the character cell width is determined using the font's digits (which seems to give generally not-too-offensive spacing in most cases, at the expense of Ms and Ws typically overhanging a bit into adjacent cells) and each character is centred in its cell. Overhangs never leave permanent droppings on the window, because the existing work done in r5003 handles them just fine even in this stressful scenario. There's a hacky new checkbox in the Appearance panel to make variable-pitch fonts appear in the font selector (they still don't by default, because I still think it's _usually_ not What You Want); the checkbox state is not actually stored as part of a saved session, but it should be automatically ticked when reloading a session that's got a variable pitch font selected. (I'm half-expecting a potential flurry of requests for this feature in the wake of http://xkcd.com/840/ , so I thought I'd pre-empt them :-) [originally from svn r9063] [r5003 == ba470dec5e37ffbde05425f48e7e9a64219aec2e]
2010-12-29 14:11:25 +00:00
maxlen = 1;
} else {
/*
* In a fixed-pitch font, we draw the whole string in one go
* in the normal way.
*/
xoffset = 0;
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
SetTextAlign(wgs->wintw_hdc, TA_TOP | TA_LEFT | TA_NOUPDATECP);
do_text_internal: fix bug in the lpDx_maybe mechanism. lpDx_maybe was a pointer defined to point at either lpDx itself or NULL, depending on whether the code decided it needed to pass the lpDx array of per-character pixel offsets to various functions during drawing (based in turn on whether the font was variable-pitch). lpDx is reallocated as necessary, which means lpDx_maybe must be kept up to date. This was achieved by resetting it to lpDx if it was already non-NULL. But lpDx starts out as NULL before the first reallocation, so that this can't work - it'll be initialised to NULL even if we _did_ want to use it, and then at the first realloc, it won't be updated! Before the previous commit turned lpDx from a static into an automatic variable, this would have been a rare bug affecting only the first call to the function. Now it will happen all the time, which is better, because we can notice and fix it. Replaced lpDx_maybe completely with a boolean flag indicating whether we should pass lpDx to drawing functions.
2023-05-27 14:26:38 +00:00
use_lpDx = true;
Support for using variable-pitch fonts for the terminal on Windows. Done in much the same way as it is in the GTK front end: the character cell width is determined using the font's digits (which seems to give generally not-too-offensive spacing in most cases, at the expense of Ms and Ws typically overhanging a bit into adjacent cells) and each character is centred in its cell. Overhangs never leave permanent droppings on the window, because the existing work done in r5003 handles them just fine even in this stressful scenario. There's a hacky new checkbox in the Appearance panel to make variable-pitch fonts appear in the font selector (they still don't by default, because I still think it's _usually_ not What You Want); the checkbox state is not actually stored as part of a saved session, but it should be automatically ticked when reloading a session that's got a variable pitch font selected. (I'm half-expecting a potential flurry of requests for this feature in the wake of http://xkcd.com/840/ , so I thought I'd pre-empt them :-) [originally from svn r9063] [r5003 == ba470dec5e37ffbde05425f48e7e9a64219aec2e]
2010-12-29 14:11:25 +00:00
maxlen = len;
}
Adopt C99 <stdbool.h>'s true/false. This commit includes <stdbool.h> from defs.h and deletes my traditional definitions of TRUE and FALSE, but other than that, it's a 100% mechanical search-and-replace transforming all uses of TRUE and FALSE into the C99-standardised lowercase spellings. No actual types are changed in this commit; that will come next. This is just getting the noise out of the way, so that subsequent commits can have a higher proportion of signal.
2018-10-29 19:50:29 +00:00
opaque = true; /* start by erasing the rectangle */
Support for using variable-pitch fonts for the terminal on Windows. Done in much the same way as it is in the GTK front end: the character cell width is determined using the font's digits (which seems to give generally not-too-offensive spacing in most cases, at the expense of Ms and Ws typically overhanging a bit into adjacent cells) and each character is centred in its cell. Overhangs never leave permanent droppings on the window, because the existing work done in r5003 handles them just fine even in this stressful scenario. There's a hacky new checkbox in the Appearance panel to make variable-pitch fonts appear in the font selector (they still don't by default, because I still think it's _usually_ not What You Want); the checkbox state is not actually stored as part of a saved session, but it should be automatically ticked when reloading a session that's got a variable pitch font selected. (I'm half-expecting a potential flurry of requests for this feature in the wake of http://xkcd.com/840/ , so I thought I'd pre-empt them :-) [originally from svn r9063] [r5003 == ba470dec5e37ffbde05425f48e7e9a64219aec2e]
2010-12-29 14:11:25 +00:00
for (remaining = len; remaining > 0;
Patch from Yoshida Masato to fill in the missing pieces of Windows UTF-16 support. High Unicode characters in the terminal are now converted back into surrogates during copy and draw operations, and the Windows drawing code takes account of that when splitting up the UTF-16 string for display. Meanwhile, accidental uses of wchar_t have been replaced with 32-bit integers in parts of the cross-platform code which were expecting not to have to deal with UTF-16. [originally from svn r9409]
2012-02-17 19:28:55 +00:00
text += len, remaining -= len, x += char_width * len2) {
Support for using variable-pitch fonts for the terminal on Windows. Done in much the same way as it is in the GTK front end: the character cell width is determined using the font's digits (which seems to give generally not-too-offensive spacing in most cases, at the expense of Ms and Ws typically overhanging a bit into adjacent cells) and each character is centred in its cell. Overhangs never leave permanent droppings on the window, because the existing work done in r5003 handles them just fine even in this stressful scenario. There's a hacky new checkbox in the Appearance panel to make variable-pitch fonts appear in the font selector (they still don't by default, because I still think it's _usually_ not What You Want); the checkbox state is not actually stored as part of a saved session, but it should be automatically ticked when reloading a session that's got a variable pitch font selected. (I'm half-expecting a potential flurry of requests for this feature in the wake of http://xkcd.com/840/ , so I thought I'd pre-empt them :-) [originally from svn r9063] [r5003 == ba470dec5e37ffbde05425f48e7e9a64219aec2e]
2010-12-29 14:11:25 +00:00
len = (maxlen < remaining ? maxlen : remaining);
Patch from Yoshida Masato to fill in the missing pieces of Windows UTF-16 support. High Unicode characters in the terminal are now converted back into surrogates during copy and draw operations, and the Windows drawing code takes account of that when splitting up the UTF-16 string for display. Meanwhile, accidental uses of wchar_t have been replaced with 32-bit integers in parts of the cross-platform code which were expecting not to have to deal with UTF-16. [originally from svn r9409]
2012-02-17 19:28:55 +00:00
/* don't divide SURROGATE PAIR and VARIATION SELECTOR */
len2 = len;
if (maxlen == 1) {
if (remaining >= 1 && IS_SURROGATE_PAIR(text[0], text[1]))
len++;
if (remaining-len >= 1 && IS_LOW_VARSEL(text[len]))
len++;
else if (remaining-len >= 2 &&
IS_HIGH_VARSEL(text[len], text[len+1]))
len += 2;
}
Support for using variable-pitch fonts for the terminal on Windows. Done in much the same way as it is in the GTK front end: the character cell width is determined using the font's digits (which seems to give generally not-too-offensive spacing in most cases, at the expense of Ms and Ws typically overhanging a bit into adjacent cells) and each character is centred in its cell. Overhangs never leave permanent droppings on the window, because the existing work done in r5003 handles them just fine even in this stressful scenario. There's a hacky new checkbox in the Appearance panel to make variable-pitch fonts appear in the font selector (they still don't by default, because I still think it's _usually_ not What You Want); the checkbox state is not actually stored as part of a saved session, but it should be automatically ticked when reloading a session that's got a variable pitch font selected. (I'm half-expecting a potential flurry of requests for this feature in the wake of http://xkcd.com/840/ , so I thought I'd pre-empt them :-) [originally from svn r9063] [r5003 == ba470dec5e37ffbde05425f48e7e9a64219aec2e]
2010-12-29 14:11:25 +00:00
do_text_internal: fix bug in the lpDx_maybe mechanism. lpDx_maybe was a pointer defined to point at either lpDx itself or NULL, depending on whether the code decided it needed to pass the lpDx array of per-character pixel offsets to various functions during drawing (based in turn on whether the font was variable-pitch). lpDx is reallocated as necessary, which means lpDx_maybe must be kept up to date. This was achieved by resetting it to lpDx if it was already non-NULL. But lpDx starts out as NULL before the first reallocation, so that this can't work - it'll be initialised to NULL even if we _did_ want to use it, and then at the first realloc, it won't be updated! Before the previous commit turned lpDx from a static into an automatic variable, this would have been a rare bug affecting only the first call to the function. Now it will happen all the time, which is better, because we can notice and fix it. Replaced lpDx_maybe completely with a boolean flag indicating whether we should pass lpDx to drawing functions.
2023-05-27 14:26:38 +00:00
if (len > lpDx_len)
New array-growing macros: sgrowarray and sgrowarrayn. The idea of these is that they centralise the common idiom along the lines of if (logical_array_len >= physical_array_size) { physical_array_size = logical_array_len * 5 / 4 + 256; array = sresize(array, physical_array_size, ElementType); } which happens at a zillion call sites throughout this code base, with different random choices of the geometric factor and additive constant, sometimes forgetting them completely, and generally doing a lot of repeated work. The new macro sgrowarray(array,size,n) has the semantics: here are the array pointer and its physical size for you to modify, now please ensure that the nth element exists, so I can write into it. And sgrowarrayn(array,size,n,m) is the same except that it ensures that the array has size at least n+m (so sgrowarray is just the special case where m=1). Now that this is a single centralised implementation that will be used everywhere, I've also gone to more effort in the implementation, with careful overflow checks that would have been painful to put at all the previous call sites. This commit also switches over every use of sresize(), apart from a few where I really didn't think it would gain anything. A consequence of that is that a lot of array-size variables have to have their types changed to size_t, because the macros require that (they address-take the size to pass to the underlying function).
2019-02-28 20:07:30 +00:00
sgrowarray(lpDx, lpDx_len, len);
Bug fix from Robert de Bath: since lpDx_maybe is always supposed to equal either lpDx or NULL, we mustn't forget to update it when we realloc lpDx. [originally from svn r9526]
2012-05-13 15:59:22 +00:00
Rationalise the mechanism in do_text_internal for providing the 'lpDx' array to ExtTextOut: - move it inside the new big loop (this should fix a potential bug whereby the DBCS handling altered some elements of it but the loop did not actually step along it) - initialise it more sensibly - rename it to lpDx rather than IpDx, since as far as I can tell the latter name was derived from a misreading of the former in the Windows API docs. [originally from svn r9066]
2010-12-29 23:48:54 +00:00
{
int i;
Patch from Yoshida Masato to fill in the missing pieces of Windows UTF-16 support. High Unicode characters in the terminal are now converted back into surrogates during copy and draw operations, and the Windows drawing code takes account of that when splitting up the UTF-16 string for display. Meanwhile, accidental uses of wchar_t have been replaced with 32-bit integers in parts of the cross-platform code which were expecting not to have to deal with UTF-16. [originally from svn r9409]
2012-02-17 19:28:55 +00:00
/* only last char has dx width in SURROGATE PAIR and
* VARIATION sequence */
for (i = 0; i < len; i++) {
Rationalise the mechanism in do_text_internal for providing the 'lpDx' array to ExtTextOut: - move it inside the new big loop (this should fix a potential bug whereby the DBCS handling altered some elements of it but the loop did not actually step along it) - initialise it more sensibly - rename it to lpDx rather than IpDx, since as far as I can tell the latter name was derived from a misreading of the former in the Windows API docs. [originally from svn r9066]
2010-12-29 23:48:54 +00:00
lpDx[i] = char_width;
Patch from Yoshida Masato to fill in the missing pieces of Windows UTF-16 support. High Unicode characters in the terminal are now converted back into surrogates during copy and draw operations, and the Windows drawing code takes account of that when splitting up the UTF-16 string for display. Meanwhile, accidental uses of wchar_t have been replaced with 32-bit integers in parts of the cross-platform code which were expecting not to have to deal with UTF-16. [originally from svn r9409]
2012-02-17 19:28:55 +00:00
if (i+1 < len && IS_HIGH_VARSEL(text[i], text[i+1])) {
if (i > 0) lpDx[i-1] = 0;
lpDx[i] = 0;
i++;
lpDx[i] = char_width;
} else if (i+1 < len && IS_SURROGATE_PAIR(text[i],text[i+1])) {
lpDx[i] = 0;
i++;
lpDx[i] = char_width;
} else if (IS_LOW_VARSEL(text[i])) {
if (i > 0) lpDx[i-1] = 0;
lpDx[i] = char_width;
}
}
Rationalise the mechanism in do_text_internal for providing the 'lpDx' array to ExtTextOut: - move it inside the new big loop (this should fix a potential bug whereby the DBCS handling altered some elements of it but the loop did not actually step along it) - initialise it more sensibly - rename it to lpDx rather than IpDx, since as far as I can tell the latter name was derived from a misreading of the former in the Windows API docs. [originally from svn r9066]
2010-12-29 23:48:54 +00:00
}
Support for using variable-pitch fonts for the terminal on Windows. Done in much the same way as it is in the GTK front end: the character cell width is determined using the font's digits (which seems to give generally not-too-offensive spacing in most cases, at the expense of Ms and Ws typically overhanging a bit into adjacent cells) and each character is centred in its cell. Overhangs never leave permanent droppings on the window, because the existing work done in r5003 handles them just fine even in this stressful scenario. There's a hacky new checkbox in the Appearance panel to make variable-pitch fonts appear in the font selector (they still don't by default, because I still think it's _usually_ not What You Want); the checkbox state is not actually stored as part of a saved session, but it should be automatically ticked when reloading a session that's got a variable pitch font selected. (I'm half-expecting a potential flurry of requests for this feature in the wake of http://xkcd.com/840/ , so I thought I'd pre-empt them :-) [originally from svn r9063] [r5003 == ba470dec5e37ffbde05425f48e7e9a64219aec2e]
2010-12-29 14:11:25 +00:00
/* We're using a private area for direct to font. (512 chars.) */
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
if (wgs->ucsdata.dbcs_screenfont &&
(text[0] & CSET_MASK) == CSET_ACP) {
Support for using variable-pitch fonts for the terminal on Windows. Done in much the same way as it is in the GTK front end: the character cell width is determined using the font's digits (which seems to give generally not-too-offensive spacing in most cases, at the expense of Ms and Ws typically overhanging a bit into adjacent cells) and each character is centred in its cell. Overhangs never leave permanent droppings on the window, because the existing work done in r5003 handles them just fine even in this stressful scenario. There's a hacky new checkbox in the Appearance panel to make variable-pitch fonts appear in the font selector (they still don't by default, because I still think it's _usually_ not What You Want); the checkbox state is not actually stored as part of a saved session, but it should be automatically ticked when reloading a session that's got a variable pitch font selected. (I'm half-expecting a potential flurry of requests for this feature in the wake of http://xkcd.com/840/ , so I thought I'd pre-empt them :-) [originally from svn r9063] [r5003 == ba470dec5e37ffbde05425f48e7e9a64219aec2e]
2010-12-29 14:11:25 +00:00
/* Ho Hum, dbcs fonts are a PITA! */
/* To display on W9x I have to convert to UCS */
int nlen, mptr;
Re-engineering of terminal emulator, phase 1. The active terminal screen is no longer an array of `unsigned long' encoding 16-bit Unicode plus 16 attribute bits. Now it's an array of `termchar' structures, which currently have 32-bit Unicode and 32 attribute bits but which will probably expand further in future. To prevent bloat of the memory footprint, I've introduced a mostly RLE-like compression scheme for storing scrollback: each line is compressed into a compact (but hard to modify) form when it moves into the term->scrollback tree, and is temporarily decompressed when the user wants to scroll back over it. My initial tests suggest that this compression averages about 1/4 of the previous (32 bits per character cell) data size in typical output, which means this is an improvement even without counting the new ability to extend the information stored in each character cell. Another beneficial side effect is that the insane format in which Unicode was passed to front ends through do_text() has now been rendered sane. Testing is incomplete; this _may_ still have instabilities. Windows and Unix front ends both seem to work as far as I've looked, but I haven't yet looked very hard. The Mac front end I've edited (it seemed obvious how to change it) but I can't compile or test it. As an immediate functional effect, the terminal emulator now supports full 32-bit Unicode to whatever extent the host platform allows it to. For example, if you output a 4-or-more-byte UTF-8 character in Unix pterm, it will not display it properly, but it will correctly paste it back out in a UTF8_STRING selection. Windows is more restricted, sadly. [originally from svn r4609]
2004-10-13 11:50:16 +00:00
Remove some pointless 'static' qualifiers. In windows/window.c, a few variables inside functions were declared as static, with no particular purpose that I can see: they don't seem to have any reason to persist between calls to the function. So it makes more sense to have them be ordinary stack-allocated automatic variables. Static variables removed by this commit: - 'RECT ss' in reset_window. - 'WORD keys[3]' and 'BYTE keysb[3]' in TranslateKey. - several (buffer, length) pairs in do_text_internal. - keys_unicode[] in TranslateKey. All of these variables were originally introduced in patches credited to Robert de Bath, which means I can't even try to reconstruct my original thought processes, because they weren't _my_ thoughts anyway. The arrays in do_text_internal are the easiest to understand: they're reallocated larger as necessary, and making them static means the allocation from a previous call can be reused, saving a malloc (though I don't think that's a good enough reason to bother, these days). The fixed-size static arrays and RECT are harder to explain. I suspect they might originally have been that way because of 1990s attitudes to performance: in x86-32 it's probably marginally faster to give your variables constant addresses than sp-relative ones, and in the 1990s computers were much slower, so there's an argument for making things static if you have no _need_ to make them automatic. These days, the difference is negligible, and persistent state is much more widely recognised as a risk! But keys_unicode[] is by far the strangest, because there was code that clearly _did_ expect it to persist between calls, namely three assignments to keys_unicode[0] near the end of the function after it's finished being used for any other purpose, and a conditioned-out set of debug() calls at the top of the function that print its contents before anything has yet written to it. But as far as I can see, the persistent data in the array is otherwise completely unused. In any call to the function, if keys_unicode is used at all, then it's either written directly by a call to ToAsciiEx, or else (for pre-NT platforms) converted from ToAsciiEx's output via MultiByteToWideChar. In both cases, the integer variable 'r' indicates how many array elements were written, and subsequent accesses only ever read those elements. So the assignments to keys_unicode[0] at the end of the previous call will be overwritten before anything at all can depend on them - with the exception of those debug statements. I don't really understand what was going on here. It's tempting to guess that those final assignments must have once done something useful, and the code that used them was later removed. But the source control history doesn't bear that out: a static array of three elements (under its original name 'keys') was introduced in commit 0d5d39064a0d078, and then commits 953b7775b321a60 and 26f1085038d7cd9 added the other two assignments. And as far as I can see, even as of the original commit 0d5d39064a0d078, the code already had the property that there was a final assignment to keys[0] which would inevitably be overwritten in the next call before it could affect anything. So I'm totally confused about what those assignments were _ever_ useful for. But an email thread from the time suggests that some of those patches were being rebased repeatedly past other work (or rather, the much less reliable CVS analogue of rebasing), so my best guess is that that's where the confusion crept in - perhaps in RDB's original version of the code they did do something useful. Regardless of that, I'm pretty convinced that persistent array can't be doing anything useful _now_. So I'm taking it out. But if anyone reports a bug resulting from this change, then I'll eat my words - and with any luck the details of the bug report will give us a clue what's going on, and then we can put back some equivalent functionality with much better comments!
2023-05-27 13:56:31 +00:00
sgrowarray(wbuf, wbuflen, len);
Formatting: normalise to put a space after condition keywords. 'if (thing)' is the local style here, not 'if(thing)'. Similarly with 'for' and 'while'.
2022-12-28 15:32:24 +00:00
for (nlen = mptr = 0; mptr<len; mptr++) {
Remove some pointless 'static' qualifiers. In windows/window.c, a few variables inside functions were declared as static, with no particular purpose that I can see: they don't seem to have any reason to persist between calls to the function. So it makes more sense to have them be ordinary stack-allocated automatic variables. Static variables removed by this commit: - 'RECT ss' in reset_window. - 'WORD keys[3]' and 'BYTE keysb[3]' in TranslateKey. - several (buffer, length) pairs in do_text_internal. - keys_unicode[] in TranslateKey. All of these variables were originally introduced in patches credited to Robert de Bath, which means I can't even try to reconstruct my original thought processes, because they weren't _my_ thoughts anyway. The arrays in do_text_internal are the easiest to understand: they're reallocated larger as necessary, and making them static means the allocation from a previous call can be reused, saving a malloc (though I don't think that's a good enough reason to bother, these days). The fixed-size static arrays and RECT are harder to explain. I suspect they might originally have been that way because of 1990s attitudes to performance: in x86-32 it's probably marginally faster to give your variables constant addresses than sp-relative ones, and in the 1990s computers were much slower, so there's an argument for making things static if you have no _need_ to make them automatic. These days, the difference is negligible, and persistent state is much more widely recognised as a risk! But keys_unicode[] is by far the strangest, because there was code that clearly _did_ expect it to persist between calls, namely three assignments to keys_unicode[0] near the end of the function after it's finished being used for any other purpose, and a conditioned-out set of debug() calls at the top of the function that print its contents before anything has yet written to it. But as far as I can see, the persistent data in the array is otherwise completely unused. In any call to the function, if keys_unicode is used at all, then it's either written directly by a call to ToAsciiEx, or else (for pre-NT platforms) converted from ToAsciiEx's output via MultiByteToWideChar. In both cases, the integer variable 'r' indicates how many array elements were written, and subsequent accesses only ever read those elements. So the assignments to keys_unicode[0] at the end of the previous call will be overwritten before anything at all can depend on them - with the exception of those debug statements. I don't really understand what was going on here. It's tempting to guess that those final assignments must have once done something useful, and the code that used them was later removed. But the source control history doesn't bear that out: a static array of three elements (under its original name 'keys') was introduced in commit 0d5d39064a0d078, and then commits 953b7775b321a60 and 26f1085038d7cd9 added the other two assignments. And as far as I can see, even as of the original commit 0d5d39064a0d078, the code already had the property that there was a final assignment to keys[0] which would inevitably be overwritten in the next call before it could affect anything. So I'm totally confused about what those assignments were _ever_ useful for. But an email thread from the time suggests that some of those patches were being rebased repeatedly past other work (or rather, the much less reliable CVS analogue of rebasing), so my best guess is that that's where the confusion crept in - perhaps in RDB's original version of the code they did do something useful. Regardless of that, I'm pretty convinced that persistent array can't be doing anything useful _now_. So I'm taking it out. But if anyone reports a bug resulting from this change, then I'll eat my words - and with any luck the details of the bug report will give us a clue what's going on, and then we can put back some equivalent functionality with much better comments!
2023-05-27 13:56:31 +00:00
wbuf[nlen] = 0xFFFD;
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
if (IsDBCSLeadByteEx(wgs->ucsdata.font_codepage,
Support for using variable-pitch fonts for the terminal on Windows. Done in much the same way as it is in the GTK front end: the character cell width is determined using the font's digits (which seems to give generally not-too-offensive spacing in most cases, at the expense of Ms and Ws typically overhanging a bit into adjacent cells) and each character is centred in its cell. Overhangs never leave permanent droppings on the window, because the existing work done in r5003 handles them just fine even in this stressful scenario. There's a hacky new checkbox in the Appearance panel to make variable-pitch fonts appear in the font selector (they still don't by default, because I still think it's _usually_ not What You Want); the checkbox state is not actually stored as part of a saved session, but it should be automatically ticked when reloading a session that's got a variable pitch font selected. (I'm half-expecting a potential flurry of requests for this feature in the wake of http://xkcd.com/840/ , so I thought I'd pre-empt them :-) [originally from svn r9063] [r5003 == ba470dec5e37ffbde05425f48e7e9a64219aec2e]
2010-12-29 14:11:25 +00:00
(BYTE) text[mptr])) {
char dbcstext[2];
dbcstext[0] = text[mptr] & 0xFF;
dbcstext[1] = text[mptr+1] & 0xFF;
Rationalise the mechanism in do_text_internal for providing the 'lpDx' array to ExtTextOut: - move it inside the new big loop (this should fix a potential bug whereby the DBCS handling altered some elements of it but the loop did not actually step along it) - initialise it more sensibly - rename it to lpDx rather than IpDx, since as far as I can tell the latter name was derived from a misreading of the former in the Windows API docs. [originally from svn r9066]
2010-12-29 23:48:54 +00:00
lpDx[nlen] += char_width;
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
MultiByteToWideChar(
wgs->ucsdata.font_codepage, MB_USEGLYPHCHARS,
Remove some pointless 'static' qualifiers. In windows/window.c, a few variables inside functions were declared as static, with no particular purpose that I can see: they don't seem to have any reason to persist between calls to the function. So it makes more sense to have them be ordinary stack-allocated automatic variables. Static variables removed by this commit: - 'RECT ss' in reset_window. - 'WORD keys[3]' and 'BYTE keysb[3]' in TranslateKey. - several (buffer, length) pairs in do_text_internal. - keys_unicode[] in TranslateKey. All of these variables were originally introduced in patches credited to Robert de Bath, which means I can't even try to reconstruct my original thought processes, because they weren't _my_ thoughts anyway. The arrays in do_text_internal are the easiest to understand: they're reallocated larger as necessary, and making them static means the allocation from a previous call can be reused, saving a malloc (though I don't think that's a good enough reason to bother, these days). The fixed-size static arrays and RECT are harder to explain. I suspect they might originally have been that way because of 1990s attitudes to performance: in x86-32 it's probably marginally faster to give your variables constant addresses than sp-relative ones, and in the 1990s computers were much slower, so there's an argument for making things static if you have no _need_ to make them automatic. These days, the difference is negligible, and persistent state is much more widely recognised as a risk! But keys_unicode[] is by far the strangest, because there was code that clearly _did_ expect it to persist between calls, namely three assignments to keys_unicode[0] near the end of the function after it's finished being used for any other purpose, and a conditioned-out set of debug() calls at the top of the function that print its contents before anything has yet written to it. But as far as I can see, the persistent data in the array is otherwise completely unused. In any call to the function, if keys_unicode is used at all, then it's either written directly by a call to ToAsciiEx, or else (for pre-NT platforms) converted from ToAsciiEx's output via MultiByteToWideChar. In both cases, the integer variable 'r' indicates how many array elements were written, and subsequent accesses only ever read those elements. So the assignments to keys_unicode[0] at the end of the previous call will be overwritten before anything at all can depend on them - with the exception of those debug statements. I don't really understand what was going on here. It's tempting to guess that those final assignments must have once done something useful, and the code that used them was later removed. But the source control history doesn't bear that out: a static array of three elements (under its original name 'keys') was introduced in commit 0d5d39064a0d078, and then commits 953b7775b321a60 and 26f1085038d7cd9 added the other two assignments. And as far as I can see, even as of the original commit 0d5d39064a0d078, the code already had the property that there was a final assignment to keys[0] which would inevitably be overwritten in the next call before it could affect anything. So I'm totally confused about what those assignments were _ever_ useful for. But an email thread from the time suggests that some of those patches were being rebased repeatedly past other work (or rather, the much less reliable CVS analogue of rebasing), so my best guess is that that's where the confusion crept in - perhaps in RDB's original version of the code they did do something useful. Regardless of that, I'm pretty convinced that persistent array can't be doing anything useful _now_. So I'm taking it out. But if anyone reports a bug resulting from this change, then I'll eat my words - and with any luck the details of the bug report will give us a clue what's going on, and then we can put back some equivalent functionality with much better comments!
2023-05-27 13:56:31 +00:00
dbcstext, 2, wbuf+nlen, 1);
Support for using variable-pitch fonts for the terminal on Windows. Done in much the same way as it is in the GTK front end: the character cell width is determined using the font's digits (which seems to give generally not-too-offensive spacing in most cases, at the expense of Ms and Ws typically overhanging a bit into adjacent cells) and each character is centred in its cell. Overhangs never leave permanent droppings on the window, because the existing work done in r5003 handles them just fine even in this stressful scenario. There's a hacky new checkbox in the Appearance panel to make variable-pitch fonts appear in the font selector (they still don't by default, because I still think it's _usually_ not What You Want); the checkbox state is not actually stored as part of a saved session, but it should be automatically ticked when reloading a session that's got a variable pitch font selected. (I'm half-expecting a potential flurry of requests for this feature in the wake of http://xkcd.com/840/ , so I thought I'd pre-empt them :-) [originally from svn r9063] [r5003 == ba470dec5e37ffbde05425f48e7e9a64219aec2e]
2010-12-29 14:11:25 +00:00
mptr++;
Formatting: miscellaneous. This patch fixes a few other whitespace and formatting issues which were pointed out by the bulk-reindent or which I spotted in passing, some involving manual editing to break lines more nicely. I think the weirdest hunk in here is the one in windows/window.c TranslateKey() where _half_ of an assignment statement inside an 'if' was on the same line as the trailing paren of the if condition. No idea at all how that one managed to happen!
2022-08-03 19:48:46 +00:00
} else {
Support for using variable-pitch fonts for the terminal on Windows. Done in much the same way as it is in the GTK front end: the character cell width is determined using the font's digits (which seems to give generally not-too-offensive spacing in most cases, at the expense of Ms and Ws typically overhanging a bit into adjacent cells) and each character is centred in its cell. Overhangs never leave permanent droppings on the window, because the existing work done in r5003 handles them just fine even in this stressful scenario. There's a hacky new checkbox in the Appearance panel to make variable-pitch fonts appear in the font selector (they still don't by default, because I still think it's _usually_ not What You Want); the checkbox state is not actually stored as part of a saved session, but it should be automatically ticked when reloading a session that's got a variable pitch font selected. (I'm half-expecting a potential flurry of requests for this feature in the wake of http://xkcd.com/840/ , so I thought I'd pre-empt them :-) [originally from svn r9063] [r5003 == ba470dec5e37ffbde05425f48e7e9a64219aec2e]
2010-12-29 14:11:25 +00:00
char dbcstext[1];
dbcstext[0] = text[mptr] & 0xFF;
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
MultiByteToWideChar(
wgs->ucsdata.font_codepage, MB_USEGLYPHCHARS,
Remove some pointless 'static' qualifiers. In windows/window.c, a few variables inside functions were declared as static, with no particular purpose that I can see: they don't seem to have any reason to persist between calls to the function. So it makes more sense to have them be ordinary stack-allocated automatic variables. Static variables removed by this commit: - 'RECT ss' in reset_window. - 'WORD keys[3]' and 'BYTE keysb[3]' in TranslateKey. - several (buffer, length) pairs in do_text_internal. - keys_unicode[] in TranslateKey. All of these variables were originally introduced in patches credited to Robert de Bath, which means I can't even try to reconstruct my original thought processes, because they weren't _my_ thoughts anyway. The arrays in do_text_internal are the easiest to understand: they're reallocated larger as necessary, and making them static means the allocation from a previous call can be reused, saving a malloc (though I don't think that's a good enough reason to bother, these days). The fixed-size static arrays and RECT are harder to explain. I suspect they might originally have been that way because of 1990s attitudes to performance: in x86-32 it's probably marginally faster to give your variables constant addresses than sp-relative ones, and in the 1990s computers were much slower, so there's an argument for making things static if you have no _need_ to make them automatic. These days, the difference is negligible, and persistent state is much more widely recognised as a risk! But keys_unicode[] is by far the strangest, because there was code that clearly _did_ expect it to persist between calls, namely three assignments to keys_unicode[0] near the end of the function after it's finished being used for any other purpose, and a conditioned-out set of debug() calls at the top of the function that print its contents before anything has yet written to it. But as far as I can see, the persistent data in the array is otherwise completely unused. In any call to the function, if keys_unicode is used at all, then it's either written directly by a call to ToAsciiEx, or else (for pre-NT platforms) converted from ToAsciiEx's output via MultiByteToWideChar. In both cases, the integer variable 'r' indicates how many array elements were written, and subsequent accesses only ever read those elements. So the assignments to keys_unicode[0] at the end of the previous call will be overwritten before anything at all can depend on them - with the exception of those debug statements. I don't really understand what was going on here. It's tempting to guess that those final assignments must have once done something useful, and the code that used them was later removed. But the source control history doesn't bear that out: a static array of three elements (under its original name 'keys') was introduced in commit 0d5d39064a0d078, and then commits 953b7775b321a60 and 26f1085038d7cd9 added the other two assignments. And as far as I can see, even as of the original commit 0d5d39064a0d078, the code already had the property that there was a final assignment to keys[0] which would inevitably be overwritten in the next call before it could affect anything. So I'm totally confused about what those assignments were _ever_ useful for. But an email thread from the time suggests that some of those patches were being rebased repeatedly past other work (or rather, the much less reliable CVS analogue of rebasing), so my best guess is that that's where the confusion crept in - perhaps in RDB's original version of the code they did do something useful. Regardless of that, I'm pretty convinced that persistent array can't be doing anything useful _now_. So I'm taking it out. But if anyone reports a bug resulting from this change, then I'll eat my words - and with any luck the details of the bug report will give us a clue what's going on, and then we can put back some equivalent functionality with much better comments!
2023-05-27 13:56:31 +00:00
dbcstext, 1, wbuf+nlen, 1);
Support for using variable-pitch fonts for the terminal on Windows. Done in much the same way as it is in the GTK front end: the character cell width is determined using the font's digits (which seems to give generally not-too-offensive spacing in most cases, at the expense of Ms and Ws typically overhanging a bit into adjacent cells) and each character is centred in its cell. Overhangs never leave permanent droppings on the window, because the existing work done in r5003 handles them just fine even in this stressful scenario. There's a hacky new checkbox in the Appearance panel to make variable-pitch fonts appear in the font selector (they still don't by default, because I still think it's _usually_ not What You Want); the checkbox state is not actually stored as part of a saved session, but it should be automatically ticked when reloading a session that's got a variable pitch font selected. (I'm half-expecting a potential flurry of requests for this feature in the wake of http://xkcd.com/840/ , so I thought I'd pre-empt them :-) [originally from svn r9063] [r5003 == ba470dec5e37ffbde05425f48e7e9a64219aec2e]
2010-12-29 14:11:25 +00:00
}
nlen++;
}
if (nlen <= 0)
Remove some pointless 'static' qualifiers. In windows/window.c, a few variables inside functions were declared as static, with no particular purpose that I can see: they don't seem to have any reason to persist between calls to the function. So it makes more sense to have them be ordinary stack-allocated automatic variables. Static variables removed by this commit: - 'RECT ss' in reset_window. - 'WORD keys[3]' and 'BYTE keysb[3]' in TranslateKey. - several (buffer, length) pairs in do_text_internal. - keys_unicode[] in TranslateKey. All of these variables were originally introduced in patches credited to Robert de Bath, which means I can't even try to reconstruct my original thought processes, because they weren't _my_ thoughts anyway. The arrays in do_text_internal are the easiest to understand: they're reallocated larger as necessary, and making them static means the allocation from a previous call can be reused, saving a malloc (though I don't think that's a good enough reason to bother, these days). The fixed-size static arrays and RECT are harder to explain. I suspect they might originally have been that way because of 1990s attitudes to performance: in x86-32 it's probably marginally faster to give your variables constant addresses than sp-relative ones, and in the 1990s computers were much slower, so there's an argument for making things static if you have no _need_ to make them automatic. These days, the difference is negligible, and persistent state is much more widely recognised as a risk! But keys_unicode[] is by far the strangest, because there was code that clearly _did_ expect it to persist between calls, namely three assignments to keys_unicode[0] near the end of the function after it's finished being used for any other purpose, and a conditioned-out set of debug() calls at the top of the function that print its contents before anything has yet written to it. But as far as I can see, the persistent data in the array is otherwise completely unused. In any call to the function, if keys_unicode is used at all, then it's either written directly by a call to ToAsciiEx, or else (for pre-NT platforms) converted from ToAsciiEx's output via MultiByteToWideChar. In both cases, the integer variable 'r' indicates how many array elements were written, and subsequent accesses only ever read those elements. So the assignments to keys_unicode[0] at the end of the previous call will be overwritten before anything at all can depend on them - with the exception of those debug statements. I don't really understand what was going on here. It's tempting to guess that those final assignments must have once done something useful, and the code that used them was later removed. But the source control history doesn't bear that out: a static array of three elements (under its original name 'keys') was introduced in commit 0d5d39064a0d078, and then commits 953b7775b321a60 and 26f1085038d7cd9 added the other two assignments. And as far as I can see, even as of the original commit 0d5d39064a0d078, the code already had the property that there was a final assignment to keys[0] which would inevitably be overwritten in the next call before it could affect anything. So I'm totally confused about what those assignments were _ever_ useful for. But an email thread from the time suggests that some of those patches were being rebased repeatedly past other work (or rather, the much less reliable CVS analogue of rebasing), so my best guess is that that's where the confusion crept in - perhaps in RDB's original version of the code they did do something useful. Regardless of that, I'm pretty convinced that persistent array can't be doing anything useful _now_. So I'm taking it out. But if anyone reports a bug resulting from this change, then I'll eat my words - and with any luck the details of the bug report will give us a clue what's going on, and then we can put back some equivalent functionality with much better comments!
2023-05-27 13:56:31 +00:00
goto out; /* Eeek! */
Support for using variable-pitch fonts for the terminal on Windows. Done in much the same way as it is in the GTK front end: the character cell width is determined using the font's digits (which seems to give generally not-too-offensive spacing in most cases, at the expense of Ms and Ws typically overhanging a bit into adjacent cells) and each character is centred in its cell. Overhangs never leave permanent droppings on the window, because the existing work done in r5003 handles them just fine even in this stressful scenario. There's a hacky new checkbox in the Appearance panel to make variable-pitch fonts appear in the font selector (they still don't by default, because I still think it's _usually_ not What You Want); the checkbox state is not actually stored as part of a saved session, but it should be automatically ticked when reloading a session that's got a variable pitch font selected. (I'm half-expecting a potential flurry of requests for this feature in the wake of http://xkcd.com/840/ , so I thought I'd pre-empt them :-) [originally from svn r9063] [r5003 == ba470dec5e37ffbde05425f48e7e9a64219aec2e]
2010-12-29 14:11:25 +00:00
windows/window.c: move more variables into WinGuiSeat. In commit f9e572595bb8cb6 I claimed that I'd removed very nearly all the global and static variables from windows/window.c. It turns out that this was wildly overoptimistic - I missed quite a few of them! I'm not quite sure how I managed that; my best guess is that I used an underpowered 'nm' command that failed to find some classes of variable. Some of the remaining function-scope statics were removed completely by commit afb3dab1e97a09f just now. In this commit, I've swept up some more and turn them into fields of WinGuiSeat, where they should have been moved last September. The (hopefully complete this time) list of remaining variables, generated by running this rune in the Windows build directory: nm windows/CMakeFiles/putty.dir/window.c.obj | grep -E '^([^ ]+)? *[bBcCdDgGsS] [^\.]' consists of the following variables which are legitimately global across the whole process and not related to a particular window: - 'hinst' and 'hprev', instance handles for Windows loadable modules - 'classname' in the terminal_window_class_a() and terminal_window_class_w() functions, which allocate a window class reusably - some pointers to Windows API functions retrieved via the DECL_WINDOWS_FUNCTION / GET_WINDOWS_FUNCTION system, such as p_AdjustWindowRectExForDpi and p_FlashWindowEx - some pointers to Windows API functions set up by assigning them at startup to the right one of the ANSI or Unicode version depending on the Windows version, e.g. sw_DefWindowProc and sw_DispatchMessage - 'unicode_window', a boolean flag set at the same time as those sw_Foo function pointers - 'sesslist', storing the last-retrieved version of the saved sessions menu - 'cursor_visible' in show_mouseptr() and 'forced_visible' in update_mouse_pointer(), each of which tracks the cumulative number of times that function has shown or hidden the mouse pointer, so as to manage its effect on the global state updated by ShowCursor - 'trust_icon', loaded from the executable's resources - 'wgslisthead', the list of all active WinGuiSeats - 'wm_mousewheel', the window-message id we use for mouse wheel events and the following which are nothing to do with our code: - '_OptionsStorage' in __local_stdio_printf_options() and __local_stdio_scanf_options(), which I'd never noticed before, but apparently are internal to a standard library header.
2023-05-27 13:59:20 +00:00
ExtTextOutW(
wgs->wintw_hdc, x + xoffset,
y - wgs->font_height * (lattr == LATTR_BOT) + text_adjust,
ETO_CLIPPED | (opaque ? ETO_OPAQUE : 0),
&line_box, wbuf, nlen, (use_lpDx ? lpDx : NULL));
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
if (wgs->bold_font_mode == BOLD_SHADOW && (attr & ATTR_BOLD)) {
SetBkMode(wgs->wintw_hdc, TRANSPARENT);
windows/window.c: move more variables into WinGuiSeat. In commit f9e572595bb8cb6 I claimed that I'd removed very nearly all the global and static variables from windows/window.c. It turns out that this was wildly overoptimistic - I missed quite a few of them! I'm not quite sure how I managed that; my best guess is that I used an underpowered 'nm' command that failed to find some classes of variable. Some of the remaining function-scope statics were removed completely by commit afb3dab1e97a09f just now. In this commit, I've swept up some more and turn them into fields of WinGuiSeat, where they should have been moved last September. The (hopefully complete this time) list of remaining variables, generated by running this rune in the Windows build directory: nm windows/CMakeFiles/putty.dir/window.c.obj | grep -E '^([^ ]+)? *[bBcCdDgGsS] [^\.]' consists of the following variables which are legitimately global across the whole process and not related to a particular window: - 'hinst' and 'hprev', instance handles for Windows loadable modules - 'classname' in the terminal_window_class_a() and terminal_window_class_w() functions, which allocate a window class reusably - some pointers to Windows API functions retrieved via the DECL_WINDOWS_FUNCTION / GET_WINDOWS_FUNCTION system, such as p_AdjustWindowRectExForDpi and p_FlashWindowEx - some pointers to Windows API functions set up by assigning them at startup to the right one of the ANSI or Unicode version depending on the Windows version, e.g. sw_DefWindowProc and sw_DispatchMessage - 'unicode_window', a boolean flag set at the same time as those sw_Foo function pointers - 'sesslist', storing the last-retrieved version of the saved sessions menu - 'cursor_visible' in show_mouseptr() and 'forced_visible' in update_mouse_pointer(), each of which tracks the cumulative number of times that function has shown or hidden the mouse pointer, so as to manage its effect on the global state updated by ShowCursor - 'trust_icon', loaded from the executable's resources - 'wgslisthead', the list of all active WinGuiSeats - 'wm_mousewheel', the window-message id we use for mouse wheel events and the following which are nothing to do with our code: - '_OptionsStorage' in __local_stdio_printf_options() and __local_stdio_scanf_options(), which I'd never noticed before, but apparently are internal to a standard library header.
2023-05-27 13:59:20 +00:00
ExtTextOutW(
wgs->wintw_hdc, x + xoffset - 1,
y - wgs->font_height * (lattr == LATTR_BOT) + text_adjust,
ETO_CLIPPED, &line_box, wbuf, nlen,
(use_lpDx ? lpDx : NULL));
Support for using variable-pitch fonts for the terminal on Windows. Done in much the same way as it is in the GTK front end: the character cell width is determined using the font's digits (which seems to give generally not-too-offensive spacing in most cases, at the expense of Ms and Ws typically overhanging a bit into adjacent cells) and each character is centred in its cell. Overhangs never leave permanent droppings on the window, because the existing work done in r5003 handles them just fine even in this stressful scenario. There's a hacky new checkbox in the Appearance panel to make variable-pitch fonts appear in the font selector (they still don't by default, because I still think it's _usually_ not What You Want); the checkbox state is not actually stored as part of a saved session, but it should be automatically ticked when reloading a session that's got a variable pitch font selected. (I'm half-expecting a potential flurry of requests for this feature in the wake of http://xkcd.com/840/ , so I thought I'd pre-empt them :-) [originally from svn r9063] [r5003 == ba470dec5e37ffbde05425f48e7e9a64219aec2e]
2010-12-29 14:11:25 +00:00
}
Re-engineering of terminal emulator, phase 1. The active terminal screen is no longer an array of `unsigned long' encoding 16-bit Unicode plus 16 attribute bits. Now it's an array of `termchar' structures, which currently have 32-bit Unicode and 32 attribute bits but which will probably expand further in future. To prevent bloat of the memory footprint, I've introduced a mostly RLE-like compression scheme for storing scrollback: each line is compressed into a compact (but hard to modify) form when it moves into the term->scrollback tree, and is temporarily decompressed when the user wants to scroll back over it. My initial tests suggest that this compression averages about 1/4 of the previous (32 bits per character cell) data size in typical output, which means this is an improvement even without counting the new ability to extend the information stored in each character cell. Another beneficial side effect is that the insane format in which Unicode was passed to front ends through do_text() has now been rendered sane. Testing is incomplete; this _may_ still have instabilities. Windows and Unix front ends both seem to work as far as I've looked, but I haven't yet looked very hard. The Mac front end I've edited (it seemed obvious how to change it) but I can't compile or test it. As an immediate functional effect, the terminal emulator now supports full 32-bit Unicode to whatever extent the host platform allows it to. For example, if you output a 4-or-more-byte UTF-8 character in Unix pterm, it will not display it properly, but it will correctly paste it back out in a UTF8_STRING selection. Windows is more restricted, sadly. [originally from svn r4609]
2004-10-13 11:50:16 +00:00
Rationalise the mechanism in do_text_internal for providing the 'lpDx' array to ExtTextOut: - move it inside the new big loop (this should fix a potential bug whereby the DBCS handling altered some elements of it but the loop did not actually step along it) - initialise it more sensibly - rename it to lpDx rather than IpDx, since as far as I can tell the latter name was derived from a misreading of the former in the Windows API docs. [originally from svn r9066]
2010-12-29 23:48:54 +00:00
lpDx[0] = -1;
Support for using variable-pitch fonts for the terminal on Windows. Done in much the same way as it is in the GTK front end: the character cell width is determined using the font's digits (which seems to give generally not-too-offensive spacing in most cases, at the expense of Ms and Ws typically overhanging a bit into adjacent cells) and each character is centred in its cell. Overhangs never leave permanent droppings on the window, because the existing work done in r5003 handles them just fine even in this stressful scenario. There's a hacky new checkbox in the Appearance panel to make variable-pitch fonts appear in the font selector (they still don't by default, because I still think it's _usually_ not What You Want); the checkbox state is not actually stored as part of a saved session, but it should be automatically ticked when reloading a session that's got a variable pitch font selected. (I'm half-expecting a potential flurry of requests for this feature in the wake of http://xkcd.com/840/ , so I thought I'd pre-empt them :-) [originally from svn r9063] [r5003 == ba470dec5e37ffbde05425f48e7e9a64219aec2e]
2010-12-29 14:11:25 +00:00
} else if (DIRECT_FONT(text[0])) {
Remove some pointless 'static' qualifiers. In windows/window.c, a few variables inside functions were declared as static, with no particular purpose that I can see: they don't seem to have any reason to persist between calls to the function. So it makes more sense to have them be ordinary stack-allocated automatic variables. Static variables removed by this commit: - 'RECT ss' in reset_window. - 'WORD keys[3]' and 'BYTE keysb[3]' in TranslateKey. - several (buffer, length) pairs in do_text_internal. - keys_unicode[] in TranslateKey. All of these variables were originally introduced in patches credited to Robert de Bath, which means I can't even try to reconstruct my original thought processes, because they weren't _my_ thoughts anyway. The arrays in do_text_internal are the easiest to understand: they're reallocated larger as necessary, and making them static means the allocation from a previous call can be reused, saving a malloc (though I don't think that's a good enough reason to bother, these days). The fixed-size static arrays and RECT are harder to explain. I suspect they might originally have been that way because of 1990s attitudes to performance: in x86-32 it's probably marginally faster to give your variables constant addresses than sp-relative ones, and in the 1990s computers were much slower, so there's an argument for making things static if you have no _need_ to make them automatic. These days, the difference is negligible, and persistent state is much more widely recognised as a risk! But keys_unicode[] is by far the strangest, because there was code that clearly _did_ expect it to persist between calls, namely three assignments to keys_unicode[0] near the end of the function after it's finished being used for any other purpose, and a conditioned-out set of debug() calls at the top of the function that print its contents before anything has yet written to it. But as far as I can see, the persistent data in the array is otherwise completely unused. In any call to the function, if keys_unicode is used at all, then it's either written directly by a call to ToAsciiEx, or else (for pre-NT platforms) converted from ToAsciiEx's output via MultiByteToWideChar. In both cases, the integer variable 'r' indicates how many array elements were written, and subsequent accesses only ever read those elements. So the assignments to keys_unicode[0] at the end of the previous call will be overwritten before anything at all can depend on them - with the exception of those debug statements. I don't really understand what was going on here. It's tempting to guess that those final assignments must have once done something useful, and the code that used them was later removed. But the source control history doesn't bear that out: a static array of three elements (under its original name 'keys') was introduced in commit 0d5d39064a0d078, and then commits 953b7775b321a60 and 26f1085038d7cd9 added the other two assignments. And as far as I can see, even as of the original commit 0d5d39064a0d078, the code already had the property that there was a final assignment to keys[0] which would inevitably be overwritten in the next call before it could affect anything. So I'm totally confused about what those assignments were _ever_ useful for. But an email thread from the time suggests that some of those patches were being rebased repeatedly past other work (or rather, the much less reliable CVS analogue of rebasing), so my best guess is that that's where the confusion crept in - perhaps in RDB's original version of the code they did do something useful. Regardless of that, I'm pretty convinced that persistent array can't be doing anything useful _now_. So I'm taking it out. But if anyone reports a bug resulting from this change, then I'll eat my words - and with any luck the details of the bug report will give us a clue what's going on, and then we can put back some equivalent functionality with much better comments!
2023-05-27 13:56:31 +00:00
sgrowarray(cbuf, cbuflen, len);
New array-growing macros: sgrowarray and sgrowarrayn. The idea of these is that they centralise the common idiom along the lines of if (logical_array_len >= physical_array_size) { physical_array_size = logical_array_len * 5 / 4 + 256; array = sresize(array, physical_array_size, ElementType); } which happens at a zillion call sites throughout this code base, with different random choices of the geometric factor and additive constant, sometimes forgetting them completely, and generally doing a lot of repeated work. The new macro sgrowarray(array,size,n) has the semantics: here are the array pointer and its physical size for you to modify, now please ensure that the nth element exists, so I can write into it. And sgrowarrayn(array,size,n,m) is the same except that it ensures that the array has size at least n+m (so sgrowarray is just the special case where m=1). Now that this is a single centralised implementation that will be used everywhere, I've also gone to more effort in the implementation, with careful overflow checks that would have been painful to put at all the previous call sites. This commit also switches over every use of sresize(), apart from a few where I really didn't think it would gain anything. A consequence of that is that a lot of array-size variables have to have their types changed to size_t, because the macros require that (they address-take the size to pass to the underlying function).
2019-02-28 20:07:30 +00:00
for (size_t i = 0; i < len; i++)
Remove some pointless 'static' qualifiers. In windows/window.c, a few variables inside functions were declared as static, with no particular purpose that I can see: they don't seem to have any reason to persist between calls to the function. So it makes more sense to have them be ordinary stack-allocated automatic variables. Static variables removed by this commit: - 'RECT ss' in reset_window. - 'WORD keys[3]' and 'BYTE keysb[3]' in TranslateKey. - several (buffer, length) pairs in do_text_internal. - keys_unicode[] in TranslateKey. All of these variables were originally introduced in patches credited to Robert de Bath, which means I can't even try to reconstruct my original thought processes, because they weren't _my_ thoughts anyway. The arrays in do_text_internal are the easiest to understand: they're reallocated larger as necessary, and making them static means the allocation from a previous call can be reused, saving a malloc (though I don't think that's a good enough reason to bother, these days). The fixed-size static arrays and RECT are harder to explain. I suspect they might originally have been that way because of 1990s attitudes to performance: in x86-32 it's probably marginally faster to give your variables constant addresses than sp-relative ones, and in the 1990s computers were much slower, so there's an argument for making things static if you have no _need_ to make them automatic. These days, the difference is negligible, and persistent state is much more widely recognised as a risk! But keys_unicode[] is by far the strangest, because there was code that clearly _did_ expect it to persist between calls, namely three assignments to keys_unicode[0] near the end of the function after it's finished being used for any other purpose, and a conditioned-out set of debug() calls at the top of the function that print its contents before anything has yet written to it. But as far as I can see, the persistent data in the array is otherwise completely unused. In any call to the function, if keys_unicode is used at all, then it's either written directly by a call to ToAsciiEx, or else (for pre-NT platforms) converted from ToAsciiEx's output via MultiByteToWideChar. In both cases, the integer variable 'r' indicates how many array elements were written, and subsequent accesses only ever read those elements. So the assignments to keys_unicode[0] at the end of the previous call will be overwritten before anything at all can depend on them - with the exception of those debug statements. I don't really understand what was going on here. It's tempting to guess that those final assignments must have once done something useful, and the code that used them was later removed. But the source control history doesn't bear that out: a static array of three elements (under its original name 'keys') was introduced in commit 0d5d39064a0d078, and then commits 953b7775b321a60 and 26f1085038d7cd9 added the other two assignments. And as far as I can see, even as of the original commit 0d5d39064a0d078, the code already had the property that there was a final assignment to keys[0] which would inevitably be overwritten in the next call before it could affect anything. So I'm totally confused about what those assignments were _ever_ useful for. But an email thread from the time suggests that some of those patches were being rebased repeatedly past other work (or rather, the much less reliable CVS analogue of rebasing), so my best guess is that that's where the confusion crept in - perhaps in RDB's original version of the code they did do something useful. Regardless of that, I'm pretty convinced that persistent array can't be doing anything useful _now_. So I'm taking it out. But if anyone reports a bug resulting from this change, then I'll eat my words - and with any luck the details of the bug report will give us a clue what's going on, and then we can put back some equivalent functionality with much better comments!
2023-05-27 13:56:31 +00:00
cbuf[i] = text[i] & 0xFF;
Support for using variable-pitch fonts for the terminal on Windows. Done in much the same way as it is in the GTK front end: the character cell width is determined using the font's digits (which seems to give generally not-too-offensive spacing in most cases, at the expense of Ms and Ws typically overhanging a bit into adjacent cells) and each character is centred in its cell. Overhangs never leave permanent droppings on the window, because the existing work done in r5003 handles them just fine even in this stressful scenario. There's a hacky new checkbox in the Appearance panel to make variable-pitch fonts appear in the font selector (they still don't by default, because I still think it's _usually_ not What You Want); the checkbox state is not actually stored as part of a saved session, but it should be automatically ticked when reloading a session that's got a variable pitch font selected. (I'm half-expecting a potential flurry of requests for this feature in the wake of http://xkcd.com/840/ , so I thought I'd pre-empt them :-) [originally from svn r9063] [r5003 == ba470dec5e37ffbde05425f48e7e9a64219aec2e]
2010-12-29 14:11:25 +00:00
windows/window.c: move more variables into WinGuiSeat. In commit f9e572595bb8cb6 I claimed that I'd removed very nearly all the global and static variables from windows/window.c. It turns out that this was wildly overoptimistic - I missed quite a few of them! I'm not quite sure how I managed that; my best guess is that I used an underpowered 'nm' command that failed to find some classes of variable. Some of the remaining function-scope statics were removed completely by commit afb3dab1e97a09f just now. In this commit, I've swept up some more and turn them into fields of WinGuiSeat, where they should have been moved last September. The (hopefully complete this time) list of remaining variables, generated by running this rune in the Windows build directory: nm windows/CMakeFiles/putty.dir/window.c.obj | grep -E '^([^ ]+)? *[bBcCdDgGsS] [^\.]' consists of the following variables which are legitimately global across the whole process and not related to a particular window: - 'hinst' and 'hprev', instance handles for Windows loadable modules - 'classname' in the terminal_window_class_a() and terminal_window_class_w() functions, which allocate a window class reusably - some pointers to Windows API functions retrieved via the DECL_WINDOWS_FUNCTION / GET_WINDOWS_FUNCTION system, such as p_AdjustWindowRectExForDpi and p_FlashWindowEx - some pointers to Windows API functions set up by assigning them at startup to the right one of the ANSI or Unicode version depending on the Windows version, e.g. sw_DefWindowProc and sw_DispatchMessage - 'unicode_window', a boolean flag set at the same time as those sw_Foo function pointers - 'sesslist', storing the last-retrieved version of the saved sessions menu - 'cursor_visible' in show_mouseptr() and 'forced_visible' in update_mouse_pointer(), each of which tracks the cumulative number of times that function has shown or hidden the mouse pointer, so as to manage its effect on the global state updated by ShowCursor - 'trust_icon', loaded from the executable's resources - 'wgslisthead', the list of all active WinGuiSeats - 'wm_mousewheel', the window-message id we use for mouse wheel events and the following which are nothing to do with our code: - '_OptionsStorage' in __local_stdio_printf_options() and __local_stdio_scanf_options(), which I'd never noticed before, but apparently are internal to a standard library header.
2023-05-27 13:59:20 +00:00
ExtTextOut(
wgs->wintw_hdc, x + xoffset,
y - wgs->font_height * (lattr == LATTR_BOT) + text_adjust,
ETO_CLIPPED | (opaque ? ETO_OPAQUE : 0),
&line_box, cbuf, len, (use_lpDx ? lpDx : NULL));
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
if (wgs->bold_font_mode == BOLD_SHADOW && (attr & ATTR_BOLD)) {
SetBkMode(wgs->wintw_hdc, TRANSPARENT);
Support for using variable-pitch fonts for the terminal on Windows. Done in much the same way as it is in the GTK front end: the character cell width is determined using the font's digits (which seems to give generally not-too-offensive spacing in most cases, at the expense of Ms and Ws typically overhanging a bit into adjacent cells) and each character is centred in its cell. Overhangs never leave permanent droppings on the window, because the existing work done in r5003 handles them just fine even in this stressful scenario. There's a hacky new checkbox in the Appearance panel to make variable-pitch fonts appear in the font selector (they still don't by default, because I still think it's _usually_ not What You Want); the checkbox state is not actually stored as part of a saved session, but it should be automatically ticked when reloading a session that's got a variable pitch font selected. (I'm half-expecting a potential flurry of requests for this feature in the wake of http://xkcd.com/840/ , so I thought I'd pre-empt them :-) [originally from svn r9063] [r5003 == ba470dec5e37ffbde05425f48e7e9a64219aec2e]
2010-12-29 14:11:25 +00:00
/* GRR: This draws the character outside its box and
* can leave 'droppings' even with the clip box! I
* suppose I could loop it one character at a time ...
* yuk.
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
*
Support for using variable-pitch fonts for the terminal on Windows. Done in much the same way as it is in the GTK front end: the character cell width is determined using the font's digits (which seems to give generally not-too-offensive spacing in most cases, at the expense of Ms and Ws typically overhanging a bit into adjacent cells) and each character is centred in its cell. Overhangs never leave permanent droppings on the window, because the existing work done in r5003 handles them just fine even in this stressful scenario. There's a hacky new checkbox in the Appearance panel to make variable-pitch fonts appear in the font selector (they still don't by default, because I still think it's _usually_ not What You Want); the checkbox state is not actually stored as part of a saved session, but it should be automatically ticked when reloading a session that's got a variable pitch font selected. (I'm half-expecting a potential flurry of requests for this feature in the wake of http://xkcd.com/840/ , so I thought I'd pre-empt them :-) [originally from svn r9063] [r5003 == ba470dec5e37ffbde05425f48e7e9a64219aec2e]
2010-12-29 14:11:25 +00:00
* Or ... I could do a test print with "W", and use +1
* or -1 for this shift depending on if the leftmost
* column is blank...
*/
windows/window.c: move more variables into WinGuiSeat. In commit f9e572595bb8cb6 I claimed that I'd removed very nearly all the global and static variables from windows/window.c. It turns out that this was wildly overoptimistic - I missed quite a few of them! I'm not quite sure how I managed that; my best guess is that I used an underpowered 'nm' command that failed to find some classes of variable. Some of the remaining function-scope statics were removed completely by commit afb3dab1e97a09f just now. In this commit, I've swept up some more and turn them into fields of WinGuiSeat, where they should have been moved last September. The (hopefully complete this time) list of remaining variables, generated by running this rune in the Windows build directory: nm windows/CMakeFiles/putty.dir/window.c.obj | grep -E '^([^ ]+)? *[bBcCdDgGsS] [^\.]' consists of the following variables which are legitimately global across the whole process and not related to a particular window: - 'hinst' and 'hprev', instance handles for Windows loadable modules - 'classname' in the terminal_window_class_a() and terminal_window_class_w() functions, which allocate a window class reusably - some pointers to Windows API functions retrieved via the DECL_WINDOWS_FUNCTION / GET_WINDOWS_FUNCTION system, such as p_AdjustWindowRectExForDpi and p_FlashWindowEx - some pointers to Windows API functions set up by assigning them at startup to the right one of the ANSI or Unicode version depending on the Windows version, e.g. sw_DefWindowProc and sw_DispatchMessage - 'unicode_window', a boolean flag set at the same time as those sw_Foo function pointers - 'sesslist', storing the last-retrieved version of the saved sessions menu - 'cursor_visible' in show_mouseptr() and 'forced_visible' in update_mouse_pointer(), each of which tracks the cumulative number of times that function has shown or hidden the mouse pointer, so as to manage its effect on the global state updated by ShowCursor - 'trust_icon', loaded from the executable's resources - 'wgslisthead', the list of all active WinGuiSeats - 'wm_mousewheel', the window-message id we use for mouse wheel events and the following which are nothing to do with our code: - '_OptionsStorage' in __local_stdio_printf_options() and __local_stdio_scanf_options(), which I'd never noticed before, but apparently are internal to a standard library header.
2023-05-27 13:59:20 +00:00
ExtTextOut(
wgs->wintw_hdc, x + xoffset - 1,
y - wgs->font_height * (lattr == LATTR_BOT) + text_adjust,
ETO_CLIPPED, &line_box, cbuf, len,
(use_lpDx ? lpDx : NULL));
Support for using variable-pitch fonts for the terminal on Windows. Done in much the same way as it is in the GTK front end: the character cell width is determined using the font's digits (which seems to give generally not-too-offensive spacing in most cases, at the expense of Ms and Ws typically overhanging a bit into adjacent cells) and each character is centred in its cell. Overhangs never leave permanent droppings on the window, because the existing work done in r5003 handles them just fine even in this stressful scenario. There's a hacky new checkbox in the Appearance panel to make variable-pitch fonts appear in the font selector (they still don't by default, because I still think it's _usually_ not What You Want); the checkbox state is not actually stored as part of a saved session, but it should be automatically ticked when reloading a session that's got a variable pitch font selected. (I'm half-expecting a potential flurry of requests for this feature in the wake of http://xkcd.com/840/ , so I thought I'd pre-empt them :-) [originally from svn r9063] [r5003 == ba470dec5e37ffbde05425f48e7e9a64219aec2e]
2010-12-29 14:11:25 +00:00
}
} else {
/* And 'normal' unicode characters */
Remove some pointless 'static' qualifiers. In windows/window.c, a few variables inside functions were declared as static, with no particular purpose that I can see: they don't seem to have any reason to persist between calls to the function. So it makes more sense to have them be ordinary stack-allocated automatic variables. Static variables removed by this commit: - 'RECT ss' in reset_window. - 'WORD keys[3]' and 'BYTE keysb[3]' in TranslateKey. - several (buffer, length) pairs in do_text_internal. - keys_unicode[] in TranslateKey. All of these variables were originally introduced in patches credited to Robert de Bath, which means I can't even try to reconstruct my original thought processes, because they weren't _my_ thoughts anyway. The arrays in do_text_internal are the easiest to understand: they're reallocated larger as necessary, and making them static means the allocation from a previous call can be reused, saving a malloc (though I don't think that's a good enough reason to bother, these days). The fixed-size static arrays and RECT are harder to explain. I suspect they might originally have been that way because of 1990s attitudes to performance: in x86-32 it's probably marginally faster to give your variables constant addresses than sp-relative ones, and in the 1990s computers were much slower, so there's an argument for making things static if you have no _need_ to make them automatic. These days, the difference is negligible, and persistent state is much more widely recognised as a risk! But keys_unicode[] is by far the strangest, because there was code that clearly _did_ expect it to persist between calls, namely three assignments to keys_unicode[0] near the end of the function after it's finished being used for any other purpose, and a conditioned-out set of debug() calls at the top of the function that print its contents before anything has yet written to it. But as far as I can see, the persistent data in the array is otherwise completely unused. In any call to the function, if keys_unicode is used at all, then it's either written directly by a call to ToAsciiEx, or else (for pre-NT platforms) converted from ToAsciiEx's output via MultiByteToWideChar. In both cases, the integer variable 'r' indicates how many array elements were written, and subsequent accesses only ever read those elements. So the assignments to keys_unicode[0] at the end of the previous call will be overwritten before anything at all can depend on them - with the exception of those debug statements. I don't really understand what was going on here. It's tempting to guess that those final assignments must have once done something useful, and the code that used them was later removed. But the source control history doesn't bear that out: a static array of three elements (under its original name 'keys') was introduced in commit 0d5d39064a0d078, and then commits 953b7775b321a60 and 26f1085038d7cd9 added the other two assignments. And as far as I can see, even as of the original commit 0d5d39064a0d078, the code already had the property that there was a final assignment to keys[0] which would inevitably be overwritten in the next call before it could affect anything. So I'm totally confused about what those assignments were _ever_ useful for. But an email thread from the time suggests that some of those patches were being rebased repeatedly past other work (or rather, the much less reliable CVS analogue of rebasing), so my best guess is that that's where the confusion crept in - perhaps in RDB's original version of the code they did do something useful. Regardless of that, I'm pretty convinced that persistent array can't be doing anything useful _now_. So I'm taking it out. But if anyone reports a bug resulting from this change, then I'll eat my words - and with any luck the details of the bug report will give us a clue what's going on, and then we can put back some equivalent functionality with much better comments!
2023-05-27 13:56:31 +00:00
sgrowarray(wbuf, wbuflen, len);
for (int i = 0; i < len; i++)
Support for using variable-pitch fonts for the terminal on Windows. Done in much the same way as it is in the GTK front end: the character cell width is determined using the font's digits (which seems to give generally not-too-offensive spacing in most cases, at the expense of Ms and Ws typically overhanging a bit into adjacent cells) and each character is centred in its cell. Overhangs never leave permanent droppings on the window, because the existing work done in r5003 handles them just fine even in this stressful scenario. There's a hacky new checkbox in the Appearance panel to make variable-pitch fonts appear in the font selector (they still don't by default, because I still think it's _usually_ not What You Want); the checkbox state is not actually stored as part of a saved session, but it should be automatically ticked when reloading a session that's got a variable pitch font selected. (I'm half-expecting a potential flurry of requests for this feature in the wake of http://xkcd.com/840/ , so I thought I'd pre-empt them :-) [originally from svn r9063] [r5003 == ba470dec5e37ffbde05425f48e7e9a64219aec2e]
2010-12-29 14:11:25 +00:00
wbuf[i] = text[i];
/* print Glyphs as they are, without Windows' Shaping*/
windows/window.c: move more variables into WinGuiSeat. In commit f9e572595bb8cb6 I claimed that I'd removed very nearly all the global and static variables from windows/window.c. It turns out that this was wildly overoptimistic - I missed quite a few of them! I'm not quite sure how I managed that; my best guess is that I used an underpowered 'nm' command that failed to find some classes of variable. Some of the remaining function-scope statics were removed completely by commit afb3dab1e97a09f just now. In this commit, I've swept up some more and turn them into fields of WinGuiSeat, where they should have been moved last September. The (hopefully complete this time) list of remaining variables, generated by running this rune in the Windows build directory: nm windows/CMakeFiles/putty.dir/window.c.obj | grep -E '^([^ ]+)? *[bBcCdDgGsS] [^\.]' consists of the following variables which are legitimately global across the whole process and not related to a particular window: - 'hinst' and 'hprev', instance handles for Windows loadable modules - 'classname' in the terminal_window_class_a() and terminal_window_class_w() functions, which allocate a window class reusably - some pointers to Windows API functions retrieved via the DECL_WINDOWS_FUNCTION / GET_WINDOWS_FUNCTION system, such as p_AdjustWindowRectExForDpi and p_FlashWindowEx - some pointers to Windows API functions set up by assigning them at startup to the right one of the ANSI or Unicode version depending on the Windows version, e.g. sw_DefWindowProc and sw_DispatchMessage - 'unicode_window', a boolean flag set at the same time as those sw_Foo function pointers - 'sesslist', storing the last-retrieved version of the saved sessions menu - 'cursor_visible' in show_mouseptr() and 'forced_visible' in update_mouse_pointer(), each of which tracks the cumulative number of times that function has shown or hidden the mouse pointer, so as to manage its effect on the global state updated by ShowCursor - 'trust_icon', loaded from the executable's resources - 'wgslisthead', the list of all active WinGuiSeats - 'wm_mousewheel', the window-message id we use for mouse wheel events and the following which are nothing to do with our code: - '_OptionsStorage' in __local_stdio_printf_options() and __local_stdio_scanf_options(), which I'd never noticed before, but apparently are internal to a standard library header.
2023-05-27 13:59:20 +00:00
general_textout(
wgs, wgs->wintw_hdc, x + xoffset,
y - wgs->font_height * (lattr==LATTR_BOT) + text_adjust,
&line_box, wbuf, len, lpDx,
opaque && !(attr & TATTR_COMBINING));
Support for using variable-pitch fonts for the terminal on Windows. Done in much the same way as it is in the GTK front end: the character cell width is determined using the font's digits (which seems to give generally not-too-offensive spacing in most cases, at the expense of Ms and Ws typically overhanging a bit into adjacent cells) and each character is centred in its cell. Overhangs never leave permanent droppings on the window, because the existing work done in r5003 handles them just fine even in this stressful scenario. There's a hacky new checkbox in the Appearance panel to make variable-pitch fonts appear in the font selector (they still don't by default, because I still think it's _usually_ not What You Want); the checkbox state is not actually stored as part of a saved session, but it should be automatically ticked when reloading a session that's got a variable pitch font selected. (I'm half-expecting a potential flurry of requests for this feature in the wake of http://xkcd.com/840/ , so I thought I'd pre-empt them :-) [originally from svn r9063] [r5003 == ba470dec5e37ffbde05425f48e7e9a64219aec2e]
2010-12-29 14:11:25 +00:00
/* And the shadow bold hack. */
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
if (wgs->bold_font_mode == BOLD_SHADOW && (attr & ATTR_BOLD)) {
SetBkMode(wgs->wintw_hdc, TRANSPARENT);
windows/window.c: move more variables into WinGuiSeat. In commit f9e572595bb8cb6 I claimed that I'd removed very nearly all the global and static variables from windows/window.c. It turns out that this was wildly overoptimistic - I missed quite a few of them! I'm not quite sure how I managed that; my best guess is that I used an underpowered 'nm' command that failed to find some classes of variable. Some of the remaining function-scope statics were removed completely by commit afb3dab1e97a09f just now. In this commit, I've swept up some more and turn them into fields of WinGuiSeat, where they should have been moved last September. The (hopefully complete this time) list of remaining variables, generated by running this rune in the Windows build directory: nm windows/CMakeFiles/putty.dir/window.c.obj | grep -E '^([^ ]+)? *[bBcCdDgGsS] [^\.]' consists of the following variables which are legitimately global across the whole process and not related to a particular window: - 'hinst' and 'hprev', instance handles for Windows loadable modules - 'classname' in the terminal_window_class_a() and terminal_window_class_w() functions, which allocate a window class reusably - some pointers to Windows API functions retrieved via the DECL_WINDOWS_FUNCTION / GET_WINDOWS_FUNCTION system, such as p_AdjustWindowRectExForDpi and p_FlashWindowEx - some pointers to Windows API functions set up by assigning them at startup to the right one of the ANSI or Unicode version depending on the Windows version, e.g. sw_DefWindowProc and sw_DispatchMessage - 'unicode_window', a boolean flag set at the same time as those sw_Foo function pointers - 'sesslist', storing the last-retrieved version of the saved sessions menu - 'cursor_visible' in show_mouseptr() and 'forced_visible' in update_mouse_pointer(), each of which tracks the cumulative number of times that function has shown or hidden the mouse pointer, so as to manage its effect on the global state updated by ShowCursor - 'trust_icon', loaded from the executable's resources - 'wgslisthead', the list of all active WinGuiSeats - 'wm_mousewheel', the window-message id we use for mouse wheel events and the following which are nothing to do with our code: - '_OptionsStorage' in __local_stdio_printf_options() and __local_stdio_scanf_options(), which I'd never noticed before, but apparently are internal to a standard library header.
2023-05-27 13:59:20 +00:00
ExtTextOutW(
wgs->wintw_hdc, x + xoffset - 1,
y - wgs->font_height * (lattr == LATTR_BOT) + text_adjust,
ETO_CLIPPED, &line_box, wbuf, len,
(use_lpDx ? lpDx : NULL));
Support for using variable-pitch fonts for the terminal on Windows. Done in much the same way as it is in the GTK front end: the character cell width is determined using the font's digits (which seems to give generally not-too-offensive spacing in most cases, at the expense of Ms and Ws typically overhanging a bit into adjacent cells) and each character is centred in its cell. Overhangs never leave permanent droppings on the window, because the existing work done in r5003 handles them just fine even in this stressful scenario. There's a hacky new checkbox in the Appearance panel to make variable-pitch fonts appear in the font selector (they still don't by default, because I still think it's _usually_ not What You Want); the checkbox state is not actually stored as part of a saved session, but it should be automatically ticked when reloading a session that's got a variable pitch font selected. (I'm half-expecting a potential flurry of requests for this feature in the wake of http://xkcd.com/840/ , so I thought I'd pre-empt them :-) [originally from svn r9063] [r5003 == ba470dec5e37ffbde05425f48e7e9a64219aec2e]
2010-12-29 14:11:25 +00:00
}
}
First-stage support for Unicode combining characters. The `chars' array of each `termline' structure now contains optional additional entries after the normal number of columns, which are used to chain a linked list of combining characters off any primary termchar that needs it. This means we support arbitrarily many combining characters per cell (unlike xterm's hard limit of 2). Cut and paste works correctly (selecting a character cell containing multiple code points causes all those code points to be cut and pasted). Display works by simply overlaying all the relevant characters on top of one another; this is good enough for Unix (xterm does the same thing), and mostly seems OK for Windows except that the Windows Unicode fonts have a nasty habit of not containing most of the combining characters and thus overlaying an unknown-code-point box on your perfectly good base glyph. I had no idea how to add support in the Mac do_text(), so I've simply stuck in an assertion that will trigger the first time a combining character is displayed, and hopefully this will bite someone with the clue to fix it. [originally from svn r4622]
2004-10-14 16:42:43 +00:00
Support for using variable-pitch fonts for the terminal on Windows. Done in much the same way as it is in the GTK front end: the character cell width is determined using the font's digits (which seems to give generally not-too-offensive spacing in most cases, at the expense of Ms and Ws typically overhanging a bit into adjacent cells) and each character is centred in its cell. Overhangs never leave permanent droppings on the window, because the existing work done in r5003 handles them just fine even in this stressful scenario. There's a hacky new checkbox in the Appearance panel to make variable-pitch fonts appear in the font selector (they still don't by default, because I still think it's _usually_ not What You Want); the checkbox state is not actually stored as part of a saved session, but it should be automatically ticked when reloading a session that's got a variable pitch font selected. (I'm half-expecting a potential flurry of requests for this feature in the wake of http://xkcd.com/840/ , so I thought I'd pre-empt them :-) [originally from svn r9063] [r5003 == ba470dec5e37ffbde05425f48e7e9a64219aec2e]
2010-12-29 14:11:25 +00:00
/*
* If we're looping round again, stop erasing the background
* rectangle.
*/
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
SetBkMode(wgs->wintw_hdc, TRANSPARENT);
Adopt C99 <stdbool.h>'s true/false. This commit includes <stdbool.h> from defs.h and deletes my traditional definitions of TRUE and FALSE, but other than that, it's a 100% mechanical search-and-replace transforming all uses of TRUE and FALSE into the C99-standardised lowercase spellings. No actual types are changed in this commit; that will come next. This is just getting the noise out of the way, so that subsequent commits can have a higher proportion of signal.
2018-10-29 19:50:29 +00:00
opaque = false;
Initial checkin: beta 0.43 [originally from svn r11]
1999-01-08 13:02:13 +00:00
}
Support SGR 9 for strikethrough effect on text. This is mostly easy: it's just like drawing an underline, except that you put it at a different height in the character cell. The only question is _where_ in the character cell. Pango, and Windows GetOutlineTextMetrics, will tell you exactly where the font wants to have it. Following xterm, I fall back to 3/8 of the font's ascent (above the baseline) if either of those is unavailable.
2020-08-13 20:08:53 +00:00
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
if (lattr != LATTR_TOP &&
(force_manual_underline || (wgs->und_mode == UND_LINE &&
(attr & ATTR_UNDER))))
draw_horizontal_line_on_text(wgs, wgs->descent, lattr, line_box, fg);
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
Support SGR 9 for strikethrough effect on text. This is mostly easy: it's just like drawing an underline, except that you put it at a different height in the character cell. The only question is _where_ in the character cell. Pango, and Windows GetOutlineTextMetrics, will tell you exactly where the font wants to have it. Following xterm, I fall back to 3/8 of the font's ascent (above the baseline) if either of those is unavailable.
2020-08-13 20:08:53 +00:00
if (attr & ATTR_STRIKE)
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
draw_horizontal_line_on_text(wgs, wgs->font_strikethrough_y, lattr,
line_box, fg);
Remove some pointless 'static' qualifiers. In windows/window.c, a few variables inside functions were declared as static, with no particular purpose that I can see: they don't seem to have any reason to persist between calls to the function. So it makes more sense to have them be ordinary stack-allocated automatic variables. Static variables removed by this commit: - 'RECT ss' in reset_window. - 'WORD keys[3]' and 'BYTE keysb[3]' in TranslateKey. - several (buffer, length) pairs in do_text_internal. - keys_unicode[] in TranslateKey. All of these variables were originally introduced in patches credited to Robert de Bath, which means I can't even try to reconstruct my original thought processes, because they weren't _my_ thoughts anyway. The arrays in do_text_internal are the easiest to understand: they're reallocated larger as necessary, and making them static means the allocation from a previous call can be reused, saving a malloc (though I don't think that's a good enough reason to bother, these days). The fixed-size static arrays and RECT are harder to explain. I suspect they might originally have been that way because of 1990s attitudes to performance: in x86-32 it's probably marginally faster to give your variables constant addresses than sp-relative ones, and in the 1990s computers were much slower, so there's an argument for making things static if you have no _need_ to make them automatic. These days, the difference is negligible, and persistent state is much more widely recognised as a risk! But keys_unicode[] is by far the strangest, because there was code that clearly _did_ expect it to persist between calls, namely three assignments to keys_unicode[0] near the end of the function after it's finished being used for any other purpose, and a conditioned-out set of debug() calls at the top of the function that print its contents before anything has yet written to it. But as far as I can see, the persistent data in the array is otherwise completely unused. In any call to the function, if keys_unicode is used at all, then it's either written directly by a call to ToAsciiEx, or else (for pre-NT platforms) converted from ToAsciiEx's output via MultiByteToWideChar. In both cases, the integer variable 'r' indicates how many array elements were written, and subsequent accesses only ever read those elements. So the assignments to keys_unicode[0] at the end of the previous call will be overwritten before anything at all can depend on them - with the exception of those debug statements. I don't really understand what was going on here. It's tempting to guess that those final assignments must have once done something useful, and the code that used them was later removed. But the source control history doesn't bear that out: a static array of three elements (under its original name 'keys') was introduced in commit 0d5d39064a0d078, and then commits 953b7775b321a60 and 26f1085038d7cd9 added the other two assignments. And as far as I can see, even as of the original commit 0d5d39064a0d078, the code already had the property that there was a final assignment to keys[0] which would inevitably be overwritten in the next call before it could affect anything. So I'm totally confused about what those assignments were _ever_ useful for. But an email thread from the time suggests that some of those patches were being rebased repeatedly past other work (or rather, the much less reliable CVS analogue of rebasing), so my best guess is that that's where the confusion crept in - perhaps in RDB's original version of the code they did do something useful. Regardless of that, I'm pretty convinced that persistent array can't be doing anything useful _now_. So I'm taking it out. But if anyone reports a bug resulting from this change, then I'll eat my words - and with any luck the details of the bug report will give us a clue what's going on, and then we can put back some equivalent functionality with much better comments!
2023-05-27 13:56:31 +00:00
out:
sfree(lpDx);
sfree(wbuf);
sfree(cbuf);
RDB's Unicode patch. Fonts are now used in Unicode mode where possible and we have a single unified means of trying to display any Unicode code point. Instead of the various ad-hoc translation modes we had before, we now have a single `codepage' option which allows us to treat the incoming (and outgoing) text as any given character set, and locally we map that to Unicode and back. [originally from svn r1110]
2001-05-10 08:34:20 +00:00
}
First-stage support for Unicode combining characters. The `chars' array of each `termline' structure now contains optional additional entries after the normal number of columns, which are used to chain a linked list of combining characters off any primary termchar that needs it. This means we support arbitrarily many combining characters per cell (unlike xterm's hard limit of 2). Cut and paste works correctly (selecting a character cell containing multiple code points causes all those code points to be cut and pasted). Display works by simply overlaying all the relevant characters on top of one another; this is good enough for Unix (xterm does the same thing), and mostly seems OK for Windows except that the Windows Unicode fonts have a nasty habit of not containing most of the combining characters and thus overlaying an unknown-code-point box on your perfectly good base glyph. I had no idea how to add support in the Mac do_text(), so I've simply stuck in an assertion that will trigger the first time a combining character is displayed, and hopefully this will bite someone with the clue to fix it. [originally from svn r4622]
2004-10-14 16:42:43 +00:00
/*
* Wrapper that handles combining characters.
*/
Remove the 'Frontend' type and replace it with a vtable. After the recent Seat and LogContext revamps, _nearly_ all the remaining uses of the type 'Frontend' were in terminal.c, which needs all sorts of interactions with the GUI window the terminal lives in, from the obvious (actually drawing text on the window, reading and writing the clipboard) to the obscure (minimising, maximising and moving the window in response to particular escape sequences). All of those functions are now provided by an abstraction called TermWin. The few remaining uses of Frontend after _that_ are internal to a particular platform directory, so as to spread the implementation of that particular kind of Frontend between multiple source files; so I've renamed all of those so that they take a more specifically named type that refers to the particular implementation rather than the general abstraction. So now the name 'Frontend' no longer exists in the code base at all, and everywhere one used to be used, it's completely clear whether it was operating in one of Frontend's three abstract roles (and if so, which), or whether it was specific to a particular implementation. Another type that's disappeared is 'Context', which used to be a typedef defined to something different on each platform, describing whatever short-lived resources were necessary to draw on the terminal window: the front end would provide a ready-made one when calling term_paint, and the terminal could request one with get_ctx/free_ctx if it wanted to do proactive window updates. Now that drawing context lives inside the TermWin itself, because there was never any need to have two of those contexts live at the same time. (Another minor API change is that the window-title functions - both reading and writing - have had a missing 'const' added to their char * parameters / return values.) I don't expect this change to enable any particularly interesting new functionality (in particular, I have no plans that need more than one implementation of TermWin in the same application). But it completes the tidying-up that began with the Seat and LogContext rework.
2018-10-25 17:44:04 +00:00
static void wintw_draw_text(
TermWin *tw, int x, int y, wchar_t *text, int len,
unsigned long attr, int lattr, truecolour truecolour)
First-stage support for Unicode combining characters. The `chars' array of each `termline' structure now contains optional additional entries after the normal number of columns, which are used to chain a linked list of combining characters off any primary termchar that needs it. This means we support arbitrarily many combining characters per cell (unlike xterm's hard limit of 2). Cut and paste works correctly (selecting a character cell containing multiple code points causes all those code points to be cut and pasted). Display works by simply overlaying all the relevant characters on top of one another; this is good enough for Unix (xterm does the same thing), and mostly seems OK for Windows except that the Windows Unicode fonts have a nasty habit of not containing most of the combining characters and thus overlaying an unknown-code-point box on your perfectly good base glyph. I had no idea how to add support in the Mac do_text(), so I've simply stuck in an assertion that will trigger the first time a combining character is displayed, and hopefully this will bite someone with the clue to fix it. [originally from svn r4622]
2004-10-14 16:42:43 +00:00
{
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
WinGuiSeat *wgs = container_of(tw, WinGuiSeat, termwin);
First-stage support for Unicode combining characters. The `chars' array of each `termline' structure now contains optional additional entries after the normal number of columns, which are used to chain a linked list of combining characters off any primary termchar that needs it. This means we support arbitrarily many combining characters per cell (unlike xterm's hard limit of 2). Cut and paste works correctly (selecting a character cell containing multiple code points causes all those code points to be cut and pasted). Display works by simply overlaying all the relevant characters on top of one another; this is good enough for Unix (xterm does the same thing), and mostly seems OK for Windows except that the Windows Unicode fonts have a nasty habit of not containing most of the combining characters and thus overlaying an unknown-code-point box on your perfectly good base glyph. I had no idea how to add support in the Mac do_text(), so I've simply stuck in an assertion that will trigger the first time a combining character is displayed, and hopefully this will bite someone with the clue to fix it. [originally from svn r4622]
2004-10-14 16:42:43 +00:00
if (attr & TATTR_COMBINING) {
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
unsigned long a = 0;
int len0 = 1;
Patch from Yoshida Masato to fill in the missing pieces of Windows UTF-16 support. High Unicode characters in the terminal are now converted back into surrogates during copy and draw operations, and the Windows drawing code takes account of that when splitting up the UTF-16 string for display. Meanwhile, accidental uses of wchar_t have been replaced with 32-bit integers in parts of the cross-platform code which were expecting not to have to deal with UTF-16. [originally from svn r9409]
2012-02-17 19:28:55 +00:00
/* don't divide SURROGATE PAIR and VARIATION SELECTOR */
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
if (len >= 2 && IS_SURROGATE_PAIR(text[0], text[1]))
len0 = 2;
if (len-len0 >= 1 && IS_LOW_VARSEL(text[len0])) {
attr &= ~TATTR_COMBINING;
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
do_text_internal(wgs, x, y, text, len0+1, attr, lattr, truecolour);
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
text += len0+1;
len -= len0+1;
a = TATTR_COMBINING;
} else if (len-len0 >= 2 && IS_HIGH_VARSEL(text[len0], text[len0+1])) {
attr &= ~TATTR_COMBINING;
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
do_text_internal(wgs, x, y, text, len0+2, attr, lattr, truecolour);
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
text += len0+2;
len -= len0+2;
a = TATTR_COMBINING;
} else {
Patch from Yoshida Masato to fill in the missing pieces of Windows UTF-16 support. High Unicode characters in the terminal are now converted back into surrogates during copy and draw operations, and the Windows drawing code takes account of that when splitting up the UTF-16 string for display. Meanwhile, accidental uses of wchar_t have been replaced with 32-bit integers in parts of the cross-platform code which were expecting not to have to deal with UTF-16. [originally from svn r9409]
2012-02-17 19:28:55 +00:00
attr &= ~TATTR_COMBINING;
}
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
while (len--) {
if (len >= 1 && IS_SURROGATE_PAIR(text[0], text[1])) {
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
do_text_internal(wgs, x, y, text, 2, attr | a, lattr,
truecolour);
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
len--;
text++;
} else
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
do_text_internal(wgs, x, y, text, 1, attr | a, lattr,
truecolour);
Patch from Yoshida Masato to fill in the missing pieces of Windows UTF-16 support. High Unicode characters in the terminal are now converted back into surrogates during copy and draw operations, and the Windows drawing code takes account of that when splitting up the UTF-16 string for display. Meanwhile, accidental uses of wchar_t have been replaced with 32-bit integers in parts of the cross-platform code which were expecting not to have to deal with UTF-16. [originally from svn r9409]
2012-02-17 19:28:55 +00:00
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
text++;
a = TATTR_COMBINING;
}
First-stage support for Unicode combining characters. The `chars' array of each `termline' structure now contains optional additional entries after the normal number of columns, which are used to chain a linked list of combining characters off any primary termchar that needs it. This means we support arbitrarily many combining characters per cell (unlike xterm's hard limit of 2). Cut and paste works correctly (selecting a character cell containing multiple code points causes all those code points to be cut and pasted). Display works by simply overlaying all the relevant characters on top of one another; this is good enough for Unix (xterm does the same thing), and mostly seems OK for Windows except that the Windows Unicode fonts have a nasty habit of not containing most of the combining characters and thus overlaying an unknown-code-point box on your perfectly good base glyph. I had no idea how to add support in the Mac do_text(), so I've simply stuck in an assertion that will trigger the first time a combining character is displayed, and hopefully this will bite someone with the clue to fix it. [originally from svn r4622]
2004-10-14 16:42:43 +00:00
} else
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
do_text_internal(wgs, x, y, text, len, attr, lattr, truecolour);
First-stage support for Unicode combining characters. The `chars' array of each `termline' structure now contains optional additional entries after the normal number of columns, which are used to chain a linked list of combining characters off any primary termchar that needs it. This means we support arbitrarily many combining characters per cell (unlike xterm's hard limit of 2). Cut and paste works correctly (selecting a character cell containing multiple code points causes all those code points to be cut and pasted). Display works by simply overlaying all the relevant characters on top of one another; this is good enough for Unix (xterm does the same thing), and mostly seems OK for Windows except that the Windows Unicode fonts have a nasty habit of not containing most of the combining characters and thus overlaying an unknown-code-point box on your perfectly good base glyph. I had no idea how to add support in the Mac do_text(), so I've simply stuck in an assertion that will trigger the first time a combining character is displayed, and hopefully this will bite someone with the clue to fix it. [originally from svn r4622]
2004-10-14 16:42:43 +00:00
}
Remove the 'Frontend' type and replace it with a vtable. After the recent Seat and LogContext revamps, _nearly_ all the remaining uses of the type 'Frontend' were in terminal.c, which needs all sorts of interactions with the GUI window the terminal lives in, from the obvious (actually drawing text on the window, reading and writing the clipboard) to the obscure (minimising, maximising and moving the window in response to particular escape sequences). All of those functions are now provided by an abstraction called TermWin. The few remaining uses of Frontend after _that_ are internal to a particular platform directory, so as to spread the implementation of that particular kind of Frontend between multiple source files; so I've renamed all of those so that they take a more specifically named type that refers to the particular implementation rather than the general abstraction. So now the name 'Frontend' no longer exists in the code base at all, and everywhere one used to be used, it's completely clear whether it was operating in one of Frontend's three abstract roles (and if so, which), or whether it was specific to a particular implementation. Another type that's disappeared is 'Context', which used to be a typedef defined to something different on each platform, describing whatever short-lived resources were necessary to draw on the terminal window: the front end would provide a ready-made one when calling term_paint, and the terminal could request one with get_ctx/free_ctx if it wanted to do proactive window updates. Now that drawing context lives inside the TermWin itself, because there was never any need to have two of those contexts live at the same time. (Another minor API change is that the window-title functions - both reading and writing - have had a missing 'const' added to their char * parameters / return values.) I don't expect this change to enable any particularly interesting new functionality (in particular, I have no plans that need more than one implementation of TermWin in the same application). But it completes the tidying-up that began with the Seat and LogContext rework.
2018-10-25 17:44:04 +00:00
static void wintw_draw_cursor(
TermWin *tw, int x, int y, wchar_t *text, int len,
unsigned long attr, int lattr, truecolour truecolour)
RDB's Unicode patch. Fonts are now used in Unicode mode where possible and we have a single unified means of trying to display any Unicode code point. Instead of the various ad-hoc translation modes we had before, we now have a single `codepage' option which allows us to treat the incoming (and outgoing) text as any given character set, and locally we map that to Unicode and back. [originally from svn r1110]
2001-05-10 08:34:20 +00:00
{
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
WinGuiSeat *wgs = container_of(tw, WinGuiSeat, termwin);
RDB's Unicode patch. Fonts are now used in Unicode mode where possible and we have a single unified means of trying to display any Unicode code point. Instead of the various ad-hoc translation modes we had before, we now have a single `codepage' option which allows us to treat the incoming (and outgoing) text as any given character set, and locally we map that to Unicode and back. [originally from svn r1110]
2001-05-10 08:34:20 +00:00
int fnt_width;
int char_width;
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
int ctype = wgs->cursor_type;
RDB's Unicode patch. Fonts are now used in Unicode mode where possible and we have a single unified means of trying to display any Unicode code point. Instead of the various ad-hoc translation modes we had before, we now have a single `codepage' option which allows us to treat the incoming (and outgoing) text as any given character set, and locally we map that to Unicode and back. [originally from svn r1110]
2001-05-10 08:34:20 +00:00
I masked off LATTR_WRAPPED et al in do_text_internal(), but forgot to do the same in do_cursor(). Bet that's the cause of Andrey Borzenkov's cursor positioning bug. [originally from svn r4770]
2004-11-11 09:40:50 +00:00
lattr &= LATTR_MODE;
Cleanup: make an enum for the values of CONF_cursor_type. These have been magic numbers 0, 1 and 2 in the source for ages. I think it's about time they had actual names, to make all the points of use clearer.
2023-05-29 14:51:17 +00:00
if ((attr & TATTR_ACTCURS) &&
(ctype == CURSOR_BLOCK || wgs->term->big_cursor)) {
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
if (*text != UCSWIDE) {
win_draw_text(tw, x, y, text, len, attr, lattr, truecolour);
return;
}
Cleanup: make an enum for the values of CONF_cursor_type. These have been magic numbers 0, 1 and 2 in the source for ages. I think it's about time they had actual names, to make all the points of use clearer.
2023-05-29 14:51:17 +00:00
ctype = CURSOR_VERTICAL_LINE;
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
attr |= TATTR_RIGHTCURS;
RDB's Unicode patch. Fonts are now used in Unicode mode where possible and we have a single unified means of trying to display any Unicode code point. Instead of the various ad-hoc translation modes we had before, we now have a single `codepage' option which allows us to treat the incoming (and outgoing) text as any given character set, and locally we map that to Unicode and back. [originally from svn r1110]
2001-05-10 08:34:20 +00:00
}
windows/window.c: move more variables into WinGuiSeat. In commit f9e572595bb8cb6 I claimed that I'd removed very nearly all the global and static variables from windows/window.c. It turns out that this was wildly overoptimistic - I missed quite a few of them! I'm not quite sure how I managed that; my best guess is that I used an underpowered 'nm' command that failed to find some classes of variable. Some of the remaining function-scope statics were removed completely by commit afb3dab1e97a09f just now. In this commit, I've swept up some more and turn them into fields of WinGuiSeat, where they should have been moved last September. The (hopefully complete this time) list of remaining variables, generated by running this rune in the Windows build directory: nm windows/CMakeFiles/putty.dir/window.c.obj | grep -E '^([^ ]+)? *[bBcCdDgGsS] [^\.]' consists of the following variables which are legitimately global across the whole process and not related to a particular window: - 'hinst' and 'hprev', instance handles for Windows loadable modules - 'classname' in the terminal_window_class_a() and terminal_window_class_w() functions, which allocate a window class reusably - some pointers to Windows API functions retrieved via the DECL_WINDOWS_FUNCTION / GET_WINDOWS_FUNCTION system, such as p_AdjustWindowRectExForDpi and p_FlashWindowEx - some pointers to Windows API functions set up by assigning them at startup to the right one of the ANSI or Unicode version depending on the Windows version, e.g. sw_DefWindowProc and sw_DispatchMessage - 'unicode_window', a boolean flag set at the same time as those sw_Foo function pointers - 'sesslist', storing the last-retrieved version of the saved sessions menu - 'cursor_visible' in show_mouseptr() and 'forced_visible' in update_mouse_pointer(), each of which tracks the cumulative number of times that function has shown or hidden the mouse pointer, so as to manage its effect on the global state updated by ShowCursor - 'trust_icon', loaded from the executable's resources - 'wgslisthead', the list of all active WinGuiSeats - 'wm_mousewheel', the window-message id we use for mouse wheel events and the following which are nothing to do with our code: - '_OptionsStorage' in __local_stdio_printf_options() and __local_stdio_scanf_options(), which I'd never noticed before, but apparently are internal to a standard library header.
2023-05-27 13:59:20 +00:00
fnt_width = char_width = wgs->font_width * (1 + (lattr != LATTR_NORM));
RDB's Unicode patch. Fonts are now used in Unicode mode where possible and we have a single unified means of trying to display any Unicode code point. Instead of the various ad-hoc translation modes we had before, we now have a single `codepage' option which allows us to treat the incoming (and outgoing) text as any given character set, and locally we map that to Unicode and back. [originally from svn r1110]
2001-05-10 08:34:20 +00:00
if (attr & ATTR_WIDE)
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
char_width *= 2;
RDB's Unicode patch. Fonts are now used in Unicode mode where possible and we have a single unified means of trying to display any Unicode code point. Instead of the various ad-hoc translation modes we had before, we now have a single `codepage' option which allows us to treat the incoming (and outgoing) text as any given character set, and locally we map that to Unicode and back. [originally from svn r1110]
2001-05-10 08:34:20 +00:00
x *= fnt_width;
windows/window.c: move more variables into WinGuiSeat. In commit f9e572595bb8cb6 I claimed that I'd removed very nearly all the global and static variables from windows/window.c. It turns out that this was wildly overoptimistic - I missed quite a few of them! I'm not quite sure how I managed that; my best guess is that I used an underpowered 'nm' command that failed to find some classes of variable. Some of the remaining function-scope statics were removed completely by commit afb3dab1e97a09f just now. In this commit, I've swept up some more and turn them into fields of WinGuiSeat, where they should have been moved last September. The (hopefully complete this time) list of remaining variables, generated by running this rune in the Windows build directory: nm windows/CMakeFiles/putty.dir/window.c.obj | grep -E '^([^ ]+)? *[bBcCdDgGsS] [^\.]' consists of the following variables which are legitimately global across the whole process and not related to a particular window: - 'hinst' and 'hprev', instance handles for Windows loadable modules - 'classname' in the terminal_window_class_a() and terminal_window_class_w() functions, which allocate a window class reusably - some pointers to Windows API functions retrieved via the DECL_WINDOWS_FUNCTION / GET_WINDOWS_FUNCTION system, such as p_AdjustWindowRectExForDpi and p_FlashWindowEx - some pointers to Windows API functions set up by assigning them at startup to the right one of the ANSI or Unicode version depending on the Windows version, e.g. sw_DefWindowProc and sw_DispatchMessage - 'unicode_window', a boolean flag set at the same time as those sw_Foo function pointers - 'sesslist', storing the last-retrieved version of the saved sessions menu - 'cursor_visible' in show_mouseptr() and 'forced_visible' in update_mouse_pointer(), each of which tracks the cumulative number of times that function has shown or hidden the mouse pointer, so as to manage its effect on the global state updated by ShowCursor - 'trust_icon', loaded from the executable's resources - 'wgslisthead', the list of all active WinGuiSeats - 'wm_mousewheel', the window-message id we use for mouse wheel events and the following which are nothing to do with our code: - '_OptionsStorage' in __local_stdio_printf_options() and __local_stdio_scanf_options(), which I'd never noticed before, but apparently are internal to a standard library header.
2023-05-27 13:59:20 +00:00
y *= wgs->font_height;
x += wgs->offset_width;
y += wgs->offset_height;
RDB's Unicode patch. Fonts are now used in Unicode mode where possible and we have a single unified means of trying to display any Unicode code point. Instead of the various ad-hoc translation modes we had before, we now have a single `codepage' option which allows us to treat the incoming (and outgoing) text as any given character set, and locally we map that to Unicode and back. [originally from svn r1110]
2001-05-10 08:34:20 +00:00
Cleanup: make an enum for the values of CONF_cursor_type. These have been magic numbers 0, 1 and 2 in the source for ages. I think it's about time they had actual names, to make all the points of use clearer.
2023-05-29 14:51:17 +00:00
if ((attr & TATTR_PASCURS) &&
(ctype == CURSOR_BLOCK || wgs->term->big_cursor)) {
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
POINT pts[5];
HPEN oldpen;
pts[0].x = pts[1].x = pts[4].x = x;
pts[2].x = pts[3].x = x + char_width - 1;
pts[0].y = pts[3].y = pts[4].y = y;
windows/window.c: move more variables into WinGuiSeat. In commit f9e572595bb8cb6 I claimed that I'd removed very nearly all the global and static variables from windows/window.c. It turns out that this was wildly overoptimistic - I missed quite a few of them! I'm not quite sure how I managed that; my best guess is that I used an underpowered 'nm' command that failed to find some classes of variable. Some of the remaining function-scope statics were removed completely by commit afb3dab1e97a09f just now. In this commit, I've swept up some more and turn them into fields of WinGuiSeat, where they should have been moved last September. The (hopefully complete this time) list of remaining variables, generated by running this rune in the Windows build directory: nm windows/CMakeFiles/putty.dir/window.c.obj | grep -E '^([^ ]+)? *[bBcCdDgGsS] [^\.]' consists of the following variables which are legitimately global across the whole process and not related to a particular window: - 'hinst' and 'hprev', instance handles for Windows loadable modules - 'classname' in the terminal_window_class_a() and terminal_window_class_w() functions, which allocate a window class reusably - some pointers to Windows API functions retrieved via the DECL_WINDOWS_FUNCTION / GET_WINDOWS_FUNCTION system, such as p_AdjustWindowRectExForDpi and p_FlashWindowEx - some pointers to Windows API functions set up by assigning them at startup to the right one of the ANSI or Unicode version depending on the Windows version, e.g. sw_DefWindowProc and sw_DispatchMessage - 'unicode_window', a boolean flag set at the same time as those sw_Foo function pointers - 'sesslist', storing the last-retrieved version of the saved sessions menu - 'cursor_visible' in show_mouseptr() and 'forced_visible' in update_mouse_pointer(), each of which tracks the cumulative number of times that function has shown or hidden the mouse pointer, so as to manage its effect on the global state updated by ShowCursor - 'trust_icon', loaded from the executable's resources - 'wgslisthead', the list of all active WinGuiSeats - 'wm_mousewheel', the window-message id we use for mouse wheel events and the following which are nothing to do with our code: - '_OptionsStorage' in __local_stdio_printf_options() and __local_stdio_scanf_options(), which I'd never noticed before, but apparently are internal to a standard library header.
2023-05-27 13:59:20 +00:00
pts[1].y = pts[2].y = y + wgs->font_height - 1;
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
oldpen = SelectObject(wgs->wintw_hdc,
CreatePen(PS_SOLID, 0, wgs->colours[261]));
Polyline(wgs->wintw_hdc, pts, 5);
oldpen = SelectObject(wgs->wintw_hdc, oldpen);
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
DeleteObject(oldpen);
Cleanup: make an enum for the values of CONF_cursor_type. These have been magic numbers 0, 1 and 2 in the source for ages. I think it's about time they had actual names, to make all the points of use clearer.
2023-05-29 14:51:17 +00:00
} else if ((attr & (TATTR_ACTCURS | TATTR_PASCURS)) &&
ctype != CURSOR_BLOCK) {
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
int startx, starty, dx, dy, length, i;
Cleanup: make an enum for the values of CONF_cursor_type. These have been magic numbers 0, 1 and 2 in the source for ages. I think it's about time they had actual names, to make all the points of use clearer.
2023-05-29 14:51:17 +00:00
if (ctype == CURSOR_UNDERLINE) {
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
startx = x;
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
starty = y + wgs->descent;
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
dx = 1;
dy = 0;
length = char_width;
Cleanup: make an enum for the values of CONF_cursor_type. These have been magic numbers 0, 1 and 2 in the source for ages. I think it's about time they had actual names, to make all the points of use clearer.
2023-05-29 14:51:17 +00:00
} else /* ctype == CURSOR_VERTICAL_LINE */ {
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
int xadjust = 0;
if (attr & TATTR_RIGHTCURS)
xadjust = char_width - 1;
startx = x + xadjust;
starty = y;
dx = 0;
dy = 1;
windows/window.c: move more variables into WinGuiSeat. In commit f9e572595bb8cb6 I claimed that I'd removed very nearly all the global and static variables from windows/window.c. It turns out that this was wildly overoptimistic - I missed quite a few of them! I'm not quite sure how I managed that; my best guess is that I used an underpowered 'nm' command that failed to find some classes of variable. Some of the remaining function-scope statics were removed completely by commit afb3dab1e97a09f just now. In this commit, I've swept up some more and turn them into fields of WinGuiSeat, where they should have been moved last September. The (hopefully complete this time) list of remaining variables, generated by running this rune in the Windows build directory: nm windows/CMakeFiles/putty.dir/window.c.obj | grep -E '^([^ ]+)? *[bBcCdDgGsS] [^\.]' consists of the following variables which are legitimately global across the whole process and not related to a particular window: - 'hinst' and 'hprev', instance handles for Windows loadable modules - 'classname' in the terminal_window_class_a() and terminal_window_class_w() functions, which allocate a window class reusably - some pointers to Windows API functions retrieved via the DECL_WINDOWS_FUNCTION / GET_WINDOWS_FUNCTION system, such as p_AdjustWindowRectExForDpi and p_FlashWindowEx - some pointers to Windows API functions set up by assigning them at startup to the right one of the ANSI or Unicode version depending on the Windows version, e.g. sw_DefWindowProc and sw_DispatchMessage - 'unicode_window', a boolean flag set at the same time as those sw_Foo function pointers - 'sesslist', storing the last-retrieved version of the saved sessions menu - 'cursor_visible' in show_mouseptr() and 'forced_visible' in update_mouse_pointer(), each of which tracks the cumulative number of times that function has shown or hidden the mouse pointer, so as to manage its effect on the global state updated by ShowCursor - 'trust_icon', loaded from the executable's resources - 'wgslisthead', the list of all active WinGuiSeats - 'wm_mousewheel', the window-message id we use for mouse wheel events and the following which are nothing to do with our code: - '_OptionsStorage' in __local_stdio_printf_options() and __local_stdio_scanf_options(), which I'd never noticed before, but apparently are internal to a standard library header.
2023-05-27 13:59:20 +00:00
length = wgs->font_height;
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
}
if (attr & TATTR_ACTCURS) {
HPEN oldpen;
oldpen =
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
SelectObject(wgs->wintw_hdc,
CreatePen(PS_SOLID, 0, wgs->colours[261]));
MoveToEx(wgs->wintw_hdc, startx, starty, NULL);
LineTo(wgs->wintw_hdc, startx + dx * length, starty + dy * length);
oldpen = SelectObject(wgs->wintw_hdc, oldpen);
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
DeleteObject(oldpen);
} else {
for (i = 0; i < length; i++) {
if (i % 2 == 0) {
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
SetPixel(wgs->wintw_hdc, startx, starty,
wgs->colours[261]);
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
}
startx += dx;
starty += dy;
}
}
Introduce alternative cursor shapes: underline, vertical line [originally from svn r870]
2001-01-17 16:57:33 +00:00
}
Initial checkin: beta 0.43 [originally from svn r11]
1999-01-08 13:02:13 +00:00
}
Add a TermWin method to draw a 'trust sigil'. This is not yet used by anything, but the idea is that it'll be a graphic in the terminal window that can't be replicated by a server sending escape sequences, and hence can be used as a reliable indication that the text on a particular terminal line is generated by PuTTY itself and not passed through from the server. This will make it possible to detect a malicious server trying to mimic local prompts to trick you out of information that shouldn't be sent over the wire (such as private-key passphrases). The trust sigil I've picked is a small copy of the PuTTY icon, which is thematically nice (it can be read as if the PuTTY icon is the name of the speaker in a dialogue) and also convenient because we had that graphic available already on all platforms. (Though the contortions I had to go through to make the GTK 1 code draw it were quite annoying.) The trust sigil has the same dimensions as a CJK double-width character, i.e. it's 2 character cells wide by 1 high.
2019-03-10 14:37:11 +00:00
static void wintw_draw_trust_sigil(TermWin *tw, int x, int y)
{
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
WinGuiSeat *wgs = container_of(tw, WinGuiSeat, termwin);
windows/window.c: move more variables into WinGuiSeat. In commit f9e572595bb8cb6 I claimed that I'd removed very nearly all the global and static variables from windows/window.c. It turns out that this was wildly overoptimistic - I missed quite a few of them! I'm not quite sure how I managed that; my best guess is that I used an underpowered 'nm' command that failed to find some classes of variable. Some of the remaining function-scope statics were removed completely by commit afb3dab1e97a09f just now. In this commit, I've swept up some more and turn them into fields of WinGuiSeat, where they should have been moved last September. The (hopefully complete this time) list of remaining variables, generated by running this rune in the Windows build directory: nm windows/CMakeFiles/putty.dir/window.c.obj | grep -E '^([^ ]+)? *[bBcCdDgGsS] [^\.]' consists of the following variables which are legitimately global across the whole process and not related to a particular window: - 'hinst' and 'hprev', instance handles for Windows loadable modules - 'classname' in the terminal_window_class_a() and terminal_window_class_w() functions, which allocate a window class reusably - some pointers to Windows API functions retrieved via the DECL_WINDOWS_FUNCTION / GET_WINDOWS_FUNCTION system, such as p_AdjustWindowRectExForDpi and p_FlashWindowEx - some pointers to Windows API functions set up by assigning them at startup to the right one of the ANSI or Unicode version depending on the Windows version, e.g. sw_DefWindowProc and sw_DispatchMessage - 'unicode_window', a boolean flag set at the same time as those sw_Foo function pointers - 'sesslist', storing the last-retrieved version of the saved sessions menu - 'cursor_visible' in show_mouseptr() and 'forced_visible' in update_mouse_pointer(), each of which tracks the cumulative number of times that function has shown or hidden the mouse pointer, so as to manage its effect on the global state updated by ShowCursor - 'trust_icon', loaded from the executable's resources - 'wgslisthead', the list of all active WinGuiSeats - 'wm_mousewheel', the window-message id we use for mouse wheel events and the following which are nothing to do with our code: - '_OptionsStorage' in __local_stdio_printf_options() and __local_stdio_scanf_options(), which I'd never noticed before, but apparently are internal to a standard library header.
2023-05-27 13:59:20 +00:00
x *= wgs->font_width;
y *= wgs->font_height;
x += wgs->offset_width;
y += wgs->offset_height;
Add a TermWin method to draw a 'trust sigil'. This is not yet used by anything, but the idea is that it'll be a graphic in the terminal window that can't be replicated by a server sending escape sequences, and hence can be used as a reliable indication that the text on a particular terminal line is generated by PuTTY itself and not passed through from the server. This will make it possible to detect a malicious server trying to mimic local prompts to trick you out of information that shouldn't be sent over the wire (such as private-key passphrases). The trust sigil I've picked is a small copy of the PuTTY icon, which is thematically nice (it can be read as if the PuTTY icon is the name of the speaker in a dialogue) and also convenient because we had that graphic available already on all platforms. (Though the contortions I had to go through to make the GTK 1 code draw it were quite annoying.) The trust sigil has the same dimensions as a CJK double-width character, i.e. it's 2 character cells wide by 1 high.
2019-03-10 14:37:11 +00:00
windows/window.c: move more variables into WinGuiSeat. In commit f9e572595bb8cb6 I claimed that I'd removed very nearly all the global and static variables from windows/window.c. It turns out that this was wildly overoptimistic - I missed quite a few of them! I'm not quite sure how I managed that; my best guess is that I used an underpowered 'nm' command that failed to find some classes of variable. Some of the remaining function-scope statics were removed completely by commit afb3dab1e97a09f just now. In this commit, I've swept up some more and turn them into fields of WinGuiSeat, where they should have been moved last September. The (hopefully complete this time) list of remaining variables, generated by running this rune in the Windows build directory: nm windows/CMakeFiles/putty.dir/window.c.obj | grep -E '^([^ ]+)? *[bBcCdDgGsS] [^\.]' consists of the following variables which are legitimately global across the whole process and not related to a particular window: - 'hinst' and 'hprev', instance handles for Windows loadable modules - 'classname' in the terminal_window_class_a() and terminal_window_class_w() functions, which allocate a window class reusably - some pointers to Windows API functions retrieved via the DECL_WINDOWS_FUNCTION / GET_WINDOWS_FUNCTION system, such as p_AdjustWindowRectExForDpi and p_FlashWindowEx - some pointers to Windows API functions set up by assigning them at startup to the right one of the ANSI or Unicode version depending on the Windows version, e.g. sw_DefWindowProc and sw_DispatchMessage - 'unicode_window', a boolean flag set at the same time as those sw_Foo function pointers - 'sesslist', storing the last-retrieved version of the saved sessions menu - 'cursor_visible' in show_mouseptr() and 'forced_visible' in update_mouse_pointer(), each of which tracks the cumulative number of times that function has shown or hidden the mouse pointer, so as to manage its effect on the global state updated by ShowCursor - 'trust_icon', loaded from the executable's resources - 'wgslisthead', the list of all active WinGuiSeats - 'wm_mousewheel', the window-message id we use for mouse wheel events and the following which are nothing to do with our code: - '_OptionsStorage' in __local_stdio_printf_options() and __local_stdio_scanf_options(), which I'd never noticed before, but apparently are internal to a standard library header.
2023-05-27 13:59:20 +00:00
DrawIconEx(wgs->wintw_hdc, x, y, trust_icon,
wgs->font_width * 2, wgs->font_height, 0, NULL, DI_NORMAL);
Add a TermWin method to draw a 'trust sigil'. This is not yet used by anything, but the idea is that it'll be a graphic in the terminal window that can't be replicated by a server sending escape sequences, and hence can be used as a reliable indication that the text on a particular terminal line is generated by PuTTY itself and not passed through from the server. This will make it possible to detect a malicious server trying to mimic local prompts to trick you out of information that shouldn't be sent over the wire (such as private-key passphrases). The trust sigil I've picked is a small copy of the PuTTY icon, which is thematically nice (it can be read as if the PuTTY icon is the name of the speaker in a dialogue) and also convenient because we had that graphic available already on all platforms. (Though the contortions I had to go through to make the GTK 1 code draw it were quite annoying.) The trust sigil has the same dimensions as a CJK double-width character, i.e. it's 2 character cells wide by 1 high.
2019-03-10 14:37:11 +00:00
}
Three more patches from RDB: one to make Atomica work right, one to fiddle with the widths of characters in DBCS screen fonts, and (the big one) one to enable a mode in which resizing the window locks the terminal size and lets the font change, instead of vice versa. That should shut up a few feature requests! [originally from svn r1269]
2001-09-15 15:54:24 +00:00
/* This function gets the actual width of a character in the normal font.
*/
Remove the 'Frontend' type and replace it with a vtable. After the recent Seat and LogContext revamps, _nearly_ all the remaining uses of the type 'Frontend' were in terminal.c, which needs all sorts of interactions with the GUI window the terminal lives in, from the obvious (actually drawing text on the window, reading and writing the clipboard) to the obscure (minimising, maximising and moving the window in response to particular escape sequences). All of those functions are now provided by an abstraction called TermWin. The few remaining uses of Frontend after _that_ are internal to a particular platform directory, so as to spread the implementation of that particular kind of Frontend between multiple source files; so I've renamed all of those so that they take a more specifically named type that refers to the particular implementation rather than the general abstraction. So now the name 'Frontend' no longer exists in the code base at all, and everywhere one used to be used, it's completely clear whether it was operating in one of Frontend's three abstract roles (and if so, which), or whether it was specific to a particular implementation. Another type that's disappeared is 'Context', which used to be a typedef defined to something different on each platform, describing whatever short-lived resources were necessary to draw on the terminal window: the front end would provide a ready-made one when calling term_paint, and the terminal could request one with get_ctx/free_ctx if it wanted to do proactive window updates. Now that drawing context lives inside the TermWin itself, because there was never any need to have two of those contexts live at the same time. (Another minor API change is that the window-title functions - both reading and writing - have had a missing 'const' added to their char * parameters / return values.) I don't expect this change to enable any particularly interesting new functionality (in particular, I have no plans that need more than one implementation of TermWin in the same application). But it completes the tidying-up that began with the Seat and LogContext rework.
2018-10-25 17:44:04 +00:00
static int wintw_char_width(TermWin *tw, int uc)
{
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
WinGuiSeat *wgs = container_of(tw, WinGuiSeat, termwin);
Three more patches from RDB: one to make Atomica work right, one to fiddle with the widths of characters in DBCS screen fonts, and (the big one) one to enable a mode in which resizing the window locks the terminal size and lets the font change, instead of vice versa. That should shut up a few feature requests! [originally from svn r1269]
2001-09-15 15:54:24 +00:00
int ibuf = 0;
/* If the font max is the same as the font ave width then this
* function is a no-op.
*/
windows/window.c: move more variables into WinGuiSeat. In commit f9e572595bb8cb6 I claimed that I'd removed very nearly all the global and static variables from windows/window.c. It turns out that this was wildly overoptimistic - I missed quite a few of them! I'm not quite sure how I managed that; my best guess is that I used an underpowered 'nm' command that failed to find some classes of variable. Some of the remaining function-scope statics were removed completely by commit afb3dab1e97a09f just now. In this commit, I've swept up some more and turn them into fields of WinGuiSeat, where they should have been moved last September. The (hopefully complete this time) list of remaining variables, generated by running this rune in the Windows build directory: nm windows/CMakeFiles/putty.dir/window.c.obj | grep -E '^([^ ]+)? *[bBcCdDgGsS] [^\.]' consists of the following variables which are legitimately global across the whole process and not related to a particular window: - 'hinst' and 'hprev', instance handles for Windows loadable modules - 'classname' in the terminal_window_class_a() and terminal_window_class_w() functions, which allocate a window class reusably - some pointers to Windows API functions retrieved via the DECL_WINDOWS_FUNCTION / GET_WINDOWS_FUNCTION system, such as p_AdjustWindowRectExForDpi and p_FlashWindowEx - some pointers to Windows API functions set up by assigning them at startup to the right one of the ANSI or Unicode version depending on the Windows version, e.g. sw_DefWindowProc and sw_DispatchMessage - 'unicode_window', a boolean flag set at the same time as those sw_Foo function pointers - 'sesslist', storing the last-retrieved version of the saved sessions menu - 'cursor_visible' in show_mouseptr() and 'forced_visible' in update_mouse_pointer(), each of which tracks the cumulative number of times that function has shown or hidden the mouse pointer, so as to manage its effect on the global state updated by ShowCursor - 'trust_icon', loaded from the executable's resources - 'wgslisthead', the list of all active WinGuiSeats - 'wm_mousewheel', the window-message id we use for mouse wheel events and the following which are nothing to do with our code: - '_OptionsStorage' in __local_stdio_printf_options() and __local_stdio_scanf_options(), which I'd never noticed before, but apparently are internal to a standard library header.
2023-05-27 13:59:20 +00:00
if (!wgs->font_dualwidth) return 1;
Three more patches from RDB: one to make Atomica work right, one to fiddle with the widths of characters in DBCS screen fonts, and (the big one) one to enable a mode in which resizing the window locks the terminal size and lets the font change, instead of vice versa. That should shut up a few feature requests! [originally from svn r1269]
2001-09-15 15:54:24 +00:00
switch (uc & CSET_MASK) {
Re-engineering of terminal emulator, phase 1. The active terminal screen is no longer an array of `unsigned long' encoding 16-bit Unicode plus 16 attribute bits. Now it's an array of `termchar' structures, which currently have 32-bit Unicode and 32 attribute bits but which will probably expand further in future. To prevent bloat of the memory footprint, I've introduced a mostly RLE-like compression scheme for storing scrollback: each line is compressed into a compact (but hard to modify) form when it moves into the term->scrollback tree, and is temporarily decompressed when the user wants to scroll back over it. My initial tests suggest that this compression averages about 1/4 of the previous (32 bits per character cell) data size in typical output, which means this is an improvement even without counting the new ability to extend the information stored in each character cell. Another beneficial side effect is that the insane format in which Unicode was passed to front ends through do_text() has now been rendered sane. Testing is incomplete; this _may_ still have instabilities. Windows and Unix front ends both seem to work as far as I've looked, but I haven't yet looked very hard. The Mac front end I've edited (it seemed obvious how to change it) but I can't compile or test it. As an immediate functional effect, the terminal emulator now supports full 32-bit Unicode to whatever extent the host platform allows it to. For example, if you output a 4-or-more-byte UTF-8 character in Unix pterm, it will not display it properly, but it will correctly paste it back out in a UTF8_STRING selection. Windows is more restricted, sadly. [originally from svn r4609]
2004-10-13 11:50:16 +00:00
case CSET_ASCII:
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
uc = wgs->ucsdata.unitab_line[uc & 0xFF];
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
break;
Re-engineering of terminal emulator, phase 1. The active terminal screen is no longer an array of `unsigned long' encoding 16-bit Unicode plus 16 attribute bits. Now it's an array of `termchar' structures, which currently have 32-bit Unicode and 32 attribute bits but which will probably expand further in future. To prevent bloat of the memory footprint, I've introduced a mostly RLE-like compression scheme for storing scrollback: each line is compressed into a compact (but hard to modify) form when it moves into the term->scrollback tree, and is temporarily decompressed when the user wants to scroll back over it. My initial tests suggest that this compression averages about 1/4 of the previous (32 bits per character cell) data size in typical output, which means this is an improvement even without counting the new ability to extend the information stored in each character cell. Another beneficial side effect is that the insane format in which Unicode was passed to front ends through do_text() has now been rendered sane. Testing is incomplete; this _may_ still have instabilities. Windows and Unix front ends both seem to work as far as I've looked, but I haven't yet looked very hard. The Mac front end I've edited (it seemed obvious how to change it) but I can't compile or test it. As an immediate functional effect, the terminal emulator now supports full 32-bit Unicode to whatever extent the host platform allows it to. For example, if you output a 4-or-more-byte UTF-8 character in Unix pterm, it will not display it properly, but it will correctly paste it back out in a UTF8_STRING selection. Windows is more restricted, sadly. [originally from svn r4609]
2004-10-13 11:50:16 +00:00
case CSET_LINEDRW:
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
uc = wgs->ucsdata.unitab_xterm[uc & 0xFF];
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
break;
Re-engineering of terminal emulator, phase 1. The active terminal screen is no longer an array of `unsigned long' encoding 16-bit Unicode plus 16 attribute bits. Now it's an array of `termchar' structures, which currently have 32-bit Unicode and 32 attribute bits but which will probably expand further in future. To prevent bloat of the memory footprint, I've introduced a mostly RLE-like compression scheme for storing scrollback: each line is compressed into a compact (but hard to modify) form when it moves into the term->scrollback tree, and is temporarily decompressed when the user wants to scroll back over it. My initial tests suggest that this compression averages about 1/4 of the previous (32 bits per character cell) data size in typical output, which means this is an improvement even without counting the new ability to extend the information stored in each character cell. Another beneficial side effect is that the insane format in which Unicode was passed to front ends through do_text() has now been rendered sane. Testing is incomplete; this _may_ still have instabilities. Windows and Unix front ends both seem to work as far as I've looked, but I haven't yet looked very hard. The Mac front end I've edited (it seemed obvious how to change it) but I can't compile or test it. As an immediate functional effect, the terminal emulator now supports full 32-bit Unicode to whatever extent the host platform allows it to. For example, if you output a 4-or-more-byte UTF-8 character in Unix pterm, it will not display it properly, but it will correctly paste it back out in a UTF8_STRING selection. Windows is more restricted, sadly. [originally from svn r4609]
2004-10-13 11:50:16 +00:00
case CSET_SCOACS:
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
uc = wgs->ucsdata.unitab_scoacs[uc & 0xFF];
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
break;
Three more patches from RDB: one to make Atomica work right, one to fiddle with the widths of characters in DBCS screen fonts, and (the big one) one to enable a mode in which resizing the window locks the terminal size and lets the font change, instead of vice versa. That should shut up a few feature requests! [originally from svn r1269]
2001-09-15 15:54:24 +00:00
}
if (DIRECT_FONT(uc)) {
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
if (wgs->ucsdata.dbcs_screenfont) return 1;
Three more patches from RDB: one to make Atomica work right, one to fiddle with the widths of characters in DBCS screen fonts, and (the big one) one to enable a mode in which resizing the window locks the terminal size and lets the font change, instead of vice versa. That should shut up a few feature requests! [originally from svn r1269]
2001-09-15 15:54:24 +00:00
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
/* Speedup, I know of no font where ascii is the wrong width */
if ((uc&~CSET_MASK) >= ' ' && (uc&~CSET_MASK)<= '~')
return 1;
Three more patches from RDB: one to make Atomica work right, one to fiddle with the widths of characters in DBCS screen fonts, and (the big one) one to enable a mode in which resizing the window locks the terminal size and lets the font change, instead of vice versa. That should shut up a few feature requests! [originally from svn r1269]
2001-09-15 15:54:24 +00:00
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
if ( (uc & CSET_MASK) == CSET_ACP ) {
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
SelectObject(wgs->wintw_hdc, wgs->fonts[FONT_NORMAL]);
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
} else if ( (uc & CSET_MASK) == CSET_OEMCP ) {
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
another_font(wgs, FONT_OEM);
if (!wgs->fonts[FONT_OEM]) return 0;
Three more patches from RDB: one to make Atomica work right, one to fiddle with the widths of characters in DBCS screen fonts, and (the big one) one to enable a mode in which resizing the window locks the terminal size and lets the font change, instead of vice versa. That should shut up a few feature requests! [originally from svn r1269]
2001-09-15 15:54:24 +00:00
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
SelectObject(wgs->wintw_hdc, wgs->fonts[FONT_OEM]);
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
} else
return 0;
Three more patches from RDB: one to make Atomica work right, one to fiddle with the widths of characters in DBCS screen fonts, and (the big one) one to enable a mode in which resizing the window locks the terminal size and lets the font change, instead of vice versa. That should shut up a few feature requests! [originally from svn r1269]
2001-09-15 15:54:24 +00:00
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
if (GetCharWidth32(wgs->wintw_hdc, uc & ~CSET_MASK,
Remove the 'Frontend' type and replace it with a vtable. After the recent Seat and LogContext revamps, _nearly_ all the remaining uses of the type 'Frontend' were in terminal.c, which needs all sorts of interactions with the GUI window the terminal lives in, from the obvious (actually drawing text on the window, reading and writing the clipboard) to the obscure (minimising, maximising and moving the window in response to particular escape sequences). All of those functions are now provided by an abstraction called TermWin. The few remaining uses of Frontend after _that_ are internal to a particular platform directory, so as to spread the implementation of that particular kind of Frontend between multiple source files; so I've renamed all of those so that they take a more specifically named type that refers to the particular implementation rather than the general abstraction. So now the name 'Frontend' no longer exists in the code base at all, and everywhere one used to be used, it's completely clear whether it was operating in one of Frontend's three abstract roles (and if so, which), or whether it was specific to a particular implementation. Another type that's disappeared is 'Context', which used to be a typedef defined to something different on each platform, describing whatever short-lived resources were necessary to draw on the terminal window: the front end would provide a ready-made one when calling term_paint, and the terminal could request one with get_ctx/free_ctx if it wanted to do proactive window updates. Now that drawing context lives inside the TermWin itself, because there was never any need to have two of those contexts live at the same time. (Another minor API change is that the window-title functions - both reading and writing - have had a missing 'const' added to their char * parameters / return values.) I don't expect this change to enable any particularly interesting new functionality (in particular, I have no plans that need more than one implementation of TermWin in the same application). But it completes the tidying-up that began with the Seat and LogContext rework.
2018-10-25 17:44:04 +00:00
uc & ~CSET_MASK, &ibuf) != 1 &&
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
GetCharWidth(wgs->wintw_hdc, uc & ~CSET_MASK,
Remove the 'Frontend' type and replace it with a vtable. After the recent Seat and LogContext revamps, _nearly_ all the remaining uses of the type 'Frontend' were in terminal.c, which needs all sorts of interactions with the GUI window the terminal lives in, from the obvious (actually drawing text on the window, reading and writing the clipboard) to the obscure (minimising, maximising and moving the window in response to particular escape sequences). All of those functions are now provided by an abstraction called TermWin. The few remaining uses of Frontend after _that_ are internal to a particular platform directory, so as to spread the implementation of that particular kind of Frontend between multiple source files; so I've renamed all of those so that they take a more specifically named type that refers to the particular implementation rather than the general abstraction. So now the name 'Frontend' no longer exists in the code base at all, and everywhere one used to be used, it's completely clear whether it was operating in one of Frontend's three abstract roles (and if so, which), or whether it was specific to a particular implementation. Another type that's disappeared is 'Context', which used to be a typedef defined to something different on each platform, describing whatever short-lived resources were necessary to draw on the terminal window: the front end would provide a ready-made one when calling term_paint, and the terminal could request one with get_ctx/free_ctx if it wanted to do proactive window updates. Now that drawing context lives inside the TermWin itself, because there was never any need to have two of those contexts live at the same time. (Another minor API change is that the window-title functions - both reading and writing - have had a missing 'const' added to their char * parameters / return values.) I don't expect this change to enable any particularly interesting new functionality (in particular, I have no plans that need more than one implementation of TermWin in the same application). But it completes the tidying-up that began with the Seat and LogContext rework.
2018-10-25 17:44:04 +00:00
uc & ~CSET_MASK, &ibuf) != 1)
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
return 0;
Three more patches from RDB: one to make Atomica work right, one to fiddle with the widths of characters in DBCS screen fonts, and (the big one) one to enable a mode in which resizing the window locks the terminal size and lets the font change, instead of vice versa. That should shut up a few feature requests! [originally from svn r1269]
2001-09-15 15:54:24 +00:00
} else {
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
/* Speedup, I know of no font where ascii is the wrong width */
if (uc >= ' ' && uc <= '~') return 1;
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
SelectObject(wgs->wintw_hdc, wgs->fonts[FONT_NORMAL]);
if (GetCharWidth32W(wgs->wintw_hdc, uc, uc, &ibuf) == 1)
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
/* Okay that one worked */ ;
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
else if (GetCharWidthW(wgs->wintw_hdc, uc, uc, &ibuf) == 1)
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
/* This should work on 9x too, but it's "less accurate" */ ;
else
return 0;
Three more patches from RDB: one to make Atomica work right, one to fiddle with the widths of characters in DBCS screen fonts, and (the big one) one to enable a mode in which resizing the window locks the terminal size and lets the font change, instead of vice versa. That should shut up a few feature requests! [originally from svn r1269]
2001-09-15 15:54:24 +00:00
}
windows/window.c: move more variables into WinGuiSeat. In commit f9e572595bb8cb6 I claimed that I'd removed very nearly all the global and static variables from windows/window.c. It turns out that this was wildly overoptimistic - I missed quite a few of them! I'm not quite sure how I managed that; my best guess is that I used an underpowered 'nm' command that failed to find some classes of variable. Some of the remaining function-scope statics were removed completely by commit afb3dab1e97a09f just now. In this commit, I've swept up some more and turn them into fields of WinGuiSeat, where they should have been moved last September. The (hopefully complete this time) list of remaining variables, generated by running this rune in the Windows build directory: nm windows/CMakeFiles/putty.dir/window.c.obj | grep -E '^([^ ]+)? *[bBcCdDgGsS] [^\.]' consists of the following variables which are legitimately global across the whole process and not related to a particular window: - 'hinst' and 'hprev', instance handles for Windows loadable modules - 'classname' in the terminal_window_class_a() and terminal_window_class_w() functions, which allocate a window class reusably - some pointers to Windows API functions retrieved via the DECL_WINDOWS_FUNCTION / GET_WINDOWS_FUNCTION system, such as p_AdjustWindowRectExForDpi and p_FlashWindowEx - some pointers to Windows API functions set up by assigning them at startup to the right one of the ANSI or Unicode version depending on the Windows version, e.g. sw_DefWindowProc and sw_DispatchMessage - 'unicode_window', a boolean flag set at the same time as those sw_Foo function pointers - 'sesslist', storing the last-retrieved version of the saved sessions menu - 'cursor_visible' in show_mouseptr() and 'forced_visible' in update_mouse_pointer(), each of which tracks the cumulative number of times that function has shown or hidden the mouse pointer, so as to manage its effect on the global state updated by ShowCursor - 'trust_icon', loaded from the executable's resources - 'wgslisthead', the list of all active WinGuiSeats - 'wm_mousewheel', the window-message id we use for mouse wheel events and the following which are nothing to do with our code: - '_OptionsStorage' in __local_stdio_printf_options() and __local_stdio_scanf_options(), which I'd never noticed before, but apparently are internal to a standard library header.
2023-05-27 13:59:20 +00:00
ibuf += wgs->font_width / 2 -1;
ibuf /= wgs->font_width;
Three more patches from RDB: one to make Atomica work right, one to fiddle with the widths of characters in DBCS screen fonts, and (the big one) one to enable a mode in which resizing the window locks the terminal size and lets the font change, instead of vice versa. That should shut up a few feature requests! [originally from svn r1269]
2001-09-15 15:54:24 +00:00
return ibuf;
}
Find ToUnicodeEx() at run time, not load time. This restores PuTTY's backward compatibility to versions of Windows too old to have ToUnicodeEx in their system libraries, which was accidentally broken in 0.63. [originally from svn r10061]
2013-11-17 14:03:20 +00:00
DECL_WINDOWS_FUNCTION(static, BOOL, FlashWindowEx, (PFLASHWINFO));
DECL_WINDOWS_FUNCTION(static, BOOL, ToUnicodeEx,
(UINT, UINT, const BYTE *, LPWSTR, int, UINT, HKL));
Some support for wide-character filenames in Windows. The Windows version of the Filename structure now contains three versions of the pathname, in UTF-16, UTF-8 and the system code page. Callers can use whichever is most convenient. All uses of filenames for actually opening files now use the UTF-16 version, which means they can tolerate 'exotic' filenames, by which I mean those including Unicode characters outside the host system's CP_ACP default code page. Other uses of Filename structures inside the 'windows' subdirectory do something appropriate, e.g. when printing a filename inside a message box or a console message, we use the UTF-8 version of the filename with the UTF-8 version of the appropriate API. There are three remaining pieces to full Unicode filename support: One is that the cross-platform code has many calls to filename_to_str(), embodying the assumption that a file name can be reliably converted into the unspecified current character set; those will all need changing in some way. Another is that write_setting_filename(), in windows/storage.c, still saves filenames to the Registry as an ordinary REG_SZ in the system code page. So even if an exotic filename were stored in a Conf, that Conf couldn't round-trip via the Registry and back without corrupting that filename by coercing it back to a string that fits in CP_ACP and therefore doesn't represent the same file. This can't be fixed without a compatibility break in the storage format, and I don't want to make a minimal change in that area: if we're going to break compatibility, then we should break it good and hard (the Nanny Ogg principle), and devise a completely fresh storage representation that fixes as many other legacy problems as possible at the same time. So that's my plan, not yet started. The final point, much more obviously, is that we're still short of methods to _construct_ any Filename structures using a Unicode input string! It should now work to enter one in the GUI configurer (either by manual text input or via the file selector), but it won't round-trip through a save and load (as discussed above), and there's still no way to specify one on the command line (the groundwork is laid by commit 10e1ac7752de928 but not yet linked up). But this is a start.
2023-05-28 10:30:59 +00:00
DECL_WINDOWS_FUNCTION(static, BOOL, PlaySoundW, (LPCWSTR, HMODULE, DWORD));
DECL_WINDOWS_FUNCTION(static, BOOL, PlaySoundA, (LPCSTR, HMODULE, DWORD));
Find ToUnicodeEx() at run time, not load time. This restores PuTTY's backward compatibility to versions of Windows too old to have ToUnicodeEx in their system libraries, which was accidentally broken in 0.63. [originally from svn r10061]
2013-11-17 14:03:20 +00:00
static void init_winfuncs(void)
{
HMODULE user32_module = load_system32_dll("user32.dll");
Load winmm.dll (for PlaySound()) at run time. It's not on the default list of important system 'known DLLs' stored at HKLM\SYSTEM\CurrentControlSet\Control\Session Manager\KnownDLLs (see https://isc.sans.edu/forums/diary/DLL+hijacking+vulnerabilities/9445/ ) which apparently makes it exempt from Windows's standard DLL hijacking defence, i.e. if an executable links against it in the normal way then that executable will be vulnerable to DLL hijacking from a file called winmm.dll in the same directory as it. The solution is to load it dynamically _after_ we've locked down our DLL search path, which fortunately PuTTY's code base is well used to doing already for other DLLs.
2017-03-13 21:24:06 +00:00
HMODULE winmm_module = load_system32_dll("winmm.dll");
Windows 10: add per monitor DPI awareness support. On a system with 2 or more displays with different DPI settings, moving the PuTTY window from one display to another will make Windows resize the window using its "bitmap" strategy, stretching/compressing the text, making it fuzzy and harder to read. This change makes PuTTY resize its window and font size to accurately fit the DPI of the display it is on. We process the WM_DPICHANGED message, saving the new DPI, window size and position. We proceed to then reset the window, recreating the fonts using the new DPI and calculate the new window size and position based on the new font size, user display options (ie. with/without scrollbar) and the suggested window position provided by Windows. The suggested window size is usually not a perfect fit, therefore we must add a small offset to the new window position in order to avoid issues with repeated DPI changes while dragging the window from one display to another.
2021-03-29 15:31:13 +00:00
HMODULE shcore_module = load_system32_dll("shcore.dll");
Find ToUnicodeEx() at run time, not load time. This restores PuTTY's backward compatibility to versions of Windows too old to have ToUnicodeEx in their system libraries, which was accidentally broken in 0.63. [originally from svn r10061]
2013-11-17 14:03:20 +00:00
GET_WINDOWS_FUNCTION(user32_module, FlashWindowEx);
Reinstate use of ToUnicodeEx(). This was accidentally disabled by 73039b783, causing a regression in ability to type characters outside of the current Windows code page.
2017-04-29 11:07:37 +00:00
GET_WINDOWS_FUNCTION(user32_module, ToUnicodeEx);
Some support for wide-character filenames in Windows. The Windows version of the Filename structure now contains three versions of the pathname, in UTF-16, UTF-8 and the system code page. Callers can use whichever is most convenient. All uses of filenames for actually opening files now use the UTF-16 version, which means they can tolerate 'exotic' filenames, by which I mean those including Unicode characters outside the host system's CP_ACP default code page. Other uses of Filename structures inside the 'windows' subdirectory do something appropriate, e.g. when printing a filename inside a message box or a console message, we use the UTF-8 version of the filename with the UTF-8 version of the appropriate API. There are three remaining pieces to full Unicode filename support: One is that the cross-platform code has many calls to filename_to_str(), embodying the assumption that a file name can be reliably converted into the unspecified current character set; those will all need changing in some way. Another is that write_setting_filename(), in windows/storage.c, still saves filenames to the Registry as an ordinary REG_SZ in the system code page. So even if an exotic filename were stored in a Conf, that Conf couldn't round-trip via the Registry and back without corrupting that filename by coercing it back to a string that fits in CP_ACP and therefore doesn't represent the same file. This can't be fixed without a compatibility break in the storage format, and I don't want to make a minimal change in that area: if we're going to break compatibility, then we should break it good and hard (the Nanny Ogg principle), and devise a completely fresh storage representation that fixes as many other legacy problems as possible at the same time. So that's my plan, not yet started. The final point, much more obviously, is that we're still short of methods to _construct_ any Filename structures using a Unicode input string! It should now work to enter one in the GUI configurer (either by manual text input or via the file selector), but it won't round-trip through a save and load (as discussed above), and there's still no way to specify one on the command line (the groundwork is laid by commit 10e1ac7752de928 but not yet linked up). But this is a start.
2023-05-28 10:30:59 +00:00
GET_WINDOWS_FUNCTION(winmm_module, PlaySoundW);
GET_WINDOWS_FUNCTION(winmm_module, PlaySoundA);
Remove hard dependencies on multi-monitor functions. These are more functions that don't exist on all our supported legacy versions of Windows, so we need to follow the same policy as everywhere else, by trying to acquire them at run time and having a fallback if they aren't available.
2022-03-11 18:32:26 +00:00
GET_WINDOWS_FUNCTION_NO_TYPECHECK(user32_module, GetMonitorInfoA);
GET_WINDOWS_FUNCTION_NO_TYPECHECK(user32_module, MonitorFromPoint);
GET_WINDOWS_FUNCTION_NO_TYPECHECK(user32_module, MonitorFromWindow);
Windows 10: add per monitor DPI awareness support. On a system with 2 or more displays with different DPI settings, moving the PuTTY window from one display to another will make Windows resize the window using its "bitmap" strategy, stretching/compressing the text, making it fuzzy and harder to read. This change makes PuTTY resize its window and font size to accurately fit the DPI of the display it is on. We process the WM_DPICHANGED message, saving the new DPI, window size and position. We proceed to then reset the window, recreating the fonts using the new DPI and calculate the new window size and position based on the new font size, user display options (ie. with/without scrollbar) and the suggested window position provided by Windows. The suggested window size is usually not a perfect fit, therefore we must add a small offset to the new window position in order to avoid issues with repeated DPI changes while dragging the window from one display to another.
2021-03-29 15:31:13 +00:00
GET_WINDOWS_FUNCTION_NO_TYPECHECK(shcore_module, GetDpiForMonitor);
GET_WINDOWS_FUNCTION_NO_TYPECHECK(user32_module, GetSystemMetricsForDpi);
GET_WINDOWS_FUNCTION_NO_TYPECHECK(user32_module, AdjustWindowRectExForDpi);
Find ToUnicodeEx() at run time, not load time. This restores PuTTY's backward compatibility to versions of Windows too old to have ToUnicodeEx in their system libraries, which was accidentally broken in 0.63. [originally from svn r10061]
2013-11-17 14:03:20 +00:00
}
Initial checkin: beta 0.43 [originally from svn r11]
1999-01-08 13:02:13 +00:00
/*
Robert de Bath's Big Patch, part 1 [originally from svn r516]
2000-07-26 12:13:51 +00:00
* Translate a WM_(SYS)?KEY(UP|DOWN) message into a string of ASCII
Ctrl-Break now sends a Break signal (previously it was equivalent to Ctrl-C). [originally from svn r7295] [this svn revision also touched putty-wishlist]
2007-02-18 14:02:39 +00:00
* codes. Returns number of bytes used, zero to drop the message,
* -1 to forward the message to Windows, or another negative number
* to indicate a NUL-terminated "special" string.
Initial checkin: beta 0.43 [originally from svn r11]
1999-01-08 13:02:13 +00:00
*/
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
static int TranslateKey(WinGuiSeat *wgs, UINT message, WPARAM wParam,
LPARAM lParam, unsigned char *output)
Run entire source base through GNU indent to tidy up the varying coding styles of the various contributors! Woohoo! [originally from svn r1098]
2001-05-06 14:35:20 +00:00
{
Initial checkin: beta 0.43 [originally from svn r11]
1999-01-08 13:02:13 +00:00
BYTE keystate[256];
Convert a lot of 'int' variables to 'bool'. My normal habit these days, in new code, is to treat int and bool as _almost_ completely separate types. I'm still willing to use C's implicit test for zero on an integer (e.g. 'if (!blob.len)' is fine, no need to spell it out as blob.len != 0), but generally, if a variable is going to be conceptually a boolean, I like to declare it bool and assign to it using 'true' or 'false' rather than 0 or 1. PuTTY is an exception, because it predates the C99 bool, and I've stuck to its existing coding style even when adding new code to it. But it's been annoying me more and more, so now that I've decided C99 bool is an acceptable thing to require from our toolchain in the first place, here's a quite thorough trawl through the source doing 'boolification'. Many variables and function parameters are now typed as bool rather than int; many assignments of 0 or 1 to those variables are now spelled 'true' or 'false'. I managed this thorough conversion with the help of a custom clang plugin that I wrote to trawl the AST and apply heuristics to point out where things might want changing. So I've even managed to do a decent job on parts of the code I haven't looked at in years! To make the plugin's work easier, I pushed platform front ends generally in the direction of using standard 'bool' in preference to platform-specific boolean types like Windows BOOL or GTK's gboolean; I've left the platform booleans in places they _have_ to be for the platform APIs to work right, but variables only used by my own code have been converted wherever I found them. In a few places there are int values that look very like booleans in _most_ of the places they're used, but have a rarely-used third value, or a distinction between different nonzero values that most users don't care about. In these cases, I've _removed_ uses of 'true' and 'false' for the return values, to emphasise that there's something more subtle going on than a simple boolean answer: - the 'multisel' field in dialog.h's list box structure, for which the GTK front end in particular recognises a difference between 1 and 2 but nearly everything else treats as boolean - the 'urgent' parameter to plug_receive, where 1 vs 2 tells you something about the specific location of the urgent pointer, but most clients only care about 0 vs 'something nonzero' - the return value of wc_match, where -1 indicates a syntax error in the wildcard. - the return values from SSH-1 RSA-key loading functions, which use -1 for 'wrong passphrase' and 0 for all other failures (so any caller which already knows it's not loading an _encrypted private_ key can treat them as boolean) - term->esc_query, and the 'query' parameter in toggle_mode in terminal.c, which _usually_ hold 0 for ESC[123h or 1 for ESC[?123h, but can also hold -1 for some other intervening character that we don't support. In a few places there's an integer that I haven't turned into a bool even though it really _can_ only take values 0 or 1 (and, as above, tried to make the call sites consistent in not calling those values true and false), on the grounds that I thought it would make it more confusing to imply that the 0 value was in some sense 'negative' or bad and the 1 positive or good: - the return value of plug_accepting uses the POSIXish convention of 0=success and nonzero=error; I think if I made it bool then I'd also want to reverse its sense, and that's a job for a separate piece of work. - the 'screen' parameter to lineptr() in terminal.c, where 0 and 1 represent the default and alternate screens. There's no obvious reason why one of those should be considered 'true' or 'positive' or 'success' - they're just indices - so I've left it as int. ssh_scp_recv had particularly confusing semantics for its previous int return value: its call sites used '<= 0' to check for error, but it never actually returned a negative number, just 0 or 1. Now the function and its call sites agree that it's a bool. In a couple of places I've renamed variables called 'ret', because I don't like that name any more - it's unclear whether it means the return value (in preparation) for the _containing_ function or the return value received from a subroutine call, and occasionally I've accidentally used the same variable for both and introduced a bug. So where one of those got in my way, I've renamed it to 'toret' or 'retd' (the latter short for 'returned') in line with my usual modern practice, but I haven't done a thorough job of finding all of them. Finally, one amusing side effect of doing this is that I've had to separate quite a few chained assignments. It used to be perfectly fine to write 'a = b = c = TRUE' when a,b,c were int and TRUE was just a the 'true' defined by stdbool.h, that idiom provokes a warning from gcc: 'suggest parentheses around assignment used as truth value'!
2018-11-02 19:23:19 +00:00
int scan, shift_state;
bool left_alt = false, key_down;
Centralise key escape sequences into terminal.c. A long time ago, in commit 4d77b6567, I moved the generation of the arrow-key escape sequences into a function format_arrow_key(). Mostly the reason for that was a special purpose I had in mind at the time which involved auto-generating the same sequences in response to things other than a keypress, but I always thought it would be nice to centralise a lot more of PuTTY's complicated keyboard handling in the same way - at least the handling of the function keys and their numerous static and dynamic config options. In this year's general spirit of tidying up and refactoring, I think it's finally time. So here I introduce three more centralised functions for dealing with the numbered function keys, the small keypad (Ins, Home, PgUp etc) and the numeric keypad. Lots of horrible and duplicated code from the key handling functions in window.c and gtkwin.c is now more sensibly centralised: each platform keyboard handler concerns itself with the local format of a keyboard event and platform-specific enumeration of key codes, and once it's decided what the logical key press actually _is_, it hands off to the new functions in terminal.c to generate the appropriate escape code. Mostly this is intended to be a refactoring without functional change, leaving the keyboard handling how it's always been. But in cases where the Windows and GTK handlers were accidentally inconsistent, I've fixed the inconsistency rather than carefully keeping both sides how they were. Known consistency fixes: - swapping the arrow keys between normal (ESC [ A) and application (ESC O A) is now done by pressing Ctrl with them, and _not_ by pressing Shift. That was how it was always supposed to work, and how it's worked on GTK all along, but on Windows it's been done by Shift as well since 2010, due to a bug at the call site of format_arrow_key() introduced when I originally wrote that function. - in Xterm function key mode plus application keypad mode, the /*- keys on the numeric keypad now send ESC O {o,j,m} in place of ESC O {Q,R,S}. That's how the Windows keyboard handler has worked all along (it was a deliberate behaviour tweak for the Xterm-like function key mode, because in that mode ESC O {Q,R,S} are generated by F2-F4). But the GTK keyboard handler omitted that particular special case and was still sending ESC O {Q,R,S} for those keys in all application keypad modes. - also in Xterm function key mode plus app keypad mode, we only generates the app-keypad escape sequences if Num Lock is on; with Num Lock off, the numeric keypad becomes arrow keys and Home/End/etc, just as it would in non-app-keypad mode. Windows has done this all along, but again, GTK lacked that special case.
2018-12-08 08:25:32 +00:00
int r, i;
Run entire source base through GNU indent to tidy up the varying coding styles of the various contributors! Woohoo! [originally from svn r1098]
2001-05-06 14:35:20 +00:00
unsigned char *p = output;
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
int funky_type = conf_get_int(wgs->conf, CONF_funky_type);
bool no_applic_k = conf_get_bool(wgs->conf, CONF_no_applic_k);
bool ctrlaltkeys = conf_get_bool(wgs->conf, CONF_ctrlaltkeys);
bool nethack_keypad = conf_get_bool(wgs->conf, CONF_nethack_keypad);
Fix handling of Return and keypad Enter. The recent rewriting in both the GTK and Windows keyboard handlers left the keypad 'Enter' key in a bad state, when no override is enabled that causes it to generate an escape sequence. On Windows, a series of fallbacks was causing it to generate \r regardless of configuration, whereas in Telnet mode it should default to generating the special Telnet new-line sequence, and in response to ESC[20h (enabling term->cr_lf_return) it should generate \r\n. On GTK, it wasn't generating anything _at all_, and also, I can't see any evidence that the GTK keyboard handler had ever remembered to implement the cr_lf_return mode. Now Keypad Enter in non-escape-sequence mode should behave just like Return, on both platforms.
2019-04-15 19:43:10 +00:00
char keypad_key = '\0';
Initial checkin: beta 0.43 [originally from svn r11]
1999-01-08 13:02:13 +00:00
Kestutis Kupciunas's Lithuanian-friendliness patch to TranslateKey [originally from svn r847]
2001-01-07 18:28:01 +00:00
HKL kbd_layout = GetKeyboardLayout(0);
Robert de Bath's Big Patch, part 1 [originally from svn r516]
2000-07-26 12:13:51 +00:00
r = GetKeyboardState(keystate);
Run entire source base through GNU indent to tidy up the varying coding styles of the various contributors! Woohoo! [originally from svn r1098]
2001-05-06 14:35:20 +00:00
if (!r)
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
memset(keystate, 0, sizeof(keystate));
Run entire source base through GNU indent to tidy up the varying coding styles of the various contributors! Woohoo! [originally from svn r1098]
2001-05-06 14:35:20 +00:00
else {
Robert de Bath's big patch: - cope with strange WinSock wrappers not supporting SIOCATMARK - define yet more terminal compatibility modes - support UK-ASCII (just like US-ASCII but # is a sterling sign) - support connection keepalives at a configurable interval [originally from svn r692]
2000-10-09 12:53:32 +00:00
#if 0
RDB's Unicode patch. Fonts are now used in Unicode mode where possible and we have a single unified means of trying to display any Unicode code point. Instead of the various ad-hoc translation modes we had before, we now have a single `codepage' option which allows us to treat the incoming (and outgoing) text as any given character set, and locally we map that to Unicode and back. [originally from svn r1110]
2001-05-10 08:34:20 +00:00
#define SHOW_TOASCII_RESULT
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
{ /* Tell us all about key events */
static BYTE oldstate[256];
static int first = 1;
static int scan;
int ch;
if (first)
memcpy(oldstate, keystate, sizeof(oldstate));
first = 0;
if ((HIWORD(lParam) & (KF_UP | KF_REPEAT)) == KF_REPEAT) {
debug("+");
} else if ((HIWORD(lParam) & KF_UP)
&& scan == (HIWORD(lParam) & 0xFF)) {
debug(". U");
} else {
debug(".\n");
if (wParam >= VK_F1 && wParam <= VK_F20)
debug("K_F%d", wParam + 1 - VK_F1);
else
switch (wParam) {
case VK_SHIFT:
debug("SHIFT");
break;
case VK_CONTROL:
debug("CTRL");
break;
case VK_MENU:
debug("ALT");
break;
default:
debug("VK_%02x", wParam);
}
if (message == WM_SYSKEYDOWN || message == WM_SYSKEYUP)
debug("*");
debug(", S%02x", scan = (HIWORD(lParam) & 0xFF));
ch = MapVirtualKeyEx(wParam, 2, kbd_layout);
if (ch >= ' ' && ch <= '~')
debug(", '%c'", ch);
else if (ch)
debug(", $%02x", ch);
if ((keystate[VK_SHIFT] & 0x80) != 0)
debug(", S");
if ((keystate[VK_CONTROL] & 0x80) != 0)
debug(", C");
if ((HIWORD(lParam) & KF_EXTENDED))
debug(", E");
if ((HIWORD(lParam) & KF_UP))
debug(", U");
}
if ((HIWORD(lParam) & (KF_UP | KF_REPEAT)) == KF_REPEAT);
else if ((HIWORD(lParam) & KF_UP))
oldstate[wParam & 0xFF] ^= 0x80;
else
oldstate[wParam & 0xFF] ^= 0x81;
for (ch = 0; ch < 256; ch++)
if (oldstate[ch] != keystate[ch])
debug(", M%02x=%02x", ch, keystate[ch]);
memcpy(oldstate, keystate, sizeof(oldstate));
}
Robert de Bath's big patch: - cope with strange WinSock wrappers not supporting SIOCATMARK - define yet more terminal compatibility modes - support UK-ASCII (just like US-ASCII but # is a sterling sign) - support connection keepalives at a configurable interval [originally from svn r692]
2000-10-09 12:53:32 +00:00
#endif
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
if (wParam == VK_MENU && (HIWORD(lParam) & KF_EXTENDED)) {
keystate[VK_RMENU] = keystate[VK_MENU];
}
AltGr should now work again even when Compose key disabled [originally from svn r838]
2001-01-07 14:30:00 +00:00
Robert de Bath's Big Patch, part 1 [originally from svn r516]
2000-07-26 12:13:51 +00:00
Fix a batch of typos in comments and docs.
2022-01-03 06:38:07 +00:00
/* Nastiness with NUMLock - Shift-NUMLock is left alone though */
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
if ((funky_type == FUNKY_VT400 ||
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
(funky_type <= FUNKY_LINUX && wgs->term->app_keypad_keys &&
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
!no_applic_k))
&& wParam == VK_NUMLOCK && !(keystate[VK_SHIFT] & 0x80)) {
Robert de Bath's Big Patch, part 1 [originally from svn r516]
2000-07-26 12:13:51 +00:00
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
wParam = VK_EXECUTE;
Robert de Bath's Big Patch, part 1 [originally from svn r516]
2000-07-26 12:13:51 +00:00
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
/* UnToggle NUMLock */
if ((HIWORD(lParam) & (KF_UP | KF_REPEAT)) == 0)
keystate[VK_NUMLOCK] ^= 1;
}
Robert de Bath's Big Patch, part 1 [originally from svn r516]
2000-07-26 12:13:51 +00:00
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
/* And write back the 'adjusted' state */
SetKeyboardState(keystate);
Robert de Bath's Big Patch, part 1 [originally from svn r516]
2000-07-26 12:13:51 +00:00
}
/* Disable Auto repeat if required */
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
if (wgs->term->repeat_off &&
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
(HIWORD(lParam) & (KF_UP | KF_REPEAT)) == KF_REPEAT)
return 0;
Robert de Bath's Big Patch, part 1 [originally from svn r516]
2000-07-26 12:13:51 +00:00
Run entire source base through GNU indent to tidy up the varying coding styles of the various contributors! Woohoo! [originally from svn r1098]
2001-05-06 14:35:20 +00:00
if ((HIWORD(lParam) & KF_ALTDOWN) && (keystate[VK_RMENU] & 0x80) == 0)
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
left_alt = true;
Robert de Bath's Big Patch, part 1 [originally from svn r516]
2000-07-26 12:13:51 +00:00
Run entire source base through GNU indent to tidy up the varying coding styles of the various contributors! Woohoo! [originally from svn r1098]
2001-05-06 14:35:20 +00:00
key_down = ((HIWORD(lParam) & KF_UP) == 0);
Robert de Bath's Big Patch, part 1 [originally from svn r516]
2000-07-26 12:13:51 +00:00
Keyboard handling patch from RDB: the Windows Application key is now always Compose (we have no better use for it), and Ctrl-Alt can be made to act like AltGr (but it's never Compose even when AltGr is). [originally from svn r1033]
2001-04-09 12:52:43 +00:00
/* Make sure Ctrl-ALT is not the same as AltGr for ToAscii unless told. */
Run entire source base through GNU indent to tidy up the varying coding styles of the various contributors! Woohoo! [originally from svn r1098]
2001-05-06 14:35:20 +00:00
if (left_alt && (keystate[VK_CONTROL] & 0x80)) {
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
if (ctrlaltkeys)
keystate[VK_MENU] = 0;
else {
keystate[VK_RMENU] = 0x80;
left_alt = false;
}
Keyboard handling patch from RDB: the Windows Application key is now always Compose (we have no better use for it), and Ctrl-Alt can be made to act like AltGr (but it's never Compose even when AltGr is). [originally from svn r1033]
2001-04-09 12:52:43 +00:00
}
Robert de Bath's Big Patch, part 1 [originally from svn r516]
2000-07-26 12:13:51 +00:00
scan = (HIWORD(lParam) & (KF_UP | KF_EXTENDED | 0xFF));
Run entire source base through GNU indent to tidy up the varying coding styles of the various contributors! Woohoo! [originally from svn r1098]
2001-05-06 14:35:20 +00:00
shift_state = ((keystate[VK_SHIFT] & 0x80) != 0)
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
+ ((keystate[VK_CONTROL] & 0x80) != 0) * 2;
Initial checkin: beta 0.43 [originally from svn r11]
1999-01-08 13:02:13 +00:00
Keyboard handling patch from RDB: the Windows Application key is now always Compose (we have no better use for it), and Ctrl-Alt can be made to act like AltGr (but it's never Compose even when AltGr is). [originally from svn r1033]
2001-04-09 12:52:43 +00:00
/* Note if AltGr was pressed and if it was used as a compose key */
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
if (!wgs->compose_state) {
windows/window.c: move more variables into WinGuiSeat. In commit f9e572595bb8cb6 I claimed that I'd removed very nearly all the global and static variables from windows/window.c. It turns out that this was wildly overoptimistic - I missed quite a few of them! I'm not quite sure how I managed that; my best guess is that I used an underpowered 'nm' command that failed to find some classes of variable. Some of the remaining function-scope statics were removed completely by commit afb3dab1e97a09f just now. In this commit, I've swept up some more and turn them into fields of WinGuiSeat, where they should have been moved last September. The (hopefully complete this time) list of remaining variables, generated by running this rune in the Windows build directory: nm windows/CMakeFiles/putty.dir/window.c.obj | grep -E '^([^ ]+)? *[bBcCdDgGsS] [^\.]' consists of the following variables which are legitimately global across the whole process and not related to a particular window: - 'hinst' and 'hprev', instance handles for Windows loadable modules - 'classname' in the terminal_window_class_a() and terminal_window_class_w() functions, which allocate a window class reusably - some pointers to Windows API functions retrieved via the DECL_WINDOWS_FUNCTION / GET_WINDOWS_FUNCTION system, such as p_AdjustWindowRectExForDpi and p_FlashWindowEx - some pointers to Windows API functions set up by assigning them at startup to the right one of the ANSI or Unicode version depending on the Windows version, e.g. sw_DefWindowProc and sw_DispatchMessage - 'unicode_window', a boolean flag set at the same time as those sw_Foo function pointers - 'sesslist', storing the last-retrieved version of the saved sessions menu - 'cursor_visible' in show_mouseptr() and 'forced_visible' in update_mouse_pointer(), each of which tracks the cumulative number of times that function has shown or hidden the mouse pointer, so as to manage its effect on the global state updated by ShowCursor - 'trust_icon', loaded from the executable's resources - 'wgslisthead', the list of all active WinGuiSeats - 'wm_mousewheel', the window-message id we use for mouse wheel events and the following which are nothing to do with our code: - '_OptionsStorage' in __local_stdio_printf_options() and __local_stdio_scanf_options(), which I'd never noticed before, but apparently are internal to a standard library header.
2023-05-27 13:59:20 +00:00
wgs->compose_keycode = 0x100;
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
if (conf_get_bool(wgs->conf, CONF_compose_key)) {
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
if (wParam == VK_MENU && (HIWORD(lParam) & KF_EXTENDED))
windows/window.c: move more variables into WinGuiSeat. In commit f9e572595bb8cb6 I claimed that I'd removed very nearly all the global and static variables from windows/window.c. It turns out that this was wildly overoptimistic - I missed quite a few of them! I'm not quite sure how I managed that; my best guess is that I used an underpowered 'nm' command that failed to find some classes of variable. Some of the remaining function-scope statics were removed completely by commit afb3dab1e97a09f just now. In this commit, I've swept up some more and turn them into fields of WinGuiSeat, where they should have been moved last September. The (hopefully complete this time) list of remaining variables, generated by running this rune in the Windows build directory: nm windows/CMakeFiles/putty.dir/window.c.obj | grep -E '^([^ ]+)? *[bBcCdDgGsS] [^\.]' consists of the following variables which are legitimately global across the whole process and not related to a particular window: - 'hinst' and 'hprev', instance handles for Windows loadable modules - 'classname' in the terminal_window_class_a() and terminal_window_class_w() functions, which allocate a window class reusably - some pointers to Windows API functions retrieved via the DECL_WINDOWS_FUNCTION / GET_WINDOWS_FUNCTION system, such as p_AdjustWindowRectExForDpi and p_FlashWindowEx - some pointers to Windows API functions set up by assigning them at startup to the right one of the ANSI or Unicode version depending on the Windows version, e.g. sw_DefWindowProc and sw_DispatchMessage - 'unicode_window', a boolean flag set at the same time as those sw_Foo function pointers - 'sesslist', storing the last-retrieved version of the saved sessions menu - 'cursor_visible' in show_mouseptr() and 'forced_visible' in update_mouse_pointer(), each of which tracks the cumulative number of times that function has shown or hidden the mouse pointer, so as to manage its effect on the global state updated by ShowCursor - 'trust_icon', loaded from the executable's resources - 'wgslisthead', the list of all active WinGuiSeats - 'wm_mousewheel', the window-message id we use for mouse wheel events and the following which are nothing to do with our code: - '_OptionsStorage' in __local_stdio_printf_options() and __local_stdio_scanf_options(), which I'd never noticed before, but apparently are internal to a standard library header.
2023-05-27 13:59:20 +00:00
wgs->compose_keycode = wParam;
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
}
if (wParam == VK_APPS)
windows/window.c: move more variables into WinGuiSeat. In commit f9e572595bb8cb6 I claimed that I'd removed very nearly all the global and static variables from windows/window.c. It turns out that this was wildly overoptimistic - I missed quite a few of them! I'm not quite sure how I managed that; my best guess is that I used an underpowered 'nm' command that failed to find some classes of variable. Some of the remaining function-scope statics were removed completely by commit afb3dab1e97a09f just now. In this commit, I've swept up some more and turn them into fields of WinGuiSeat, where they should have been moved last September. The (hopefully complete this time) list of remaining variables, generated by running this rune in the Windows build directory: nm windows/CMakeFiles/putty.dir/window.c.obj | grep -E '^([^ ]+)? *[bBcCdDgGsS] [^\.]' consists of the following variables which are legitimately global across the whole process and not related to a particular window: - 'hinst' and 'hprev', instance handles for Windows loadable modules - 'classname' in the terminal_window_class_a() and terminal_window_class_w() functions, which allocate a window class reusably - some pointers to Windows API functions retrieved via the DECL_WINDOWS_FUNCTION / GET_WINDOWS_FUNCTION system, such as p_AdjustWindowRectExForDpi and p_FlashWindowEx - some pointers to Windows API functions set up by assigning them at startup to the right one of the ANSI or Unicode version depending on the Windows version, e.g. sw_DefWindowProc and sw_DispatchMessage - 'unicode_window', a boolean flag set at the same time as those sw_Foo function pointers - 'sesslist', storing the last-retrieved version of the saved sessions menu - 'cursor_visible' in show_mouseptr() and 'forced_visible' in update_mouse_pointer(), each of which tracks the cumulative number of times that function has shown or hidden the mouse pointer, so as to manage its effect on the global state updated by ShowCursor - 'trust_icon', loaded from the executable's resources - 'wgslisthead', the list of all active WinGuiSeats - 'wm_mousewheel', the window-message id we use for mouse wheel events and the following which are nothing to do with our code: - '_OptionsStorage' in __local_stdio_printf_options() and __local_stdio_scanf_options(), which I'd never noticed before, but apparently are internal to a standard library header.
2023-05-27 13:59:20 +00:00
wgs->compose_keycode = wParam;
Keyboard handling patch from RDB: the Windows Application key is now always Compose (we have no better use for it), and Ctrl-Alt can be made to act like AltGr (but it's never Compose even when AltGr is). [originally from svn r1033]
2001-04-09 12:52:43 +00:00
}
windows/window.c: move more variables into WinGuiSeat. In commit f9e572595bb8cb6 I claimed that I'd removed very nearly all the global and static variables from windows/window.c. It turns out that this was wildly overoptimistic - I missed quite a few of them! I'm not quite sure how I managed that; my best guess is that I used an underpowered 'nm' command that failed to find some classes of variable. Some of the remaining function-scope statics were removed completely by commit afb3dab1e97a09f just now. In this commit, I've swept up some more and turn them into fields of WinGuiSeat, where they should have been moved last September. The (hopefully complete this time) list of remaining variables, generated by running this rune in the Windows build directory: nm windows/CMakeFiles/putty.dir/window.c.obj | grep -E '^([^ ]+)? *[bBcCdDgGsS] [^\.]' consists of the following variables which are legitimately global across the whole process and not related to a particular window: - 'hinst' and 'hprev', instance handles for Windows loadable modules - 'classname' in the terminal_window_class_a() and terminal_window_class_w() functions, which allocate a window class reusably - some pointers to Windows API functions retrieved via the DECL_WINDOWS_FUNCTION / GET_WINDOWS_FUNCTION system, such as p_AdjustWindowRectExForDpi and p_FlashWindowEx - some pointers to Windows API functions set up by assigning them at startup to the right one of the ANSI or Unicode version depending on the Windows version, e.g. sw_DefWindowProc and sw_DispatchMessage - 'unicode_window', a boolean flag set at the same time as those sw_Foo function pointers - 'sesslist', storing the last-retrieved version of the saved sessions menu - 'cursor_visible' in show_mouseptr() and 'forced_visible' in update_mouse_pointer(), each of which tracks the cumulative number of times that function has shown or hidden the mouse pointer, so as to manage its effect on the global state updated by ShowCursor - 'trust_icon', loaded from the executable's resources - 'wgslisthead', the list of all active WinGuiSeats - 'wm_mousewheel', the window-message id we use for mouse wheel events and the following which are nothing to do with our code: - '_OptionsStorage' in __local_stdio_printf_options() and __local_stdio_scanf_options(), which I'd never noticed before, but apparently are internal to a standard library header.
2023-05-27 13:59:20 +00:00
if (wParam == wgs->compose_keycode) {
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
if (wgs->compose_state == 0 &&
Formatting: miscellaneous. This patch fixes a few other whitespace and formatting issues which were pointed out by the bulk-reindent or which I spotted in passing, some involving manual editing to break lines more nicely. I think the weirdest hunk in here is the one in windows/window.c TranslateKey() where _half_ of an assignment statement inside an 'if' was on the same line as the trailing paren of the if condition. No idea at all how that one managed to happen!
2022-08-03 19:48:46 +00:00
(HIWORD(lParam) & (KF_UP | KF_REPEAT)) == 0)
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
wgs->compose_state = 1;
else if (wgs->compose_state == 1 && (HIWORD(lParam) & KF_UP))
wgs->compose_state = 2;
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
else
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
wgs->compose_state = 0;
} else if (wgs->compose_state == 1 && wParam != VK_CONTROL)
wgs->compose_state = 0;
Keyboard handling patch from RDB: the Windows Application key is now always Compose (we have no better use for it), and Ctrl-Alt can be made to act like AltGr (but it's never Compose even when AltGr is). [originally from svn r1033]
2001-04-09 12:52:43 +00:00
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
if (wgs->compose_state > 1 && left_alt)
wgs->compose_state = 0;
Add AltGr support at last! Thanks to <andre@via.ecp.fr> for the technique if not all of the details. [originally from svn r92]
1999-03-12 17:14:06 +00:00
Robert de Bath's Big Patch, part 1 [originally from svn r516]
2000-07-26 12:13:51 +00:00
/* Sanitize the number pad if not using a PC NumPad */
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
if (left_alt || (wgs->term->app_keypad_keys && !no_applic_k
&& funky_type != FUNKY_XTERM) ||
funky_type == FUNKY_VT400 || nethack_keypad || wgs->compose_state) {
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
if ((HIWORD(lParam) & KF_EXTENDED) == 0) {
int nParam = 0;
switch (wParam) {
case VK_INSERT:
nParam = VK_NUMPAD0;
break;
case VK_END:
nParam = VK_NUMPAD1;
break;
case VK_DOWN:
nParam = VK_NUMPAD2;
break;
case VK_NEXT:
nParam = VK_NUMPAD3;
break;
case VK_LEFT:
nParam = VK_NUMPAD4;
break;
case VK_CLEAR:
nParam = VK_NUMPAD5;
break;
case VK_RIGHT:
nParam = VK_NUMPAD6;
break;
case VK_HOME:
nParam = VK_NUMPAD7;
break;
case VK_UP:
nParam = VK_NUMPAD8;
break;
case VK_PRIOR:
nParam = VK_NUMPAD9;
break;
case VK_DELETE:
nParam = VK_DECIMAL;
break;
}
if (nParam) {
if (keystate[VK_NUMLOCK] & 1)
shift_state |= 1;
wParam = nParam;
}
}
Oops - Shift-PgUp/PgDn conflicted with NetHack mode [originally from svn r285]
1999-11-09 11:19:34 +00:00
}
Robert de Bath's Big Patch, part 1 [originally from svn r516]
2000-07-26 12:13:51 +00:00
/* If a key is pressed and AltGr is not active */
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
if (key_down && (keystate[VK_RMENU] & 0x80) == 0 && !wgs->compose_state) {
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
/* Okay, prepare for most alts then ... */
if (left_alt)
*p++ = '\033';
/* Lets see if it's a pattern we know all about ... */
if (wParam == VK_PRIOR && shift_state == 1) {
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
SendMessage(wgs->term_hwnd, WM_VSCROLL, SB_PAGEUP, 0);
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
return 0;
}
ctrl-shift-page-up/down to top or bottom of scrollback Just a small patch, that I find really useful.
2017-11-03 14:31:10 +00:00
if (wParam == VK_PRIOR && shift_state == 3) { /* ctrl-shift-pageup */
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
SendMessage(wgs->term_hwnd, WM_VSCROLL, SB_TOP, 0);
ctrl-shift-page-up/down to top or bottom of scrollback Just a small patch, that I find really useful.
2017-11-03 14:31:10 +00:00
return 0;
}
if (wParam == VK_NEXT && shift_state == 3) { /* ctrl-shift-pagedown */
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
SendMessage(wgs->term_hwnd, WM_VSCROLL, SB_BOTTOM, 0);
ctrl-shift-page-up/down to top or bottom of scrollback Just a small patch, that I find really useful.
2017-11-03 14:31:10 +00:00
return 0;
}
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
if (wParam == VK_PRIOR && shift_state == 2) {
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
SendMessage(wgs->term_hwnd, WM_VSCROLL, SB_LINEUP, 0);
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
return 0;
}
if (wParam == VK_NEXT && shift_state == 1) {
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
SendMessage(wgs->term_hwnd, WM_VSCROLL, SB_PAGEDOWN, 0);
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
return 0;
}
if (wParam == VK_NEXT && shift_state == 2) {
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
SendMessage(wgs->term_hwnd, WM_VSCROLL, SB_LINEDOWN, 0);
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
return 0;
}
if ((wParam == VK_PRIOR || wParam == VK_NEXT) && shift_state == 3) {
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
term_scroll_to_selection(wgs->term, (wParam == VK_PRIOR ? 0 : 1));
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
return 0;
}
if (wParam == VK_INSERT && shift_state == 2) {
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
switch (conf_get_int(wgs->conf, CONF_ctrlshiftins)) {
Add GUI configuration for choice of clipboards. On all platforms, you can now configure which clipboard the mouse pastes from, which clipboard Ctrl-Ins and Shift-Ins access, and which Ctrl-Shift-C and Ctrl-Shift-V access. In each case, the options are: - nothing at all - a clipboard which is implicitly written by the act of mouse selection (the PRIMARY selection on X, CLIP_LOCAL everywhere else) - the standard clipboard written by explicit copy/paste UI actions (CLIPBOARD on X, the unique system clipboard elsewhere). Also, you can control whether selecting text with the mouse _also_ writes to the explicitly accessed clipboard. The wording of the various messages changes between platforms, but the basic UI shape is the same everywhere.
2017-12-10 17:16:50 +00:00
case CLIPUI_IMPLICIT:
break; /* no need to re-copy to CLIP_LOCAL */
case CLIPUI_EXPLICIT:
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
term_request_copy(wgs->term, clips_system,
lenof(clips_system));
Add GUI configuration for choice of clipboards. On all platforms, you can now configure which clipboard the mouse pastes from, which clipboard Ctrl-Ins and Shift-Ins access, and which Ctrl-Shift-C and Ctrl-Shift-V access. In each case, the options are: - nothing at all - a clipboard which is implicitly written by the act of mouse selection (the PRIMARY selection on X, CLIP_LOCAL everywhere else) - the standard clipboard written by explicit copy/paste UI actions (CLIPBOARD on X, the unique system clipboard elsewhere). Also, you can control whether selecting text with the mouse _also_ writes to the explicitly accessed clipboard. The wording of the various messages changes between platforms, but the basic UI shape is the same everywhere.
2017-12-10 17:16:50 +00:00
break;
default:
break;
}
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
return 0;
}
if (wParam == VK_INSERT && shift_state == 1) {
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
switch (conf_get_int(wgs->conf, CONF_ctrlshiftins)) {
Add GUI configuration for choice of clipboards. On all platforms, you can now configure which clipboard the mouse pastes from, which clipboard Ctrl-Ins and Shift-Ins access, and which Ctrl-Shift-C and Ctrl-Shift-V access. In each case, the options are: - nothing at all - a clipboard which is implicitly written by the act of mouse selection (the PRIMARY selection on X, CLIP_LOCAL everywhere else) - the standard clipboard written by explicit copy/paste UI actions (CLIPBOARD on X, the unique system clipboard elsewhere). Also, you can control whether selecting text with the mouse _also_ writes to the explicitly accessed clipboard. The wording of the various messages changes between platforms, but the basic UI shape is the same everywhere.
2017-12-10 17:16:50 +00:00
case CLIPUI_IMPLICIT:
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
term_request_paste(wgs->term, CLIP_LOCAL);
Add GUI configuration for choice of clipboards. On all platforms, you can now configure which clipboard the mouse pastes from, which clipboard Ctrl-Ins and Shift-Ins access, and which Ctrl-Shift-C and Ctrl-Shift-V access. In each case, the options are: - nothing at all - a clipboard which is implicitly written by the act of mouse selection (the PRIMARY selection on X, CLIP_LOCAL everywhere else) - the standard clipboard written by explicit copy/paste UI actions (CLIPBOARD on X, the unique system clipboard elsewhere). Also, you can control whether selecting text with the mouse _also_ writes to the explicitly accessed clipboard. The wording of the various messages changes between platforms, but the basic UI shape is the same everywhere.
2017-12-10 17:16:50 +00:00
break;
case CLIPUI_EXPLICIT:
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
term_request_paste(wgs->term, CLIP_SYSTEM);
Add GUI configuration for choice of clipboards. On all platforms, you can now configure which clipboard the mouse pastes from, which clipboard Ctrl-Ins and Shift-Ins access, and which Ctrl-Shift-C and Ctrl-Shift-V access. In each case, the options are: - nothing at all - a clipboard which is implicitly written by the act of mouse selection (the PRIMARY selection on X, CLIP_LOCAL everywhere else) - the standard clipboard written by explicit copy/paste UI actions (CLIPBOARD on X, the unique system clipboard elsewhere). Also, you can control whether selecting text with the mouse _also_ writes to the explicitly accessed clipboard. The wording of the various messages changes between platforms, but the basic UI shape is the same everywhere.
2017-12-10 17:16:50 +00:00
break;
default:
break;
}
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
return 0;
}
if (wParam == 'C' && shift_state == 3) {
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
switch (conf_get_int(wgs->conf, CONF_ctrlshiftcv)) {
Add GUI configuration for choice of clipboards. On all platforms, you can now configure which clipboard the mouse pastes from, which clipboard Ctrl-Ins and Shift-Ins access, and which Ctrl-Shift-C and Ctrl-Shift-V access. In each case, the options are: - nothing at all - a clipboard which is implicitly written by the act of mouse selection (the PRIMARY selection on X, CLIP_LOCAL everywhere else) - the standard clipboard written by explicit copy/paste UI actions (CLIPBOARD on X, the unique system clipboard elsewhere). Also, you can control whether selecting text with the mouse _also_ writes to the explicitly accessed clipboard. The wording of the various messages changes between platforms, but the basic UI shape is the same everywhere.
2017-12-10 17:16:50 +00:00
case CLIPUI_IMPLICIT:
break; /* no need to re-copy to CLIP_LOCAL */
case CLIPUI_EXPLICIT:
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
term_request_copy(wgs->term, clips_system,
lenof(clips_system));
Add GUI configuration for choice of clipboards. On all platforms, you can now configure which clipboard the mouse pastes from, which clipboard Ctrl-Ins and Shift-Ins access, and which Ctrl-Shift-C and Ctrl-Shift-V access. In each case, the options are: - nothing at all - a clipboard which is implicitly written by the act of mouse selection (the PRIMARY selection on X, CLIP_LOCAL everywhere else) - the standard clipboard written by explicit copy/paste UI actions (CLIPBOARD on X, the unique system clipboard elsewhere). Also, you can control whether selecting text with the mouse _also_ writes to the explicitly accessed clipboard. The wording of the various messages changes between platforms, but the basic UI shape is the same everywhere.
2017-12-10 17:16:50 +00:00
break;
default:
break;
}
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
return 0;
}
if (wParam == 'V' && shift_state == 3) {
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
switch (conf_get_int(wgs->conf, CONF_ctrlshiftcv)) {
Add GUI configuration for choice of clipboards. On all platforms, you can now configure which clipboard the mouse pastes from, which clipboard Ctrl-Ins and Shift-Ins access, and which Ctrl-Shift-C and Ctrl-Shift-V access. In each case, the options are: - nothing at all - a clipboard which is implicitly written by the act of mouse selection (the PRIMARY selection on X, CLIP_LOCAL everywhere else) - the standard clipboard written by explicit copy/paste UI actions (CLIPBOARD on X, the unique system clipboard elsewhere). Also, you can control whether selecting text with the mouse _also_ writes to the explicitly accessed clipboard. The wording of the various messages changes between platforms, but the basic UI shape is the same everywhere.
2017-12-10 17:16:50 +00:00
case CLIPUI_IMPLICIT:
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
term_request_paste(wgs->term, CLIP_LOCAL);
Add GUI configuration for choice of clipboards. On all platforms, you can now configure which clipboard the mouse pastes from, which clipboard Ctrl-Ins and Shift-Ins access, and which Ctrl-Shift-C and Ctrl-Shift-V access. In each case, the options are: - nothing at all - a clipboard which is implicitly written by the act of mouse selection (the PRIMARY selection on X, CLIP_LOCAL everywhere else) - the standard clipboard written by explicit copy/paste UI actions (CLIPBOARD on X, the unique system clipboard elsewhere). Also, you can control whether selecting text with the mouse _also_ writes to the explicitly accessed clipboard. The wording of the various messages changes between platforms, but the basic UI shape is the same everywhere.
2017-12-10 17:16:50 +00:00
break;
case CLIPUI_EXPLICIT:
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
term_request_paste(wgs->term, CLIP_SYSTEM);
Add GUI configuration for choice of clipboards. On all platforms, you can now configure which clipboard the mouse pastes from, which clipboard Ctrl-Ins and Shift-Ins access, and which Ctrl-Shift-C and Ctrl-Shift-V access. In each case, the options are: - nothing at all - a clipboard which is implicitly written by the act of mouse selection (the PRIMARY selection on X, CLIP_LOCAL everywhere else) - the standard clipboard written by explicit copy/paste UI actions (CLIPBOARD on X, the unique system clipboard elsewhere). Also, you can control whether selecting text with the mouse _also_ writes to the explicitly accessed clipboard. The wording of the various messages changes between platforms, but the basic UI shape is the same everywhere.
2017-12-10 17:16:50 +00:00
break;
default:
break;
}
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
return 0;
}
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
if (left_alt && wParam == VK_F4 &&
conf_get_bool(wgs->conf, CONF_alt_f4)) {
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
return -1;
}
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
if (left_alt && wParam == VK_SPACE &&
conf_get_bool(wgs->conf, CONF_alt_space)) {
SendMessage(wgs->term_hwnd, WM_SYSCOMMAND, SC_KEYMENU, 0);
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
return -1;
}
if (left_alt && wParam == VK_RETURN &&
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
conf_get_bool(wgs->conf, CONF_fullscreenonaltenter) &&
(conf_get_int(wgs->conf, CONF_resize_action) != RESIZE_DISABLED)) {
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
if ((HIWORD(lParam) & (KF_UP | KF_REPEAT)) != KF_REPEAT)
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
flip_full_screen(wgs);
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
return -1;
}
/* Control-Numlock for app-keypad mode switch */
if (wParam == VK_PAUSE && shift_state == 2) {
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
wgs->term->app_keypad_keys = !wgs->term->app_keypad_keys;
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
return 0;
}
if (wParam == VK_BACK && shift_state == 0) { /* Backspace */
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
*p++ = (conf_get_bool(wgs->conf, CONF_bksp_is_delete) ?
0x7F : 0x08);
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
*p++ = 0;
return -2;
}
if (wParam == VK_BACK && shift_state == 1) { /* Shift Backspace */
/* We do the opposite of what is configured */
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
*p++ = (conf_get_bool(wgs->conf, CONF_bksp_is_delete) ?
0x08 : 0x7F);
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
*p++ = 0;
return -2;
}
if (wParam == VK_TAB && shift_state == 1) { /* Shift tab */
*p++ = 0x1B;
*p++ = '[';
*p++ = 'Z';
return p - output;
}
if (wParam == VK_SPACE && shift_state == 2) { /* Ctrl-Space */
*p++ = 0;
return p - output;
}
if (wParam == VK_SPACE && shift_state == 3) { /* Ctrl-Shift-Space */
*p++ = 160;
return p - output;
}
if (wParam == VK_CANCEL && shift_state == 2) { /* Ctrl-Break */
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
if (wgs->backend)
backend_special(wgs->backend, SS_BRK, 0);
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
return 0;
}
if (wParam == VK_PAUSE) { /* Break/Pause */
*p++ = 26;
*p++ = 0;
return -2;
}
/* Control-2 to Control-8 are special */
if (shift_state == 2 && wParam >= '2' && wParam <= '8') {
*p++ = "\000\033\034\035\036\037\177"[wParam - '2'];
return p - output;
}
if (shift_state == 2 && (wParam == 0xBD || wParam == 0xBF)) {
*p++ = 0x1F;
return p - output;
}
if (shift_state == 2 && (wParam == 0xDF || wParam == 0xDC)) {
*p++ = 0x1C;
return p - output;
}
if (shift_state == 3 && wParam == 0xDE) {
*p++ = 0x1E; /* Ctrl-~ == Ctrl-^ in xterm at least */
return p - output;
}
switch (wParam) {
Fix Alt handling in the new shifted-arrow-key support. As well as affecting the bitmap field in the escape sequence, it was _also_ having its otherwise standard effect of prefixing Esc to the whole sequence. It shouldn't do both.
2021-10-23 09:52:11 +00:00
bool consumed_alt;
Centralise key escape sequences into terminal.c. A long time ago, in commit 4d77b6567, I moved the generation of the arrow-key escape sequences into a function format_arrow_key(). Mostly the reason for that was a special purpose I had in mind at the time which involved auto-generating the same sequences in response to things other than a keypress, but I always thought it would be nice to centralise a lot more of PuTTY's complicated keyboard handling in the same way - at least the handling of the function keys and their numerous static and dynamic config options. In this year's general spirit of tidying up and refactoring, I think it's finally time. So here I introduce three more centralised functions for dealing with the numbered function keys, the small keypad (Ins, Home, PgUp etc) and the numeric keypad. Lots of horrible and duplicated code from the key handling functions in window.c and gtkwin.c is now more sensibly centralised: each platform keyboard handler concerns itself with the local format of a keyboard event and platform-specific enumeration of key codes, and once it's decided what the logical key press actually _is_, it hands off to the new functions in terminal.c to generate the appropriate escape code. Mostly this is intended to be a refactoring without functional change, leaving the keyboard handling how it's always been. But in cases where the Windows and GTK handlers were accidentally inconsistent, I've fixed the inconsistency rather than carefully keeping both sides how they were. Known consistency fixes: - swapping the arrow keys between normal (ESC [ A) and application (ESC O A) is now done by pressing Ctrl with them, and _not_ by pressing Shift. That was how it was always supposed to work, and how it's worked on GTK all along, but on Windows it's been done by Shift as well since 2010, due to a bug at the call site of format_arrow_key() introduced when I originally wrote that function. - in Xterm function key mode plus application keypad mode, the /*- keys on the numeric keypad now send ESC O {o,j,m} in place of ESC O {Q,R,S}. That's how the Windows keyboard handler has worked all along (it was a deliberate behaviour tweak for the Xterm-like function key mode, because in that mode ESC O {Q,R,S} are generated by F2-F4). But the GTK keyboard handler omitted that particular special case and was still sending ESC O {Q,R,S} for those keys in all application keypad modes. - also in Xterm function key mode plus app keypad mode, we only generates the app-keypad escape sequences if Num Lock is on; with Num Lock off, the numeric keypad becomes arrow keys and Home/End/etc, just as it would in non-app-keypad mode. Windows has done this all along, but again, GTK lacked that special case.
2018-12-08 08:25:32 +00:00
case VK_NUMPAD0: keypad_key = '0'; goto numeric_keypad;
case VK_NUMPAD1: keypad_key = '1'; goto numeric_keypad;
case VK_NUMPAD2: keypad_key = '2'; goto numeric_keypad;
case VK_NUMPAD3: keypad_key = '3'; goto numeric_keypad;
case VK_NUMPAD4: keypad_key = '4'; goto numeric_keypad;
case VK_NUMPAD5: keypad_key = '5'; goto numeric_keypad;
case VK_NUMPAD6: keypad_key = '6'; goto numeric_keypad;
case VK_NUMPAD7: keypad_key = '7'; goto numeric_keypad;
case VK_NUMPAD8: keypad_key = '8'; goto numeric_keypad;
case VK_NUMPAD9: keypad_key = '9'; goto numeric_keypad;
case VK_DECIMAL: keypad_key = '.'; goto numeric_keypad;
case VK_ADD: keypad_key = '+'; goto numeric_keypad;
case VK_SUBTRACT: keypad_key = '-'; goto numeric_keypad;
case VK_MULTIPLY: keypad_key = '*'; goto numeric_keypad;
case VK_DIVIDE: keypad_key = '/'; goto numeric_keypad;
case VK_EXECUTE: keypad_key = 'G'; goto numeric_keypad;
/* also the case for VK_RETURN below can sometimes come here */
numeric_keypad:
/* Left Alt overrides all numeric keypad usage to act as
* numeric character code input */
if (left_alt) {
if (keypad_key >= '0' && keypad_key <= '9')
windows/window.c: move more variables into WinGuiSeat. In commit f9e572595bb8cb6 I claimed that I'd removed very nearly all the global and static variables from windows/window.c. It turns out that this was wildly overoptimistic - I missed quite a few of them! I'm not quite sure how I managed that; my best guess is that I used an underpowered 'nm' command that failed to find some classes of variable. Some of the remaining function-scope statics were removed completely by commit afb3dab1e97a09f just now. In this commit, I've swept up some more and turn them into fields of WinGuiSeat, where they should have been moved last September. The (hopefully complete this time) list of remaining variables, generated by running this rune in the Windows build directory: nm windows/CMakeFiles/putty.dir/window.c.obj | grep -E '^([^ ]+)? *[bBcCdDgGsS] [^\.]' consists of the following variables which are legitimately global across the whole process and not related to a particular window: - 'hinst' and 'hprev', instance handles for Windows loadable modules - 'classname' in the terminal_window_class_a() and terminal_window_class_w() functions, which allocate a window class reusably - some pointers to Windows API functions retrieved via the DECL_WINDOWS_FUNCTION / GET_WINDOWS_FUNCTION system, such as p_AdjustWindowRectExForDpi and p_FlashWindowEx - some pointers to Windows API functions set up by assigning them at startup to the right one of the ANSI or Unicode version depending on the Windows version, e.g. sw_DefWindowProc and sw_DispatchMessage - 'unicode_window', a boolean flag set at the same time as those sw_Foo function pointers - 'sesslist', storing the last-retrieved version of the saved sessions menu - 'cursor_visible' in show_mouseptr() and 'forced_visible' in update_mouse_pointer(), each of which tracks the cumulative number of times that function has shown or hidden the mouse pointer, so as to manage its effect on the global state updated by ShowCursor - 'trust_icon', loaded from the executable's resources - 'wgslisthead', the list of all active WinGuiSeats - 'wm_mousewheel', the window-message id we use for mouse wheel events and the following which are nothing to do with our code: - '_OptionsStorage' in __local_stdio_printf_options() and __local_stdio_scanf_options(), which I'd never noticed before, but apparently are internal to a standard library header.
2023-05-27 13:59:20 +00:00
wgs->alt_numberpad_accumulator =
wgs->alt_numberpad_accumulator * 10 + keypad_key - '0';
Centralise key escape sequences into terminal.c. A long time ago, in commit 4d77b6567, I moved the generation of the arrow-key escape sequences into a function format_arrow_key(). Mostly the reason for that was a special purpose I had in mind at the time which involved auto-generating the same sequences in response to things other than a keypress, but I always thought it would be nice to centralise a lot more of PuTTY's complicated keyboard handling in the same way - at least the handling of the function keys and their numerous static and dynamic config options. In this year's general spirit of tidying up and refactoring, I think it's finally time. So here I introduce three more centralised functions for dealing with the numbered function keys, the small keypad (Ins, Home, PgUp etc) and the numeric keypad. Lots of horrible and duplicated code from the key handling functions in window.c and gtkwin.c is now more sensibly centralised: each platform keyboard handler concerns itself with the local format of a keyboard event and platform-specific enumeration of key codes, and once it's decided what the logical key press actually _is_, it hands off to the new functions in terminal.c to generate the appropriate escape code. Mostly this is intended to be a refactoring without functional change, leaving the keyboard handling how it's always been. But in cases where the Windows and GTK handlers were accidentally inconsistent, I've fixed the inconsistency rather than carefully keeping both sides how they were. Known consistency fixes: - swapping the arrow keys between normal (ESC [ A) and application (ESC O A) is now done by pressing Ctrl with them, and _not_ by pressing Shift. That was how it was always supposed to work, and how it's worked on GTK all along, but on Windows it's been done by Shift as well since 2010, due to a bug at the call site of format_arrow_key() introduced when I originally wrote that function. - in Xterm function key mode plus application keypad mode, the /*- keys on the numeric keypad now send ESC O {o,j,m} in place of ESC O {Q,R,S}. That's how the Windows keyboard handler has worked all along (it was a deliberate behaviour tweak for the Xterm-like function key mode, because in that mode ESC O {Q,R,S} are generated by F2-F4). But the GTK keyboard handler omitted that particular special case and was still sending ESC O {Q,R,S} for those keys in all application keypad modes. - also in Xterm function key mode plus app keypad mode, we only generates the app-keypad escape sequences if Num Lock is on; with Num Lock off, the numeric keypad becomes arrow keys and Home/End/etc, just as it would in non-app-keypad mode. Windows has done this all along, but again, GTK lacked that special case.
2018-12-08 08:25:32 +00:00
else
windows/window.c: move more variables into WinGuiSeat. In commit f9e572595bb8cb6 I claimed that I'd removed very nearly all the global and static variables from windows/window.c. It turns out that this was wildly overoptimistic - I missed quite a few of them! I'm not quite sure how I managed that; my best guess is that I used an underpowered 'nm' command that failed to find some classes of variable. Some of the remaining function-scope statics were removed completely by commit afb3dab1e97a09f just now. In this commit, I've swept up some more and turn them into fields of WinGuiSeat, where they should have been moved last September. The (hopefully complete this time) list of remaining variables, generated by running this rune in the Windows build directory: nm windows/CMakeFiles/putty.dir/window.c.obj | grep -E '^([^ ]+)? *[bBcCdDgGsS] [^\.]' consists of the following variables which are legitimately global across the whole process and not related to a particular window: - 'hinst' and 'hprev', instance handles for Windows loadable modules - 'classname' in the terminal_window_class_a() and terminal_window_class_w() functions, which allocate a window class reusably - some pointers to Windows API functions retrieved via the DECL_WINDOWS_FUNCTION / GET_WINDOWS_FUNCTION system, such as p_AdjustWindowRectExForDpi and p_FlashWindowEx - some pointers to Windows API functions set up by assigning them at startup to the right one of the ANSI or Unicode version depending on the Windows version, e.g. sw_DefWindowProc and sw_DispatchMessage - 'unicode_window', a boolean flag set at the same time as those sw_Foo function pointers - 'sesslist', storing the last-retrieved version of the saved sessions menu - 'cursor_visible' in show_mouseptr() and 'forced_visible' in update_mouse_pointer(), each of which tracks the cumulative number of times that function has shown or hidden the mouse pointer, so as to manage its effect on the global state updated by ShowCursor - 'trust_icon', loaded from the executable's resources - 'wgslisthead', the list of all active WinGuiSeats - 'wm_mousewheel', the window-message id we use for mouse wheel events and the following which are nothing to do with our code: - '_OptionsStorage' in __local_stdio_printf_options() and __local_stdio_scanf_options(), which I'd never noticed before, but apparently are internal to a standard library header.
2023-05-27 13:59:20 +00:00
wgs->alt_numberpad_accumulator = 0;
Centralise key escape sequences into terminal.c. A long time ago, in commit 4d77b6567, I moved the generation of the arrow-key escape sequences into a function format_arrow_key(). Mostly the reason for that was a special purpose I had in mind at the time which involved auto-generating the same sequences in response to things other than a keypress, but I always thought it would be nice to centralise a lot more of PuTTY's complicated keyboard handling in the same way - at least the handling of the function keys and their numerous static and dynamic config options. In this year's general spirit of tidying up and refactoring, I think it's finally time. So here I introduce three more centralised functions for dealing with the numbered function keys, the small keypad (Ins, Home, PgUp etc) and the numeric keypad. Lots of horrible and duplicated code from the key handling functions in window.c and gtkwin.c is now more sensibly centralised: each platform keyboard handler concerns itself with the local format of a keyboard event and platform-specific enumeration of key codes, and once it's decided what the logical key press actually _is_, it hands off to the new functions in terminal.c to generate the appropriate escape code. Mostly this is intended to be a refactoring without functional change, leaving the keyboard handling how it's always been. But in cases where the Windows and GTK handlers were accidentally inconsistent, I've fixed the inconsistency rather than carefully keeping both sides how they were. Known consistency fixes: - swapping the arrow keys between normal (ESC [ A) and application (ESC O A) is now done by pressing Ctrl with them, and _not_ by pressing Shift. That was how it was always supposed to work, and how it's worked on GTK all along, but on Windows it's been done by Shift as well since 2010, due to a bug at the call site of format_arrow_key() introduced when I originally wrote that function. - in Xterm function key mode plus application keypad mode, the /*- keys on the numeric keypad now send ESC O {o,j,m} in place of ESC O {Q,R,S}. That's how the Windows keyboard handler has worked all along (it was a deliberate behaviour tweak for the Xterm-like function key mode, because in that mode ESC O {Q,R,S} are generated by F2-F4). But the GTK keyboard handler omitted that particular special case and was still sending ESC O {Q,R,S} for those keys in all application keypad modes. - also in Xterm function key mode plus app keypad mode, we only generates the app-keypad escape sequences if Num Lock is on; with Num Lock off, the numeric keypad becomes arrow keys and Home/End/etc, just as it would in non-app-keypad mode. Windows has done this all along, but again, GTK lacked that special case.
2018-12-08 08:25:32 +00:00
break;
}
Shift-Tab now sends ESC [ Z [originally from svn r408]
2000-03-13 14:45:32 +00:00
Remove ASCII fallback in format_numeric_keypad_key(). TranslateKey() on Windows passed all numeric-keypad key events to this function in terminal.c, and accepted whatever it gave back. That included the handling for the trivial case of the numeric keypad, when Num Lock is on and application keypad mode hasn't overridden it, so that the keypad should be returning actual digits. In that case, format_numeric_keypad_key() itself was returning the same ASCII character I had passed in to it as a keypad identifier, and TranslateKey was returning that in turn as the final translation. Unfortunately, that means that with Num Lock on, the numeric keypad translates into what _I_ used as the logical keypad codes inside the source code, not what the local keyboard layout thinks are the right codes. In particular, the key I identified as keypad '.' would render as '.' even on a German keyboard where it ought to produce ','. Fixed by removing the fallback case in format_numeric_keypad_key() itself, so now it returns the empty string if it didn't produce an escape sequence as its translation. Instead, the special case is in window.c, which checks for a zero-length output string and handles it by falling through to the keyboard-layout specific ToUnicode code further down TranslateKey(). On the GTK side, no change is needed here: the GTK keyboard handler does things in the opposite order, by trying the local input method _first_ (unless it can see a reason up front to override it), and only calling format_numeric_keypad_key() if that didn't provide a translation. So the fallback ASCII translation in the latter was already not used.
2019-04-06 09:45:40 +00:00
{
int nchars = format_numeric_keypad_key(
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
(char *)p, wgs->term, keypad_key,
Remove ASCII fallback in format_numeric_keypad_key(). TranslateKey() on Windows passed all numeric-keypad key events to this function in terminal.c, and accepted whatever it gave back. That included the handling for the trivial case of the numeric keypad, when Num Lock is on and application keypad mode hasn't overridden it, so that the keypad should be returning actual digits. In that case, format_numeric_keypad_key() itself was returning the same ASCII character I had passed in to it as a keypad identifier, and TranslateKey was returning that in turn as the final translation. Unfortunately, that means that with Num Lock on, the numeric keypad translates into what _I_ used as the logical keypad codes inside the source code, not what the local keyboard layout thinks are the right codes. In particular, the key I identified as keypad '.' would render as '.' even on a German keyboard where it ought to produce ','. Fixed by removing the fallback case in format_numeric_keypad_key() itself, so now it returns the empty string if it didn't produce an escape sequence as its translation. Instead, the special case is in window.c, which checks for a zero-length output string and handles it by falling through to the keyboard-layout specific ToUnicode code further down TranslateKey(). On the GTK side, no change is needed here: the GTK keyboard handler does things in the opposite order, by trying the local input method _first_ (unless it can see a reason up front to override it), and only calling format_numeric_keypad_key() if that didn't provide a translation. So the fallback ASCII translation in the latter was already not used.
2019-04-06 09:45:40 +00:00
shift_state & 1, shift_state & 2);
if (!nchars) {
Fix handling of Return and keypad Enter. The recent rewriting in both the GTK and Windows keyboard handlers left the keypad 'Enter' key in a bad state, when no override is enabled that causes it to generate an escape sequence. On Windows, a series of fallbacks was causing it to generate \r regardless of configuration, whereas in Telnet mode it should default to generating the special Telnet new-line sequence, and in response to ESC[20h (enabling term->cr_lf_return) it should generate \r\n. On GTK, it wasn't generating anything _at all_, and also, I can't see any evidence that the GTK keyboard handler had ever remembered to implement the cr_lf_return mode. Now Keypad Enter in non-escape-sequence mode should behave just like Return, on both platforms.
2019-04-15 19:43:10 +00:00
/*
* If we didn't get an escape sequence out of the
Remove ASCII fallback in format_numeric_keypad_key(). TranslateKey() on Windows passed all numeric-keypad key events to this function in terminal.c, and accepted whatever it gave back. That included the handling for the trivial case of the numeric keypad, when Num Lock is on and application keypad mode hasn't overridden it, so that the keypad should be returning actual digits. In that case, format_numeric_keypad_key() itself was returning the same ASCII character I had passed in to it as a keypad identifier, and TranslateKey was returning that in turn as the final translation. Unfortunately, that means that with Num Lock on, the numeric keypad translates into what _I_ used as the logical keypad codes inside the source code, not what the local keyboard layout thinks are the right codes. In particular, the key I identified as keypad '.' would render as '.' even on a German keyboard where it ought to produce ','. Fixed by removing the fallback case in format_numeric_keypad_key() itself, so now it returns the empty string if it didn't produce an escape sequence as its translation. Instead, the special case is in window.c, which checks for a zero-length output string and handles it by falling through to the keyboard-layout specific ToUnicode code further down TranslateKey(). On the GTK side, no change is needed here: the GTK keyboard handler does things in the opposite order, by trying the local input method _first_ (unless it can see a reason up front to override it), and only calling format_numeric_keypad_key() if that didn't provide a translation. So the fallback ASCII translation in the latter was already not used.
2019-04-06 09:45:40 +00:00
* numeric keypad key, then that must be because
* we're in Num Lock mode without application
* keypad enabled. In that situation we leave this
* keypress to the ToUnicode/ToAsciiEx handler
* below, which will translate it according to the
* appropriate keypad layout (e.g. so that what a
* Brit thinks of as keypad '.' can become ',' in
Fix handling of Return and keypad Enter. The recent rewriting in both the GTK and Windows keyboard handlers left the keypad 'Enter' key in a bad state, when no override is enabled that causes it to generate an escape sequence. On Windows, a series of fallbacks was causing it to generate \r regardless of configuration, whereas in Telnet mode it should default to generating the special Telnet new-line sequence, and in response to ESC[20h (enabling term->cr_lf_return) it should generate \r\n. On GTK, it wasn't generating anything _at all_, and also, I can't see any evidence that the GTK keyboard handler had ever remembered to implement the cr_lf_return mode. Now Keypad Enter in non-escape-sequence mode should behave just like Return, on both platforms.
2019-04-15 19:43:10 +00:00
* the German layout).
*
* An exception is the keypad Return key: if we
* didn't get an escape sequence for that, we
* treat it like ordinary Return, taking into
* account Telnet special new line codes and
* config options.
*/
if (keypad_key == '\r')
goto ordinary_return_key;
Remove ASCII fallback in format_numeric_keypad_key(). TranslateKey() on Windows passed all numeric-keypad key events to this function in terminal.c, and accepted whatever it gave back. That included the handling for the trivial case of the numeric keypad, when Num Lock is on and application keypad mode hasn't overridden it, so that the keypad should be returning actual digits. In that case, format_numeric_keypad_key() itself was returning the same ASCII character I had passed in to it as a keypad identifier, and TranslateKey was returning that in turn as the final translation. Unfortunately, that means that with Num Lock on, the numeric keypad translates into what _I_ used as the logical keypad codes inside the source code, not what the local keyboard layout thinks are the right codes. In particular, the key I identified as keypad '.' would render as '.' even on a German keyboard where it ought to produce ','. Fixed by removing the fallback case in format_numeric_keypad_key() itself, so now it returns the empty string if it didn't produce an escape sequence as its translation. Instead, the special case is in window.c, which checks for a zero-length output string and handles it by falling through to the keyboard-layout specific ToUnicode code further down TranslateKey(). On the GTK side, no change is needed here: the GTK keyboard handler does things in the opposite order, by trying the local input method _first_ (unless it can see a reason up front to override it), and only calling format_numeric_keypad_key() if that didn't provide a translation. So the fallback ASCII translation in the latter was already not used.
2019-04-06 09:45:40 +00:00
break;
}
p += nchars;
return p - output;
}
Centralise key escape sequences into terminal.c. A long time ago, in commit 4d77b6567, I moved the generation of the arrow-key escape sequences into a function format_arrow_key(). Mostly the reason for that was a special purpose I had in mind at the time which involved auto-generating the same sequences in response to things other than a keypress, but I always thought it would be nice to centralise a lot more of PuTTY's complicated keyboard handling in the same way - at least the handling of the function keys and their numerous static and dynamic config options. In this year's general spirit of tidying up and refactoring, I think it's finally time. So here I introduce three more centralised functions for dealing with the numbered function keys, the small keypad (Ins, Home, PgUp etc) and the numeric keypad. Lots of horrible and duplicated code from the key handling functions in window.c and gtkwin.c is now more sensibly centralised: each platform keyboard handler concerns itself with the local format of a keyboard event and platform-specific enumeration of key codes, and once it's decided what the logical key press actually _is_, it hands off to the new functions in terminal.c to generate the appropriate escape code. Mostly this is intended to be a refactoring without functional change, leaving the keyboard handling how it's always been. But in cases where the Windows and GTK handlers were accidentally inconsistent, I've fixed the inconsistency rather than carefully keeping both sides how they were. Known consistency fixes: - swapping the arrow keys between normal (ESC [ A) and application (ESC O A) is now done by pressing Ctrl with them, and _not_ by pressing Shift. That was how it was always supposed to work, and how it's worked on GTK all along, but on Windows it's been done by Shift as well since 2010, due to a bug at the call site of format_arrow_key() introduced when I originally wrote that function. - in Xterm function key mode plus application keypad mode, the /*- keys on the numeric keypad now send ESC O {o,j,m} in place of ESC O {Q,R,S}. That's how the Windows keyboard handler has worked all along (it was a deliberate behaviour tweak for the Xterm-like function key mode, because in that mode ESC O {Q,R,S} are generated by F2-F4). But the GTK keyboard handler omitted that particular special case and was still sending ESC O {Q,R,S} for those keys in all application keypad modes. - also in Xterm function key mode plus app keypad mode, we only generates the app-keypad escape sequences if Num Lock is on; with Num Lock off, the numeric keypad becomes arrow keys and Home/End/etc, just as it would in non-app-keypad mode. Windows has done this all along, but again, GTK lacked that special case.
2018-12-08 08:25:32 +00:00
int fkey_number;
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
case VK_F1: fkey_number = 1; goto numbered_function_key;
case VK_F2: fkey_number = 2; goto numbered_function_key;
case VK_F3: fkey_number = 3; goto numbered_function_key;
case VK_F4: fkey_number = 4; goto numbered_function_key;
case VK_F5: fkey_number = 5; goto numbered_function_key;
case VK_F6: fkey_number = 6; goto numbered_function_key;
case VK_F7: fkey_number = 7; goto numbered_function_key;
case VK_F8: fkey_number = 8; goto numbered_function_key;
case VK_F9: fkey_number = 9; goto numbered_function_key;
case VK_F10: fkey_number = 10; goto numbered_function_key;
case VK_F11: fkey_number = 11; goto numbered_function_key;
case VK_F12: fkey_number = 12; goto numbered_function_key;
case VK_F13: fkey_number = 13; goto numbered_function_key;
case VK_F14: fkey_number = 14; goto numbered_function_key;
case VK_F15: fkey_number = 15; goto numbered_function_key;
case VK_F16: fkey_number = 16; goto numbered_function_key;
case VK_F17: fkey_number = 17; goto numbered_function_key;
case VK_F18: fkey_number = 18; goto numbered_function_key;
case VK_F19: fkey_number = 19; goto numbered_function_key;
case VK_F20: fkey_number = 20; goto numbered_function_key;
Centralise key escape sequences into terminal.c. A long time ago, in commit 4d77b6567, I moved the generation of the arrow-key escape sequences into a function format_arrow_key(). Mostly the reason for that was a special purpose I had in mind at the time which involved auto-generating the same sequences in response to things other than a keypress, but I always thought it would be nice to centralise a lot more of PuTTY's complicated keyboard handling in the same way - at least the handling of the function keys and their numerous static and dynamic config options. In this year's general spirit of tidying up and refactoring, I think it's finally time. So here I introduce three more centralised functions for dealing with the numbered function keys, the small keypad (Ins, Home, PgUp etc) and the numeric keypad. Lots of horrible and duplicated code from the key handling functions in window.c and gtkwin.c is now more sensibly centralised: each platform keyboard handler concerns itself with the local format of a keyboard event and platform-specific enumeration of key codes, and once it's decided what the logical key press actually _is_, it hands off to the new functions in terminal.c to generate the appropriate escape code. Mostly this is intended to be a refactoring without functional change, leaving the keyboard handling how it's always been. But in cases where the Windows and GTK handlers were accidentally inconsistent, I've fixed the inconsistency rather than carefully keeping both sides how they were. Known consistency fixes: - swapping the arrow keys between normal (ESC [ A) and application (ESC O A) is now done by pressing Ctrl with them, and _not_ by pressing Shift. That was how it was always supposed to work, and how it's worked on GTK all along, but on Windows it's been done by Shift as well since 2010, due to a bug at the call site of format_arrow_key() introduced when I originally wrote that function. - in Xterm function key mode plus application keypad mode, the /*- keys on the numeric keypad now send ESC O {o,j,m} in place of ESC O {Q,R,S}. That's how the Windows keyboard handler has worked all along (it was a deliberate behaviour tweak for the Xterm-like function key mode, because in that mode ESC O {Q,R,S} are generated by F2-F4). But the GTK keyboard handler omitted that particular special case and was still sending ESC O {Q,R,S} for those keys in all application keypad modes. - also in Xterm function key mode plus app keypad mode, we only generates the app-keypad escape sequences if Num Lock is on; with Num Lock off, the numeric keypad becomes arrow keys and Home/End/etc, just as it would in non-app-keypad mode. Windows has done this all along, but again, GTK lacked that special case.
2018-12-08 08:25:32 +00:00
numbered_function_key:
New function-key mode similar to modern xterm. This is the same as the previous FUNKY_XTERM mode if you don't press any modifier keys, but now Shift or Ctrl or Alt with function keys adds an extra bitmap parameter. The bitmaps are the same as the ones used by the new SHARROW_BITMAP arrow key mode.
2021-10-23 10:04:53 +00:00
consumed_alt = false;
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
p += format_function_key((char *)p, wgs->term, fkey_number,
New function-key mode similar to modern xterm. This is the same as the previous FUNKY_XTERM mode if you don't press any modifier keys, but now Shift or Ctrl or Alt with function keys adds an extra bitmap parameter. The bitmaps are the same as the ones used by the new SHARROW_BITMAP arrow key mode.
2021-10-23 10:04:53 +00:00
shift_state & 1, shift_state & 2,
left_alt, &consumed_alt);
Fix Xterm216+ Alt-Fn on Windows On most keyboard modes the escape-sequence for Alt-Fn is the same as for Fn alone but with an additional ESC prepended. However, this additional ESC should not be sent for keyboard modes that sends a different escape-sequence when Alt is pressed, like e.g. Xterm216+, as this is not expected by the server-side application. Signed-off-by: Anders Larsen <al@alarsen.net>
2024-10-01 08:08:28 +00:00
if (consumed_alt) {
/* supersedes the usual prefixing of Esc */
p -= 1;
memmove(output, output + 1, p - output);
}
Centralise key escape sequences into terminal.c. A long time ago, in commit 4d77b6567, I moved the generation of the arrow-key escape sequences into a function format_arrow_key(). Mostly the reason for that was a special purpose I had in mind at the time which involved auto-generating the same sequences in response to things other than a keypress, but I always thought it would be nice to centralise a lot more of PuTTY's complicated keyboard handling in the same way - at least the handling of the function keys and their numerous static and dynamic config options. In this year's general spirit of tidying up and refactoring, I think it's finally time. So here I introduce three more centralised functions for dealing with the numbered function keys, the small keypad (Ins, Home, PgUp etc) and the numeric keypad. Lots of horrible and duplicated code from the key handling functions in window.c and gtkwin.c is now more sensibly centralised: each platform keyboard handler concerns itself with the local format of a keyboard event and platform-specific enumeration of key codes, and once it's decided what the logical key press actually _is_, it hands off to the new functions in terminal.c to generate the appropriate escape code. Mostly this is intended to be a refactoring without functional change, leaving the keyboard handling how it's always been. But in cases where the Windows and GTK handlers were accidentally inconsistent, I've fixed the inconsistency rather than carefully keeping both sides how they were. Known consistency fixes: - swapping the arrow keys between normal (ESC [ A) and application (ESC O A) is now done by pressing Ctrl with them, and _not_ by pressing Shift. That was how it was always supposed to work, and how it's worked on GTK all along, but on Windows it's been done by Shift as well since 2010, due to a bug at the call site of format_arrow_key() introduced when I originally wrote that function. - in Xterm function key mode plus application keypad mode, the /*- keys on the numeric keypad now send ESC O {o,j,m} in place of ESC O {Q,R,S}. That's how the Windows keyboard handler has worked all along (it was a deliberate behaviour tweak for the Xterm-like function key mode, because in that mode ESC O {Q,R,S} are generated by F2-F4). But the GTK keyboard handler omitted that particular special case and was still sending ESC O {Q,R,S} for those keys in all application keypad modes. - also in Xterm function key mode plus app keypad mode, we only generates the app-keypad escape sequences if Num Lock is on; with Num Lock off, the numeric keypad becomes arrow keys and Home/End/etc, just as it would in non-app-keypad mode. Windows has done this all along, but again, GTK lacked that special case.
2018-12-08 08:25:32 +00:00
return p - output;
SmallKeypadKey sk_key;
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
case VK_HOME: sk_key = SKK_HOME; goto small_keypad_key;
case VK_END: sk_key = SKK_END; goto small_keypad_key;
case VK_INSERT: sk_key = SKK_INSERT; goto small_keypad_key;
case VK_DELETE: sk_key = SKK_DELETE; goto small_keypad_key;
case VK_PRIOR: sk_key = SKK_PGUP; goto small_keypad_key;
case VK_NEXT: sk_key = SKK_PGDN; goto small_keypad_key;
Centralise key escape sequences into terminal.c. A long time ago, in commit 4d77b6567, I moved the generation of the arrow-key escape sequences into a function format_arrow_key(). Mostly the reason for that was a special purpose I had in mind at the time which involved auto-generating the same sequences in response to things other than a keypress, but I always thought it would be nice to centralise a lot more of PuTTY's complicated keyboard handling in the same way - at least the handling of the function keys and their numerous static and dynamic config options. In this year's general spirit of tidying up and refactoring, I think it's finally time. So here I introduce three more centralised functions for dealing with the numbered function keys, the small keypad (Ins, Home, PgUp etc) and the numeric keypad. Lots of horrible and duplicated code from the key handling functions in window.c and gtkwin.c is now more sensibly centralised: each platform keyboard handler concerns itself with the local format of a keyboard event and platform-specific enumeration of key codes, and once it's decided what the logical key press actually _is_, it hands off to the new functions in terminal.c to generate the appropriate escape code. Mostly this is intended to be a refactoring without functional change, leaving the keyboard handling how it's always been. But in cases where the Windows and GTK handlers were accidentally inconsistent, I've fixed the inconsistency rather than carefully keeping both sides how they were. Known consistency fixes: - swapping the arrow keys between normal (ESC [ A) and application (ESC O A) is now done by pressing Ctrl with them, and _not_ by pressing Shift. That was how it was always supposed to work, and how it's worked on GTK all along, but on Windows it's been done by Shift as well since 2010, due to a bug at the call site of format_arrow_key() introduced when I originally wrote that function. - in Xterm function key mode plus application keypad mode, the /*- keys on the numeric keypad now send ESC O {o,j,m} in place of ESC O {Q,R,S}. That's how the Windows keyboard handler has worked all along (it was a deliberate behaviour tweak for the Xterm-like function key mode, because in that mode ESC O {Q,R,S} are generated by F2-F4). But the GTK keyboard handler omitted that particular special case and was still sending ESC O {Q,R,S} for those keys in all application keypad modes. - also in Xterm function key mode plus app keypad mode, we only generates the app-keypad escape sequences if Num Lock is on; with Num Lock off, the numeric keypad becomes arrow keys and Home/End/etc, just as it would in non-app-keypad mode. Windows has done this all along, but again, GTK lacked that special case.
2018-12-08 08:25:32 +00:00
small_keypad_key:
/* These keys don't generate terminal input with Ctrl */
if (shift_state & 2)
break;
Alt-Enter was fouling up on Win95; added explicit handler [originally from svn r687]
2000-10-07 08:10:32 +00:00
Fix Xterm216+ Alt-Fn on Windows On most keyboard modes the escape-sequence for Alt-Fn is the same as for Fn alone but with an additional ESC prepended. However, this additional ESC should not be sent for keyboard modes that sends a different escape-sequence when Alt is pressed, like e.g. Xterm216+, as this is not expected by the server-side application. Signed-off-by: Anders Larsen <al@alarsen.net>
2024-10-01 08:08:28 +00:00
consumed_alt = false;
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
p += format_small_keypad_key((char *)p, wgs->term, sk_key,
Formatting: realign run-on parenthesised stuff. My bulk indentation check also turned up a lot of cases where a run-on function call or if statement didn't have its later lines aligned correctly relative to the open paren. I think this is quite easy to do by getting things out of sync (editing the first line of the function call and forgetting to update the rest, perhaps even because you never _saw_ the rest during a search-replace). But a few didn't quite fit into that pattern, in particular an outright misleading case in unix/askpass.c where the second line of a call was aligned neatly below the _wrong_ one of the open parens on the opening line. Restored as many alignments as I could easily find.
2022-08-03 19:48:46 +00:00
shift_state & 1, shift_state & 2,
left_alt, &consumed_alt);
Fix Xterm216+ Alt-Fn on Windows On most keyboard modes the escape-sequence for Alt-Fn is the same as for Fn alone but with an additional ESC prepended. However, this additional ESC should not be sent for keyboard modes that sends a different escape-sequence when Alt is pressed, like e.g. Xterm216+, as this is not expected by the server-side application. Signed-off-by: Anders Larsen <al@alarsen.net>
2024-10-01 08:08:28 +00:00
if (consumed_alt) {
/* supersedes the usual prefixing of Esc */
p -= 1;
memmove(output, output + 1, p - output);
}
Centralise key escape sequences into terminal.c. A long time ago, in commit 4d77b6567, I moved the generation of the arrow-key escape sequences into a function format_arrow_key(). Mostly the reason for that was a special purpose I had in mind at the time which involved auto-generating the same sequences in response to things other than a keypress, but I always thought it would be nice to centralise a lot more of PuTTY's complicated keyboard handling in the same way - at least the handling of the function keys and their numerous static and dynamic config options. In this year's general spirit of tidying up and refactoring, I think it's finally time. So here I introduce three more centralised functions for dealing with the numbered function keys, the small keypad (Ins, Home, PgUp etc) and the numeric keypad. Lots of horrible and duplicated code from the key handling functions in window.c and gtkwin.c is now more sensibly centralised: each platform keyboard handler concerns itself with the local format of a keyboard event and platform-specific enumeration of key codes, and once it's decided what the logical key press actually _is_, it hands off to the new functions in terminal.c to generate the appropriate escape code. Mostly this is intended to be a refactoring without functional change, leaving the keyboard handling how it's always been. But in cases where the Windows and GTK handlers were accidentally inconsistent, I've fixed the inconsistency rather than carefully keeping both sides how they were. Known consistency fixes: - swapping the arrow keys between normal (ESC [ A) and application (ESC O A) is now done by pressing Ctrl with them, and _not_ by pressing Shift. That was how it was always supposed to work, and how it's worked on GTK all along, but on Windows it's been done by Shift as well since 2010, due to a bug at the call site of format_arrow_key() introduced when I originally wrote that function. - in Xterm function key mode plus application keypad mode, the /*- keys on the numeric keypad now send ESC O {o,j,m} in place of ESC O {Q,R,S}. That's how the Windows keyboard handler has worked all along (it was a deliberate behaviour tweak for the Xterm-like function key mode, because in that mode ESC O {Q,R,S} are generated by F2-F4). But the GTK keyboard handler omitted that particular special case and was still sending ESC O {Q,R,S} for those keys in all application keypad modes. - also in Xterm function key mode plus app keypad mode, we only generates the app-keypad escape sequences if Num Lock is on; with Num Lock off, the numeric keypad becomes arrow keys and Home/End/etc, just as it would in non-app-keypad mode. Windows has done this all along, but again, GTK lacked that special case.
2018-12-08 08:25:32 +00:00
return p - output;
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
char xkey;
Centralise key escape sequences into terminal.c. A long time ago, in commit 4d77b6567, I moved the generation of the arrow-key escape sequences into a function format_arrow_key(). Mostly the reason for that was a special purpose I had in mind at the time which involved auto-generating the same sequences in response to things other than a keypress, but I always thought it would be nice to centralise a lot more of PuTTY's complicated keyboard handling in the same way - at least the handling of the function keys and their numerous static and dynamic config options. In this year's general spirit of tidying up and refactoring, I think it's finally time. So here I introduce three more centralised functions for dealing with the numbered function keys, the small keypad (Ins, Home, PgUp etc) and the numeric keypad. Lots of horrible and duplicated code from the key handling functions in window.c and gtkwin.c is now more sensibly centralised: each platform keyboard handler concerns itself with the local format of a keyboard event and platform-specific enumeration of key codes, and once it's decided what the logical key press actually _is_, it hands off to the new functions in terminal.c to generate the appropriate escape code. Mostly this is intended to be a refactoring without functional change, leaving the keyboard handling how it's always been. But in cases where the Windows and GTK handlers were accidentally inconsistent, I've fixed the inconsistency rather than carefully keeping both sides how they were. Known consistency fixes: - swapping the arrow keys between normal (ESC [ A) and application (ESC O A) is now done by pressing Ctrl with them, and _not_ by pressing Shift. That was how it was always supposed to work, and how it's worked on GTK all along, but on Windows it's been done by Shift as well since 2010, due to a bug at the call site of format_arrow_key() introduced when I originally wrote that function. - in Xterm function key mode plus application keypad mode, the /*- keys on the numeric keypad now send ESC O {o,j,m} in place of ESC O {Q,R,S}. That's how the Windows keyboard handler has worked all along (it was a deliberate behaviour tweak for the Xterm-like function key mode, because in that mode ESC O {Q,R,S} are generated by F2-F4). But the GTK keyboard handler omitted that particular special case and was still sending ESC O {Q,R,S} for those keys in all application keypad modes. - also in Xterm function key mode plus app keypad mode, we only generates the app-keypad escape sequences if Num Lock is on; with Num Lock off, the numeric keypad becomes arrow keys and Home/End/etc, just as it would in non-app-keypad mode. Windows has done this all along, but again, GTK lacked that special case.
2018-12-08 08:25:32 +00:00
case VK_UP: xkey = 'A'; goto arrow_key;
case VK_DOWN: xkey = 'B'; goto arrow_key;
case VK_RIGHT: xkey = 'C'; goto arrow_key;
case VK_LEFT: xkey = 'D'; goto arrow_key;
case VK_CLEAR: xkey = 'G'; goto arrow_key; /* close enough */
arrow_key:
Fix Alt handling in the new shifted-arrow-key support. As well as affecting the bitmap field in the escape sequence, it was _also_ having its otherwise standard effect of prefixing Esc to the whole sequence. It shouldn't do both.
2021-10-23 09:52:11 +00:00
consumed_alt = false;
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
p += format_arrow_key((char *)p, wgs->term, xkey, shift_state & 1,
Fix Alt handling in the new shifted-arrow-key support. As well as affecting the bitmap field in the escape sequence, it was _also_ having its otherwise standard effect of prefixing Esc to the whole sequence. It shouldn't do both.
2021-10-23 09:52:11 +00:00
shift_state & 2, left_alt, &consumed_alt);
Fix Xterm216+ Alt-Fn on Windows On most keyboard modes the escape-sequence for Alt-Fn is the same as for Fn alone but with an additional ESC prepended. However, this additional ESC should not be sent for keyboard modes that sends a different escape-sequence when Alt is pressed, like e.g. Xterm216+, as this is not expected by the server-side application. Signed-off-by: Anders Larsen <al@alarsen.net>
2024-10-01 08:08:28 +00:00
if (consumed_alt) {
/* supersedes the usual prefixing of Esc */
p -= 1;
memmove(output, output + 1, p - output);
}
Centralise key escape sequences into terminal.c. A long time ago, in commit 4d77b6567, I moved the generation of the arrow-key escape sequences into a function format_arrow_key(). Mostly the reason for that was a special purpose I had in mind at the time which involved auto-generating the same sequences in response to things other than a keypress, but I always thought it would be nice to centralise a lot more of PuTTY's complicated keyboard handling in the same way - at least the handling of the function keys and their numerous static and dynamic config options. In this year's general spirit of tidying up and refactoring, I think it's finally time. So here I introduce three more centralised functions for dealing with the numbered function keys, the small keypad (Ins, Home, PgUp etc) and the numeric keypad. Lots of horrible and duplicated code from the key handling functions in window.c and gtkwin.c is now more sensibly centralised: each platform keyboard handler concerns itself with the local format of a keyboard event and platform-specific enumeration of key codes, and once it's decided what the logical key press actually _is_, it hands off to the new functions in terminal.c to generate the appropriate escape code. Mostly this is intended to be a refactoring without functional change, leaving the keyboard handling how it's always been. But in cases where the Windows and GTK handlers were accidentally inconsistent, I've fixed the inconsistency rather than carefully keeping both sides how they were. Known consistency fixes: - swapping the arrow keys between normal (ESC [ A) and application (ESC O A) is now done by pressing Ctrl with them, and _not_ by pressing Shift. That was how it was always supposed to work, and how it's worked on GTK all along, but on Windows it's been done by Shift as well since 2010, due to a bug at the call site of format_arrow_key() introduced when I originally wrote that function. - in Xterm function key mode plus application keypad mode, the /*- keys on the numeric keypad now send ESC O {o,j,m} in place of ESC O {Q,R,S}. That's how the Windows keyboard handler has worked all along (it was a deliberate behaviour tweak for the Xterm-like function key mode, because in that mode ESC O {Q,R,S} are generated by F2-F4). But the GTK keyboard handler omitted that particular special case and was still sending ESC O {Q,R,S} for those keys in all application keypad modes. - also in Xterm function key mode plus app keypad mode, we only generates the app-keypad escape sequences if Num Lock is on; with Num Lock off, the numeric keypad becomes arrow keys and Home/End/etc, just as it would in non-app-keypad mode. Windows has done this all along, but again, GTK lacked that special case.
2018-12-08 08:25:32 +00:00
return p - output;
case VK_RETURN:
if (HIWORD(lParam) & KF_EXTENDED) {
keypad_key = '\r';
goto numeric_keypad;
}
Fix handling of Return and keypad Enter. The recent rewriting in both the GTK and Windows keyboard handlers left the keypad 'Enter' key in a bad state, when no override is enabled that causes it to generate an escape sequence. On Windows, a series of fallbacks was causing it to generate \r regardless of configuration, whereas in Telnet mode it should default to generating the special Telnet new-line sequence, and in response to ESC[20h (enabling term->cr_lf_return) it should generate \r\n. On GTK, it wasn't generating anything _at all_, and also, I can't see any evidence that the GTK keyboard handler had ever remembered to implement the cr_lf_return mode. Now Keypad Enter in non-escape-sequence mode should behave just like Return, on both platforms.
2019-04-15 19:43:10 +00:00
ordinary_return_key:
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
if (shift_state == 0 && wgs->term->cr_lf_return) {
Fix handling of Return and keypad Enter. The recent rewriting in both the GTK and Windows keyboard handlers left the keypad 'Enter' key in a bad state, when no override is enabled that causes it to generate an escape sequence. On Windows, a series of fallbacks was causing it to generate \r regardless of configuration, whereas in Telnet mode it should default to generating the special Telnet new-line sequence, and in response to ESC[20h (enabling term->cr_lf_return) it should generate \r\n. On GTK, it wasn't generating anything _at all_, and also, I can't see any evidence that the GTK keyboard handler had ever remembered to implement the cr_lf_return mode. Now Keypad Enter in non-escape-sequence mode should behave just like Return, on both platforms.
2019-04-15 19:43:10 +00:00
*p++ = '\r';
*p++ = '\n';
return p - output;
} else {
*p++ = 0x0D;
*p++ = 0;
return -2;
}
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
}
Add AltGr support at last! Thanks to <andre@via.ecp.fr> for the technique if not all of the details. [originally from svn r92]
1999-03-12 17:14:06 +00:00
}
Initial checkin: beta 0.43 [originally from svn r11]
1999-01-08 13:02:13 +00:00
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
/* Okay we've done everything interesting; let windows deal with
Robert de Bath's Big Patch, part 1 [originally from svn r516]
2000-07-26 12:13:51 +00:00
* the boring stuff */
{
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
bool capsOn = false;
/* helg: clear CAPS LOCK state if caps lock switches to cyrillic */
Formatting: normalise to put a space after condition keywords. 'if (thing)' is the local style here, not 'if(thing)'. Similarly with 'for' and 'while'.
2022-12-28 15:32:24 +00:00
if (keystate[VK_CAPITAL] != 0 &&
conf_get_bool(wgs->conf, CONF_xlat_capslockcyr)) {
Formatting: fix a few mis-spaced assignments. I spotted one of those in the raw backend the other day, and now I've got round to finding a bunch more and fixing them.
2022-12-28 15:28:36 +00:00
capsOn = !left_alt;
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
keystate[VK_CAPITAL] = 0;
}
Remove some pointless 'static' qualifiers. In windows/window.c, a few variables inside functions were declared as static, with no particular purpose that I can see: they don't seem to have any reason to persist between calls to the function. So it makes more sense to have them be ordinary stack-allocated automatic variables. Static variables removed by this commit: - 'RECT ss' in reset_window. - 'WORD keys[3]' and 'BYTE keysb[3]' in TranslateKey. - several (buffer, length) pairs in do_text_internal. - keys_unicode[] in TranslateKey. All of these variables were originally introduced in patches credited to Robert de Bath, which means I can't even try to reconstruct my original thought processes, because they weren't _my_ thoughts anyway. The arrays in do_text_internal are the easiest to understand: they're reallocated larger as necessary, and making them static means the allocation from a previous call can be reused, saving a malloc (though I don't think that's a good enough reason to bother, these days). The fixed-size static arrays and RECT are harder to explain. I suspect they might originally have been that way because of 1990s attitudes to performance: in x86-32 it's probably marginally faster to give your variables constant addresses than sp-relative ones, and in the 1990s computers were much slower, so there's an argument for making things static if you have no _need_ to make them automatic. These days, the difference is negligible, and persistent state is much more widely recognised as a risk! But keys_unicode[] is by far the strangest, because there was code that clearly _did_ expect it to persist between calls, namely three assignments to keys_unicode[0] near the end of the function after it's finished being used for any other purpose, and a conditioned-out set of debug() calls at the top of the function that print its contents before anything has yet written to it. But as far as I can see, the persistent data in the array is otherwise completely unused. In any call to the function, if keys_unicode is used at all, then it's either written directly by a call to ToAsciiEx, or else (for pre-NT platforms) converted from ToAsciiEx's output via MultiByteToWideChar. In both cases, the integer variable 'r' indicates how many array elements were written, and subsequent accesses only ever read those elements. So the assignments to keys_unicode[0] at the end of the previous call will be overwritten before anything at all can depend on them - with the exception of those debug statements. I don't really understand what was going on here. It's tempting to guess that those final assignments must have once done something useful, and the code that used them was later removed. But the source control history doesn't bear that out: a static array of three elements (under its original name 'keys') was introduced in commit 0d5d39064a0d078, and then commits 953b7775b321a60 and 26f1085038d7cd9 added the other two assignments. And as far as I can see, even as of the original commit 0d5d39064a0d078, the code already had the property that there was a final assignment to keys[0] which would inevitably be overwritten in the next call before it could affect anything. So I'm totally confused about what those assignments were _ever_ useful for. But an email thread from the time suggests that some of those patches were being rebased repeatedly past other work (or rather, the much less reliable CVS analogue of rebasing), so my best guess is that that's where the confusion crept in - perhaps in RDB's original version of the code they did do something useful. Regardless of that, I'm pretty convinced that persistent array can't be doing anything useful _now_. So I'm taking it out. But if anyone reports a bug resulting from this change, then I'll eat my words - and with any luck the details of the bug report will give us a clue what's going on, and then we can put back some equivalent functionality with much better comments!
2023-05-27 13:56:31 +00:00
wchar_t keys_unicode[3];
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
/* XXX how do we know what the max size of the keys array should
* be is? There's indication on MS' website of an Inquire/InquireEx
* functioning returning a KBINFO structure which tells us. */
if (osPlatformId == VER_PLATFORM_WIN32_NT && p_ToUnicodeEx) {
r = p_ToUnicodeEx(wParam, scan, keystate, keys_unicode,
Find ToUnicodeEx() at run time, not load time. This restores PuTTY's backward compatibility to versions of Windows too old to have ToUnicodeEx in their system libraries, which was accidentally broken in 0.63. [originally from svn r10061]
2013-11-17 14:03:20 +00:00
lenof(keys_unicode), 0, kbd_layout);
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
} else {
/* XXX 'keys' parameter is declared in MSDN documentation as
* 'LPWORD lpChar'.
* The experience of a French user indicates that on
* Win98, WORD[] should be passed in, but on Win2K, it should
* be BYTE[]. German WinXP and my Win2K with "US International"
* driver corroborate this.
* Experimentally I've conditionalised the behaviour on the
* Win9x/NT split, but I suspect it's worse than that.
* See wishlist item `win-dead-keys' for more horrible detail
* and speculations. */
int i;
Remove some pointless 'static' qualifiers. In windows/window.c, a few variables inside functions were declared as static, with no particular purpose that I can see: they don't seem to have any reason to persist between calls to the function. So it makes more sense to have them be ordinary stack-allocated automatic variables. Static variables removed by this commit: - 'RECT ss' in reset_window. - 'WORD keys[3]' and 'BYTE keysb[3]' in TranslateKey. - several (buffer, length) pairs in do_text_internal. - keys_unicode[] in TranslateKey. All of these variables were originally introduced in patches credited to Robert de Bath, which means I can't even try to reconstruct my original thought processes, because they weren't _my_ thoughts anyway. The arrays in do_text_internal are the easiest to understand: they're reallocated larger as necessary, and making them static means the allocation from a previous call can be reused, saving a malloc (though I don't think that's a good enough reason to bother, these days). The fixed-size static arrays and RECT are harder to explain. I suspect they might originally have been that way because of 1990s attitudes to performance: in x86-32 it's probably marginally faster to give your variables constant addresses than sp-relative ones, and in the 1990s computers were much slower, so there's an argument for making things static if you have no _need_ to make them automatic. These days, the difference is negligible, and persistent state is much more widely recognised as a risk! But keys_unicode[] is by far the strangest, because there was code that clearly _did_ expect it to persist between calls, namely three assignments to keys_unicode[0] near the end of the function after it's finished being used for any other purpose, and a conditioned-out set of debug() calls at the top of the function that print its contents before anything has yet written to it. But as far as I can see, the persistent data in the array is otherwise completely unused. In any call to the function, if keys_unicode is used at all, then it's either written directly by a call to ToAsciiEx, or else (for pre-NT platforms) converted from ToAsciiEx's output via MultiByteToWideChar. In both cases, the integer variable 'r' indicates how many array elements were written, and subsequent accesses only ever read those elements. So the assignments to keys_unicode[0] at the end of the previous call will be overwritten before anything at all can depend on them - with the exception of those debug statements. I don't really understand what was going on here. It's tempting to guess that those final assignments must have once done something useful, and the code that used them was later removed. But the source control history doesn't bear that out: a static array of three elements (under its original name 'keys') was introduced in commit 0d5d39064a0d078, and then commits 953b7775b321a60 and 26f1085038d7cd9 added the other two assignments. And as far as I can see, even as of the original commit 0d5d39064a0d078, the code already had the property that there was a final assignment to keys[0] which would inevitably be overwritten in the next call before it could affect anything. So I'm totally confused about what those assignments were _ever_ useful for. But an email thread from the time suggests that some of those patches were being rebased repeatedly past other work (or rather, the much less reliable CVS analogue of rebasing), so my best guess is that that's where the confusion crept in - perhaps in RDB's original version of the code they did do something useful. Regardless of that, I'm pretty convinced that persistent array can't be doing anything useful _now_. So I'm taking it out. But if anyone reports a bug resulting from this change, then I'll eat my words - and with any luck the details of the bug report will give us a clue what's going on, and then we can put back some equivalent functionality with much better comments!
2023-05-27 13:56:31 +00:00
WORD keys[3];
BYTE keysb[3];
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
r = ToAsciiEx(wParam, scan, keystate, keys, 0, kbd_layout);
if (r > 0) {
for (i = 0; i < r; i++) {
keysb[i] = (BYTE)keys[i];
}
MultiByteToWideChar(CP_ACP, 0, (LPCSTR)keysb, r,
Switch to translating keystrokes using ToUnicodeEx rather than ToAsciiEx, where possible. This enables support for keys which generate Unicode characters that aren't in the system code page, which seems to me like a perverse way for Windows to have set up the system code page but apparently does happen, e.g. (I'm told) U+0219 and U+021B on Romanian keyboards. Patch mostly due to Andrei Damian-Fekete. [originally from svn r9942]
2013-07-20 11:31:24 +00:00
keys_unicode, lenof(keys_unicode));
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
}
}
RDB's Unicode patch. Fonts are now used in Unicode mode where possible and we have a single unified means of trying to display any Unicode code point. Instead of the various ad-hoc translation modes we had before, we now have a single `codepage' option which allows us to treat the incoming (and outgoing) text as any given character set, and locally we map that to Unicode and back. [originally from svn r1110]
2001-05-10 08:34:20 +00:00
#ifdef SHOW_TOASCII_RESULT
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
if (r == 1 && !key_down) {
windows/window.c: move more variables into WinGuiSeat. In commit f9e572595bb8cb6 I claimed that I'd removed very nearly all the global and static variables from windows/window.c. It turns out that this was wildly overoptimistic - I missed quite a few of them! I'm not quite sure how I managed that; my best guess is that I used an underpowered 'nm' command that failed to find some classes of variable. Some of the remaining function-scope statics were removed completely by commit afb3dab1e97a09f just now. In this commit, I've swept up some more and turn them into fields of WinGuiSeat, where they should have been moved last September. The (hopefully complete this time) list of remaining variables, generated by running this rune in the Windows build directory: nm windows/CMakeFiles/putty.dir/window.c.obj | grep -E '^([^ ]+)? *[bBcCdDgGsS] [^\.]' consists of the following variables which are legitimately global across the whole process and not related to a particular window: - 'hinst' and 'hprev', instance handles for Windows loadable modules - 'classname' in the terminal_window_class_a() and terminal_window_class_w() functions, which allocate a window class reusably - some pointers to Windows API functions retrieved via the DECL_WINDOWS_FUNCTION / GET_WINDOWS_FUNCTION system, such as p_AdjustWindowRectExForDpi and p_FlashWindowEx - some pointers to Windows API functions set up by assigning them at startup to the right one of the ANSI or Unicode version depending on the Windows version, e.g. sw_DefWindowProc and sw_DispatchMessage - 'unicode_window', a boolean flag set at the same time as those sw_Foo function pointers - 'sesslist', storing the last-retrieved version of the saved sessions menu - 'cursor_visible' in show_mouseptr() and 'forced_visible' in update_mouse_pointer(), each of which tracks the cumulative number of times that function has shown or hidden the mouse pointer, so as to manage its effect on the global state updated by ShowCursor - 'trust_icon', loaded from the executable's resources - 'wgslisthead', the list of all active WinGuiSeats - 'wm_mousewheel', the window-message id we use for mouse wheel events and the following which are nothing to do with our code: - '_OptionsStorage' in __local_stdio_printf_options() and __local_stdio_scanf_options(), which I'd never noticed before, but apparently are internal to a standard library header.
2023-05-27 13:59:20 +00:00
if (wgs->alt_numberpad_accumulator) {
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
if (in_utf(term) || ucsdata.dbcs_screenfont)
windows/window.c: move more variables into WinGuiSeat. In commit f9e572595bb8cb6 I claimed that I'd removed very nearly all the global and static variables from windows/window.c. It turns out that this was wildly overoptimistic - I missed quite a few of them! I'm not quite sure how I managed that; my best guess is that I used an underpowered 'nm' command that failed to find some classes of variable. Some of the remaining function-scope statics were removed completely by commit afb3dab1e97a09f just now. In this commit, I've swept up some more and turn them into fields of WinGuiSeat, where they should have been moved last September. The (hopefully complete this time) list of remaining variables, generated by running this rune in the Windows build directory: nm windows/CMakeFiles/putty.dir/window.c.obj | grep -E '^([^ ]+)? *[bBcCdDgGsS] [^\.]' consists of the following variables which are legitimately global across the whole process and not related to a particular window: - 'hinst' and 'hprev', instance handles for Windows loadable modules - 'classname' in the terminal_window_class_a() and terminal_window_class_w() functions, which allocate a window class reusably - some pointers to Windows API functions retrieved via the DECL_WINDOWS_FUNCTION / GET_WINDOWS_FUNCTION system, such as p_AdjustWindowRectExForDpi and p_FlashWindowEx - some pointers to Windows API functions set up by assigning them at startup to the right one of the ANSI or Unicode version depending on the Windows version, e.g. sw_DefWindowProc and sw_DispatchMessage - 'unicode_window', a boolean flag set at the same time as those sw_Foo function pointers - 'sesslist', storing the last-retrieved version of the saved sessions menu - 'cursor_visible' in show_mouseptr() and 'forced_visible' in update_mouse_pointer(), each of which tracks the cumulative number of times that function has shown or hidden the mouse pointer, so as to manage its effect on the global state updated by ShowCursor - 'trust_icon', loaded from the executable's resources - 'wgslisthead', the list of all active WinGuiSeats - 'wm_mousewheel', the window-message id we use for mouse wheel events and the following which are nothing to do with our code: - '_OptionsStorage' in __local_stdio_printf_options() and __local_stdio_scanf_options(), which I'd never noticed before, but apparently are internal to a standard library header.
2023-05-27 13:59:20 +00:00
debug(", (U+%04x)", wgs->alt_numberpad_accumulator);
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
else
windows/window.c: move more variables into WinGuiSeat. In commit f9e572595bb8cb6 I claimed that I'd removed very nearly all the global and static variables from windows/window.c. It turns out that this was wildly overoptimistic - I missed quite a few of them! I'm not quite sure how I managed that; my best guess is that I used an underpowered 'nm' command that failed to find some classes of variable. Some of the remaining function-scope statics were removed completely by commit afb3dab1e97a09f just now. In this commit, I've swept up some more and turn them into fields of WinGuiSeat, where they should have been moved last September. The (hopefully complete this time) list of remaining variables, generated by running this rune in the Windows build directory: nm windows/CMakeFiles/putty.dir/window.c.obj | grep -E '^([^ ]+)? *[bBcCdDgGsS] [^\.]' consists of the following variables which are legitimately global across the whole process and not related to a particular window: - 'hinst' and 'hprev', instance handles for Windows loadable modules - 'classname' in the terminal_window_class_a() and terminal_window_class_w() functions, which allocate a window class reusably - some pointers to Windows API functions retrieved via the DECL_WINDOWS_FUNCTION / GET_WINDOWS_FUNCTION system, such as p_AdjustWindowRectExForDpi and p_FlashWindowEx - some pointers to Windows API functions set up by assigning them at startup to the right one of the ANSI or Unicode version depending on the Windows version, e.g. sw_DefWindowProc and sw_DispatchMessage - 'unicode_window', a boolean flag set at the same time as those sw_Foo function pointers - 'sesslist', storing the last-retrieved version of the saved sessions menu - 'cursor_visible' in show_mouseptr() and 'forced_visible' in update_mouse_pointer(), each of which tracks the cumulative number of times that function has shown or hidden the mouse pointer, so as to manage its effect on the global state updated by ShowCursor - 'trust_icon', loaded from the executable's resources - 'wgslisthead', the list of all active WinGuiSeats - 'wm_mousewheel', the window-message id we use for mouse wheel events and the following which are nothing to do with our code: - '_OptionsStorage' in __local_stdio_printf_options() and __local_stdio_scanf_options(), which I'd never noticed before, but apparently are internal to a standard library header.
2023-05-27 13:59:20 +00:00
debug(", LCH(%d)", wgs->alt_numberpad_accumulator);
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
} else {
debug(", ACH(%d)", keys_unicode[0]);
}
} else if (r > 0) {
int r1;
debug(", ASC(");
for (r1 = 0; r1 < r; r1++) {
debug("%s%d", r1 ? "," : "", keys_unicode[r1]);
}
debug(")");
}
RDB's Unicode patch. Fonts are now used in Unicode mode where possible and we have a single unified means of trying to display any Unicode code point. Instead of the various ad-hoc translation modes we had before, we now have a single `codepage' option which allows us to treat the incoming (and outgoing) text as any given character set, and locally we map that to Unicode and back. [originally from svn r1110]
2001-05-10 08:34:20 +00:00
#endif
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
if (r > 0) {
WCHAR keybuf;
p = output;
for (i = 0; i < r; i++) {
wchar_t wch = keys_unicode[i];
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
if (wgs->compose_state == 2 && wch >= ' ' && wch < 0x80) {
windows/window.c: move more variables into WinGuiSeat. In commit f9e572595bb8cb6 I claimed that I'd removed very nearly all the global and static variables from windows/window.c. It turns out that this was wildly overoptimistic - I missed quite a few of them! I'm not quite sure how I managed that; my best guess is that I used an underpowered 'nm' command that failed to find some classes of variable. Some of the remaining function-scope statics were removed completely by commit afb3dab1e97a09f just now. In this commit, I've swept up some more and turn them into fields of WinGuiSeat, where they should have been moved last September. The (hopefully complete this time) list of remaining variables, generated by running this rune in the Windows build directory: nm windows/CMakeFiles/putty.dir/window.c.obj | grep -E '^([^ ]+)? *[bBcCdDgGsS] [^\.]' consists of the following variables which are legitimately global across the whole process and not related to a particular window: - 'hinst' and 'hprev', instance handles for Windows loadable modules - 'classname' in the terminal_window_class_a() and terminal_window_class_w() functions, which allocate a window class reusably - some pointers to Windows API functions retrieved via the DECL_WINDOWS_FUNCTION / GET_WINDOWS_FUNCTION system, such as p_AdjustWindowRectExForDpi and p_FlashWindowEx - some pointers to Windows API functions set up by assigning them at startup to the right one of the ANSI or Unicode version depending on the Windows version, e.g. sw_DefWindowProc and sw_DispatchMessage - 'unicode_window', a boolean flag set at the same time as those sw_Foo function pointers - 'sesslist', storing the last-retrieved version of the saved sessions menu - 'cursor_visible' in show_mouseptr() and 'forced_visible' in update_mouse_pointer(), each of which tracks the cumulative number of times that function has shown or hidden the mouse pointer, so as to manage its effect on the global state updated by ShowCursor - 'trust_icon', loaded from the executable's resources - 'wgslisthead', the list of all active WinGuiSeats - 'wm_mousewheel', the window-message id we use for mouse wheel events and the following which are nothing to do with our code: - '_OptionsStorage' in __local_stdio_printf_options() and __local_stdio_scanf_options(), which I'd never noticed before, but apparently are internal to a standard library header.
2023-05-27 13:59:20 +00:00
wgs->compose_char = wch;
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
wgs->compose_state++;
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
continue;
}
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
if (wgs->compose_state == 3 && wch >= ' ' && wch < 0x80) {
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
int nc;
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
wgs->compose_state = 0;
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
windows/window.c: move more variables into WinGuiSeat. In commit f9e572595bb8cb6 I claimed that I'd removed very nearly all the global and static variables from windows/window.c. It turns out that this was wildly overoptimistic - I missed quite a few of them! I'm not quite sure how I managed that; my best guess is that I used an underpowered 'nm' command that failed to find some classes of variable. Some of the remaining function-scope statics were removed completely by commit afb3dab1e97a09f just now. In this commit, I've swept up some more and turn them into fields of WinGuiSeat, where they should have been moved last September. The (hopefully complete this time) list of remaining variables, generated by running this rune in the Windows build directory: nm windows/CMakeFiles/putty.dir/window.c.obj | grep -E '^([^ ]+)? *[bBcCdDgGsS] [^\.]' consists of the following variables which are legitimately global across the whole process and not related to a particular window: - 'hinst' and 'hprev', instance handles for Windows loadable modules - 'classname' in the terminal_window_class_a() and terminal_window_class_w() functions, which allocate a window class reusably - some pointers to Windows API functions retrieved via the DECL_WINDOWS_FUNCTION / GET_WINDOWS_FUNCTION system, such as p_AdjustWindowRectExForDpi and p_FlashWindowEx - some pointers to Windows API functions set up by assigning them at startup to the right one of the ANSI or Unicode version depending on the Windows version, e.g. sw_DefWindowProc and sw_DispatchMessage - 'unicode_window', a boolean flag set at the same time as those sw_Foo function pointers - 'sesslist', storing the last-retrieved version of the saved sessions menu - 'cursor_visible' in show_mouseptr() and 'forced_visible' in update_mouse_pointer(), each of which tracks the cumulative number of times that function has shown or hidden the mouse pointer, so as to manage its effect on the global state updated by ShowCursor - 'trust_icon', loaded from the executable's resources - 'wgslisthead', the list of all active WinGuiSeats - 'wm_mousewheel', the window-message id we use for mouse wheel events and the following which are nothing to do with our code: - '_OptionsStorage' in __local_stdio_printf_options() and __local_stdio_scanf_options(), which I'd never noticed before, but apparently are internal to a standard library header.
2023-05-27 13:59:20 +00:00
if ((nc = check_compose(wgs->compose_char, wch)) == -1) {
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
MessageBeep(MB_ICONHAND);
return 0;
}
keybuf = nc;
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
term_keyinputw(wgs->term, &keybuf, 1);
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
continue;
}
Initial checkin: beta 0.43 [originally from svn r11]
1999-01-08 13:02:13 +00:00
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
wgs->compose_state = 0;
Initial checkin: beta 0.43 [originally from svn r11]
1999-01-08 13:02:13 +00:00
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
if (!key_down) {
windows/window.c: move more variables into WinGuiSeat. In commit f9e572595bb8cb6 I claimed that I'd removed very nearly all the global and static variables from windows/window.c. It turns out that this was wildly overoptimistic - I missed quite a few of them! I'm not quite sure how I managed that; my best guess is that I used an underpowered 'nm' command that failed to find some classes of variable. Some of the remaining function-scope statics were removed completely by commit afb3dab1e97a09f just now. In this commit, I've swept up some more and turn them into fields of WinGuiSeat, where they should have been moved last September. The (hopefully complete this time) list of remaining variables, generated by running this rune in the Windows build directory: nm windows/CMakeFiles/putty.dir/window.c.obj | grep -E '^([^ ]+)? *[bBcCdDgGsS] [^\.]' consists of the following variables which are legitimately global across the whole process and not related to a particular window: - 'hinst' and 'hprev', instance handles for Windows loadable modules - 'classname' in the terminal_window_class_a() and terminal_window_class_w() functions, which allocate a window class reusably - some pointers to Windows API functions retrieved via the DECL_WINDOWS_FUNCTION / GET_WINDOWS_FUNCTION system, such as p_AdjustWindowRectExForDpi and p_FlashWindowEx - some pointers to Windows API functions set up by assigning them at startup to the right one of the ANSI or Unicode version depending on the Windows version, e.g. sw_DefWindowProc and sw_DispatchMessage - 'unicode_window', a boolean flag set at the same time as those sw_Foo function pointers - 'sesslist', storing the last-retrieved version of the saved sessions menu - 'cursor_visible' in show_mouseptr() and 'forced_visible' in update_mouse_pointer(), each of which tracks the cumulative number of times that function has shown or hidden the mouse pointer, so as to manage its effect on the global state updated by ShowCursor - 'trust_icon', loaded from the executable's resources - 'wgslisthead', the list of all active WinGuiSeats - 'wm_mousewheel', the window-message id we use for mouse wheel events and the following which are nothing to do with our code: - '_OptionsStorage' in __local_stdio_printf_options() and __local_stdio_scanf_options(), which I'd never noticed before, but apparently are internal to a standard library header.
2023-05-27 13:59:20 +00:00
if (wgs->alt_numberpad_accumulator) {
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
if (in_utf(wgs->term) ||
wgs->ucsdata.dbcs_screenfont) {
windows/window.c: move more variables into WinGuiSeat. In commit f9e572595bb8cb6 I claimed that I'd removed very nearly all the global and static variables from windows/window.c. It turns out that this was wildly overoptimistic - I missed quite a few of them! I'm not quite sure how I managed that; my best guess is that I used an underpowered 'nm' command that failed to find some classes of variable. Some of the remaining function-scope statics were removed completely by commit afb3dab1e97a09f just now. In this commit, I've swept up some more and turn them into fields of WinGuiSeat, where they should have been moved last September. The (hopefully complete this time) list of remaining variables, generated by running this rune in the Windows build directory: nm windows/CMakeFiles/putty.dir/window.c.obj | grep -E '^([^ ]+)? *[bBcCdDgGsS] [^\.]' consists of the following variables which are legitimately global across the whole process and not related to a particular window: - 'hinst' and 'hprev', instance handles for Windows loadable modules - 'classname' in the terminal_window_class_a() and terminal_window_class_w() functions, which allocate a window class reusably - some pointers to Windows API functions retrieved via the DECL_WINDOWS_FUNCTION / GET_WINDOWS_FUNCTION system, such as p_AdjustWindowRectExForDpi and p_FlashWindowEx - some pointers to Windows API functions set up by assigning them at startup to the right one of the ANSI or Unicode version depending on the Windows version, e.g. sw_DefWindowProc and sw_DispatchMessage - 'unicode_window', a boolean flag set at the same time as those sw_Foo function pointers - 'sesslist', storing the last-retrieved version of the saved sessions menu - 'cursor_visible' in show_mouseptr() and 'forced_visible' in update_mouse_pointer(), each of which tracks the cumulative number of times that function has shown or hidden the mouse pointer, so as to manage its effect on the global state updated by ShowCursor - 'trust_icon', loaded from the executable's resources - 'wgslisthead', the list of all active WinGuiSeats - 'wm_mousewheel', the window-message id we use for mouse wheel events and the following which are nothing to do with our code: - '_OptionsStorage' in __local_stdio_printf_options() and __local_stdio_scanf_options(), which I'd never noticed before, but apparently are internal to a standard library header.
2023-05-27 13:59:20 +00:00
keybuf = wgs->alt_numberpad_accumulator;
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
term_keyinputw(wgs->term, &keybuf, 1);
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
} else {
windows/window.c: move more variables into WinGuiSeat. In commit f9e572595bb8cb6 I claimed that I'd removed very nearly all the global and static variables from windows/window.c. It turns out that this was wildly overoptimistic - I missed quite a few of them! I'm not quite sure how I managed that; my best guess is that I used an underpowered 'nm' command that failed to find some classes of variable. Some of the remaining function-scope statics were removed completely by commit afb3dab1e97a09f just now. In this commit, I've swept up some more and turn them into fields of WinGuiSeat, where they should have been moved last September. The (hopefully complete this time) list of remaining variables, generated by running this rune in the Windows build directory: nm windows/CMakeFiles/putty.dir/window.c.obj | grep -E '^([^ ]+)? *[bBcCdDgGsS] [^\.]' consists of the following variables which are legitimately global across the whole process and not related to a particular window: - 'hinst' and 'hprev', instance handles for Windows loadable modules - 'classname' in the terminal_window_class_a() and terminal_window_class_w() functions, which allocate a window class reusably - some pointers to Windows API functions retrieved via the DECL_WINDOWS_FUNCTION / GET_WINDOWS_FUNCTION system, such as p_AdjustWindowRectExForDpi and p_FlashWindowEx - some pointers to Windows API functions set up by assigning them at startup to the right one of the ANSI or Unicode version depending on the Windows version, e.g. sw_DefWindowProc and sw_DispatchMessage - 'unicode_window', a boolean flag set at the same time as those sw_Foo function pointers - 'sesslist', storing the last-retrieved version of the saved sessions menu - 'cursor_visible' in show_mouseptr() and 'forced_visible' in update_mouse_pointer(), each of which tracks the cumulative number of times that function has shown or hidden the mouse pointer, so as to manage its effect on the global state updated by ShowCursor - 'trust_icon', loaded from the executable's resources - 'wgslisthead', the list of all active WinGuiSeats - 'wm_mousewheel', the window-message id we use for mouse wheel events and the following which are nothing to do with our code: - '_OptionsStorage' in __local_stdio_printf_options() and __local_stdio_scanf_options(), which I'd never noticed before, but apparently are internal to a standard library header.
2023-05-27 13:59:20 +00:00
char ch = (char) wgs->alt_numberpad_accumulator;
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
/*
* We need not bother about stdin
* backlogs here, because in GUI PuTTY
* we can't do anything about it
* anyway; there's no means of asking
* Windows to hold off on KEYDOWN
* messages. We _have_ to buffer
* everything we're sent.
*/
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
term_keyinput(wgs->term, -1, &ch, 1);
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
}
windows/window.c: move more variables into WinGuiSeat. In commit f9e572595bb8cb6 I claimed that I'd removed very nearly all the global and static variables from windows/window.c. It turns out that this was wildly overoptimistic - I missed quite a few of them! I'm not quite sure how I managed that; my best guess is that I used an underpowered 'nm' command that failed to find some classes of variable. Some of the remaining function-scope statics were removed completely by commit afb3dab1e97a09f just now. In this commit, I've swept up some more and turn them into fields of WinGuiSeat, where they should have been moved last September. The (hopefully complete this time) list of remaining variables, generated by running this rune in the Windows build directory: nm windows/CMakeFiles/putty.dir/window.c.obj | grep -E '^([^ ]+)? *[bBcCdDgGsS] [^\.]' consists of the following variables which are legitimately global across the whole process and not related to a particular window: - 'hinst' and 'hprev', instance handles for Windows loadable modules - 'classname' in the terminal_window_class_a() and terminal_window_class_w() functions, which allocate a window class reusably - some pointers to Windows API functions retrieved via the DECL_WINDOWS_FUNCTION / GET_WINDOWS_FUNCTION system, such as p_AdjustWindowRectExForDpi and p_FlashWindowEx - some pointers to Windows API functions set up by assigning them at startup to the right one of the ANSI or Unicode version depending on the Windows version, e.g. sw_DefWindowProc and sw_DispatchMessage - 'unicode_window', a boolean flag set at the same time as those sw_Foo function pointers - 'sesslist', storing the last-retrieved version of the saved sessions menu - 'cursor_visible' in show_mouseptr() and 'forced_visible' in update_mouse_pointer(), each of which tracks the cumulative number of times that function has shown or hidden the mouse pointer, so as to manage its effect on the global state updated by ShowCursor - 'trust_icon', loaded from the executable's resources - 'wgslisthead', the list of all active WinGuiSeats - 'wm_mousewheel', the window-message id we use for mouse wheel events and the following which are nothing to do with our code: - '_OptionsStorage' in __local_stdio_printf_options() and __local_stdio_scanf_options(), which I'd never noticed before, but apparently are internal to a standard library header.
2023-05-27 13:59:20 +00:00
wgs->alt_numberpad_accumulator = 0;
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
} else {
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
term_keyinputw(wgs->term, &wch, 1);
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
}
} else {
Formatting: normalise to put a space after condition keywords. 'if (thing)' is the local style here, not 'if(thing)'. Similarly with 'for' and 'while'.
2022-12-28 15:32:24 +00:00
if (capsOn && wch < 0x80) {
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
WCHAR cbuf[2];
cbuf[0] = 27;
cbuf[1] = xlat_uskbd2cyrllic(wch);
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
term_keyinputw(
wgs->term, cbuf+!left_alt, 1+!!left_alt);
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
} else {
WCHAR cbuf[2];
cbuf[0] = '\033';
cbuf[1] = wch;
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
term_keyinputw(
wgs->term, cbuf +!left_alt, 1+!!left_alt);
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
}
}
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
show_mouseptr(wgs, false);
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
}
return p - output;
}
Initial checkin: beta 0.43 [originally from svn r11]
1999-01-08 13:02:13 +00:00
}
Robert de Bath's `Patch.a_alt_key': clean up the handling of Alt-Space, Alt-only and the System menu. It lets Windows do more of the work, and also saves a static variable, so it must be good :-) [originally from svn r1237]
2001-09-07 21:39:03 +00:00
/*
* ALT alone may or may not want to bring up the System menu.
* If it's not meant to, we return 0 on presses or releases of
* ALT, to show that we've swallowed the keystroke. Otherwise
* we return -1, which means Windows will give the keystroke
* its default handling (i.e. bring up the System menu).
*/
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
if (wParam == VK_MENU && !conf_get_bool(wgs->conf, CONF_alt_only))
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
return 0;
Initial checkin: beta 0.43 [originally from svn r11]
1999-01-08 13:02:13 +00:00
Robert de Bath's Big Patch, part 1 [originally from svn r516]
2000-07-26 12:13:51 +00:00
return -1;
Initial checkin: beta 0.43 [originally from svn r11]
1999-01-08 13:02:13 +00:00
}
win_set_[icon_]title: send a codepage along with the string. While fixing the previous commit I noticed that window titles don't actually _work_ properly if you change the terminal character set, because the text accumulated in the OSC string buffer is sent to the TermWin as raw bytes, with no indication of what character set it should interpret them as. You might get lucky if you happened to choose the right charset (in particular, UTF-8 is a common default), but if you change the charset half way through a run, then there's certainly no way the frontend will know to interpret two window titles sent before and after the change in two different charsets. So, now win_set_title() and win_set_icon_title() both include a codepage parameter along with the byte string, and it's up to them to translate the provided window title from that encoding to whatever the local window system expects to receive. On Windows, that's wide-string Unicode, so we can just use the existing dup_mb_to_wc utility function. But in GTK, it's UTF-8, so I had to write an extra utility function to encode a wide string as UTF-8.
2021-10-16 12:20:44 +00:00
static void wintw_set_title(TermWin *tw, const char *title, int codepage)
Run entire source base through GNU indent to tidy up the varying coding styles of the various contributors! Woohoo! [originally from svn r1098]
2001-05-06 14:35:20 +00:00
{
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
WinGuiSeat *wgs = container_of(tw, WinGuiSeat, termwin);
dup_mb_to_wc, dup_wc_to_mb: remove the 'flags' parameter. This parameter was undocumented, and Windows-specific: its semantics date from before PuTTY was cross-platform, and are "Pass this flags parameter straight through to the Win32 API's conversion functions". So in Windows platform code you can pass flags like MB_USEGLYPHCHARS, but in cross-platform code, you dare not pass anything nonzero at all because the Unix frontend won't recognise it (or, likely, even compile). I've kept the flag for now in the underlying mb_to_wc / wc_to_mb functions. Partly that's because there's one place in the Windows code where the parameter _is_ used; mostly, it's because I'm about to replace those functions anyway, so there's no point in editing all the call sites twice.
2024-09-24 07:46:39 +00:00
wchar_t *new_window_name = dup_mb_to_wc(codepage, title);
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
if (!wcscmp(new_window_name, wgs->window_name)) {
Windows: avoid idempotent window title changes. By testing on a platform slow enough to show the flicker, I happened to notice that if your shell prompt resets the window title every time it's displayed, this was actually resulting in a call to SetWindowText every time, which caused the GUI to actually do work. There's certainly no need for that! We can at least avoid bothering if the new title is identical to the old one.
2022-03-12 17:36:54 +00:00
sfree(new_window_name);
return;
}
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
sfree(wgs->window_name);
wgs->window_name = new_window_name;
if (conf_get_bool(wgs->conf, CONF_win_name_always) ||
!IsIconic(wgs->term_hwnd))
sw_SetWindowText(wgs->term_hwnd, wgs->window_name);
Initial checkin: beta 0.43 [originally from svn r11]
1999-01-08 13:02:13 +00:00
}
win_set_[icon_]title: send a codepage along with the string. While fixing the previous commit I noticed that window titles don't actually _work_ properly if you change the terminal character set, because the text accumulated in the OSC string buffer is sent to the TermWin as raw bytes, with no indication of what character set it should interpret them as. You might get lucky if you happened to choose the right charset (in particular, UTF-8 is a common default), but if you change the charset half way through a run, then there's certainly no way the frontend will know to interpret two window titles sent before and after the change in two different charsets. So, now win_set_title() and win_set_icon_title() both include a codepage parameter along with the byte string, and it's up to them to translate the provided window title from that encoding to whatever the local window system expects to receive. On Windows, that's wide-string Unicode, so we can just use the existing dup_mb_to_wc utility function. But in GTK, it's UTF-8, so I had to write an extra utility function to encode a wide string as UTF-8.
2021-10-16 12:20:44 +00:00
static void wintw_set_icon_title(TermWin *tw, const char *title, int codepage)
Run entire source base through GNU indent to tidy up the varying coding styles of the various contributors! Woohoo! [originally from svn r1098]
2001-05-06 14:35:20 +00:00
{
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
WinGuiSeat *wgs = container_of(tw, WinGuiSeat, termwin);
dup_mb_to_wc, dup_wc_to_mb: remove the 'flags' parameter. This parameter was undocumented, and Windows-specific: its semantics date from before PuTTY was cross-platform, and are "Pass this flags parameter straight through to the Win32 API's conversion functions". So in Windows platform code you can pass flags like MB_USEGLYPHCHARS, but in cross-platform code, you dare not pass anything nonzero at all because the Unix frontend won't recognise it (or, likely, even compile). I've kept the flag for now in the underlying mb_to_wc / wc_to_mb functions. Partly that's because there's one place in the Windows code where the parameter _is_ used; mostly, it's because I'm about to replace those functions anyway, so there's no point in editing all the call sites twice.
2024-09-24 07:46:39 +00:00
wchar_t *new_icon_name = dup_mb_to_wc(codepage, title);
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
if (!wcscmp(new_icon_name, wgs->icon_name)) {
Windows: avoid idempotent window title changes. By testing on a platform slow enough to show the flicker, I happened to notice that if your shell prompt resets the window title every time it's displayed, this was actually resulting in a call to SetWindowText every time, which caused the GUI to actually do work. There's certainly no need for that! We can at least avoid bothering if the new title is identical to the old one.
2022-03-12 17:36:54 +00:00
sfree(new_icon_name);
return;
}
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
sfree(wgs->icon_name);
wgs->icon_name = new_icon_name;
if (!conf_get_bool(wgs->conf, CONF_win_name_always) &&
IsIconic(wgs->term_hwnd))
sw_SetWindowText(wgs->term_hwnd, wgs->icon_name);
Initial checkin: beta 0.43 [originally from svn r11]
1999-01-08 13:02:13 +00:00
}
Remove the 'Frontend' type and replace it with a vtable. After the recent Seat and LogContext revamps, _nearly_ all the remaining uses of the type 'Frontend' were in terminal.c, which needs all sorts of interactions with the GUI window the terminal lives in, from the obvious (actually drawing text on the window, reading and writing the clipboard) to the obscure (minimising, maximising and moving the window in response to particular escape sequences). All of those functions are now provided by an abstraction called TermWin. The few remaining uses of Frontend after _that_ are internal to a particular platform directory, so as to spread the implementation of that particular kind of Frontend between multiple source files; so I've renamed all of those so that they take a more specifically named type that refers to the particular implementation rather than the general abstraction. So now the name 'Frontend' no longer exists in the code base at all, and everywhere one used to be used, it's completely clear whether it was operating in one of Frontend's three abstract roles (and if so, which), or whether it was specific to a particular implementation. Another type that's disappeared is 'Context', which used to be a typedef defined to something different on each platform, describing whatever short-lived resources were necessary to draw on the terminal window: the front end would provide a ready-made one when calling term_paint, and the terminal could request one with get_ctx/free_ctx if it wanted to do proactive window updates. Now that drawing context lives inside the TermWin itself, because there was never any need to have two of those contexts live at the same time. (Another minor API change is that the window-title functions - both reading and writing - have had a missing 'const' added to their char * parameters / return values.) I don't expect this change to enable any particularly interesting new functionality (in particular, I have no plans that need more than one implementation of TermWin in the same application). But it completes the tidying-up that began with the Seat and LogContext rework.
2018-10-25 17:44:04 +00:00
static void wintw_set_scrollbar(TermWin *tw, int total, int start, int page)
Run entire source base through GNU indent to tidy up the varying coding styles of the various contributors! Woohoo! [originally from svn r1098]
2001-05-06 14:35:20 +00:00
{
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
WinGuiSeat *wgs = container_of(tw, WinGuiSeat, termwin);
Initial checkin: beta 0.43 [originally from svn r11]
1999-01-08 13:02:13 +00:00
SCROLLINFO si;
Robert de Bath's Big Patch, part 1 [originally from svn r516]
2000-07-26 12:13:51 +00:00
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
if (!conf_get_bool(wgs->conf, is_full_screen(wgs) ?
Switch some Conf settings over to being bool. I think this is the full set of things that ought logically to be boolean. One annoyance is that quite a few radio-button controls in config.c address Conf fields that are now bool rather than int, which means that the shared handler function can't just access them all with conf_{get,set}_int. Rather than back out the rigorous separation of int and bool in conf.c itself, I've just added a similar alternative handler function for the bool-typed ones.
2018-10-29 19:57:31 +00:00
CONF_scrollbar_in_fullscreen : CONF_scrollbar))
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
return;
Robert de Bath's Big Patch, part 1 [originally from svn r516]
2000-07-26 12:13:51 +00:00
Initial checkin: beta 0.43 [originally from svn r11]
1999-01-08 13:02:13 +00:00
si.cbSize = sizeof(si);
Robert de Bath's Big Patch, part 1 [originally from svn r516]
2000-07-26 12:13:51 +00:00
si.fMask = SIF_ALL | SIF_DISABLENOSCROLL;
Initial checkin: beta 0.43 [originally from svn r11]
1999-01-08 13:02:13 +00:00
si.nMin = 0;
si.nMax = total - 1;
si.nPage = page;
si.nPos = start;
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
if (wgs->term_hwnd)
SetScrollInfo(wgs->term_hwnd, SB_VERT, &si, true);
Initial checkin: beta 0.43 [originally from svn r11]
1999-01-08 13:02:13 +00:00
}
Convert a lot of 'int' variables to 'bool'. My normal habit these days, in new code, is to treat int and bool as _almost_ completely separate types. I'm still willing to use C's implicit test for zero on an integer (e.g. 'if (!blob.len)' is fine, no need to spell it out as blob.len != 0), but generally, if a variable is going to be conceptually a boolean, I like to declare it bool and assign to it using 'true' or 'false' rather than 0 or 1. PuTTY is an exception, because it predates the C99 bool, and I've stuck to its existing coding style even when adding new code to it. But it's been annoying me more and more, so now that I've decided C99 bool is an acceptable thing to require from our toolchain in the first place, here's a quite thorough trawl through the source doing 'boolification'. Many variables and function parameters are now typed as bool rather than int; many assignments of 0 or 1 to those variables are now spelled 'true' or 'false'. I managed this thorough conversion with the help of a custom clang plugin that I wrote to trawl the AST and apply heuristics to point out where things might want changing. So I've even managed to do a decent job on parts of the code I haven't looked at in years! To make the plugin's work easier, I pushed platform front ends generally in the direction of using standard 'bool' in preference to platform-specific boolean types like Windows BOOL or GTK's gboolean; I've left the platform booleans in places they _have_ to be for the platform APIs to work right, but variables only used by my own code have been converted wherever I found them. In a few places there are int values that look very like booleans in _most_ of the places they're used, but have a rarely-used third value, or a distinction between different nonzero values that most users don't care about. In these cases, I've _removed_ uses of 'true' and 'false' for the return values, to emphasise that there's something more subtle going on than a simple boolean answer: - the 'multisel' field in dialog.h's list box structure, for which the GTK front end in particular recognises a difference between 1 and 2 but nearly everything else treats as boolean - the 'urgent' parameter to plug_receive, where 1 vs 2 tells you something about the specific location of the urgent pointer, but most clients only care about 0 vs 'something nonzero' - the return value of wc_match, where -1 indicates a syntax error in the wildcard. - the return values from SSH-1 RSA-key loading functions, which use -1 for 'wrong passphrase' and 0 for all other failures (so any caller which already knows it's not loading an _encrypted private_ key can treat them as boolean) - term->esc_query, and the 'query' parameter in toggle_mode in terminal.c, which _usually_ hold 0 for ESC[123h or 1 for ESC[?123h, but can also hold -1 for some other intervening character that we don't support. In a few places there's an integer that I haven't turned into a bool even though it really _can_ only take values 0 or 1 (and, as above, tried to make the call sites consistent in not calling those values true and false), on the grounds that I thought it would make it more confusing to imply that the 0 value was in some sense 'negative' or bad and the 1 positive or good: - the return value of plug_accepting uses the POSIXish convention of 0=success and nonzero=error; I think if I made it bool then I'd also want to reverse its sense, and that's a job for a separate piece of work. - the 'screen' parameter to lineptr() in terminal.c, where 0 and 1 represent the default and alternate screens. There's no obvious reason why one of those should be considered 'true' or 'positive' or 'success' - they're just indices - so I've left it as int. ssh_scp_recv had particularly confusing semantics for its previous int return value: its call sites used '<= 0' to check for error, but it never actually returned a negative number, just 0 or 1. Now the function and its call sites agree that it's a bool. In a couple of places I've renamed variables called 'ret', because I don't like that name any more - it's unclear whether it means the return value (in preparation) for the _containing_ function or the return value received from a subroutine call, and occasionally I've accidentally used the same variable for both and introduced a bug. So where one of those got in my way, I've renamed it to 'toret' or 'retd' (the latter short for 'returned') in line with my usual modern practice, but I haven't done a thorough job of finding all of them. Finally, one amusing side effect of doing this is that I've had to separate quite a few chained assignments. It used to be perfectly fine to write 'a = b = c = TRUE' when a,b,c were int and TRUE was just a the 'true' defined by stdbool.h, that idiom provokes a warning from gcc: 'suggest parentheses around assignment used as truth value'!
2018-11-02 19:23:19 +00:00
static bool wintw_setup_draw_ctx(TermWin *tw)
Run entire source base through GNU indent to tidy up the varying coding styles of the various contributors! Woohoo! [originally from svn r1098]
2001-05-06 14:35:20 +00:00
{
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
WinGuiSeat *wgs = container_of(tw, WinGuiSeat, termwin);
assert(!wgs->wintw_hdc);
wgs->wintw_hdc = make_hdc(wgs);
return wgs->wintw_hdc != NULL;
Initial checkin: beta 0.43 [originally from svn r11]
1999-01-08 13:02:13 +00:00
}
Remove the 'Frontend' type and replace it with a vtable. After the recent Seat and LogContext revamps, _nearly_ all the remaining uses of the type 'Frontend' were in terminal.c, which needs all sorts of interactions with the GUI window the terminal lives in, from the obvious (actually drawing text on the window, reading and writing the clipboard) to the obscure (minimising, maximising and moving the window in response to particular escape sequences). All of those functions are now provided by an abstraction called TermWin. The few remaining uses of Frontend after _that_ are internal to a particular platform directory, so as to spread the implementation of that particular kind of Frontend between multiple source files; so I've renamed all of those so that they take a more specifically named type that refers to the particular implementation rather than the general abstraction. So now the name 'Frontend' no longer exists in the code base at all, and everywhere one used to be used, it's completely clear whether it was operating in one of Frontend's three abstract roles (and if so, which), or whether it was specific to a particular implementation. Another type that's disappeared is 'Context', which used to be a typedef defined to something different on each platform, describing whatever short-lived resources were necessary to draw on the terminal window: the front end would provide a ready-made one when calling term_paint, and the terminal could request one with get_ctx/free_ctx if it wanted to do proactive window updates. Now that drawing context lives inside the TermWin itself, because there was never any need to have two of those contexts live at the same time. (Another minor API change is that the window-title functions - both reading and writing - have had a missing 'const' added to their char * parameters / return values.) I don't expect this change to enable any particularly interesting new functionality (in particular, I have no plans that need more than one implementation of TermWin in the same application). But it completes the tidying-up that began with the Seat and LogContext rework.
2018-10-25 17:44:04 +00:00
static void wintw_free_draw_ctx(TermWin *tw)
Run entire source base through GNU indent to tidy up the varying coding styles of the various contributors! Woohoo! [originally from svn r1098]
2001-05-06 14:35:20 +00:00
{
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
WinGuiSeat *wgs = container_of(tw, WinGuiSeat, termwin);
assert(wgs->wintw_hdc);
free_hdc(wgs, wgs->wintw_hdc);
wgs->wintw_hdc = NULL;
Initial checkin: beta 0.43 [originally from svn r11]
1999-01-08 13:02:13 +00:00
}
Centralise palette setup into terminal.c. Now terminal.c makes nearly all the decisions about what the colour palette should actually contain: it does the job of reading the GUI-configurable colours out of Conf, and also the job of making up the rest of the xterm-256 palette. The only exception is that TermWin can provide a method to override some of the default colours, which on Windows is used to implement the 'Use system colours' config option. This saves code overall, partly because the front ends don't have to be able to send palette data back to the Terminal any more (the Terminal keeps the master copy and can answer palette-query escape sequences from its own knowledge), and also because now there's only one copy of the xterm-256 palette setup code (previously gtkwin.c and window.c each had their own version of it). In this rewrite, I've also introduced a multi-layered storage system for the palette data in Terminal. One layer contains the palette information derived from Conf; the next contains platform overrides (currently just Windows's 'Use system colours'); the last one contains overrides set by escape sequences in the middle of the session. The topmost two layers can each _conditionally_ override the ones below. As a result, if a server-side application manually resets (say) the default fg and bg colours in mid-session to something that works well in a particular application, those changes won't be wiped out by a change in the Windows system colours or the Conf, which they would have been before. Instead, changes in Conf or the system colours alter the lower layers of the structure, but then when palette_rebuild is called, the upper layer continues to override them, until a palette reset (ESC]R) or terminal reset (e.g. ESC c) removes those upper-layer changes. This seems like a more consistent strategy, in that the same set of configuration settings will produce the same end result regardless of what order they were applied in. The palette-related methods in TermWin have had a total rework. palette_get and palette_reset are both gone; palette_set can now set a contiguous range of colours in one go; and the new palette_get_overrides replaces window.c's old systopalette().
2021-02-07 19:59:21 +00:00
/*
* Set up the colour palette.
*/
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
static void init_palette(WinGuiSeat *wgs)
Support OSC 4 terminal colour-palette queries. Markus Gans points out that some applications which (not at all unreasonably) don't trust $TERM to tell them the full capabilities of their terminal will use the sequence "OSC 4 ; nn ; ? BEL" to ask for the colour-palette value in position nn, and they may not particularly care _what_ the results are but they will use them to decide whether the right number of colour palette entries even exist.
2017-10-05 19:43:02 +00:00
{
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
wgs->pal = NULL;
wgs->logpal = snew_plus(
LOGPALETTE, (OSC4_NCOLOURS - 1) * sizeof(PALETTEENTRY));
wgs->logpal->palVersion = 0x300;
wgs->logpal->palNumEntries = OSC4_NCOLOURS;
Centralise palette setup into terminal.c. Now terminal.c makes nearly all the decisions about what the colour palette should actually contain: it does the job of reading the GUI-configurable colours out of Conf, and also the job of making up the rest of the xterm-256 palette. The only exception is that TermWin can provide a method to override some of the default colours, which on Windows is used to implement the 'Use system colours' config option. This saves code overall, partly because the front ends don't have to be able to send palette data back to the Terminal any more (the Terminal keeps the master copy and can answer palette-query escape sequences from its own knowledge), and also because now there's only one copy of the xterm-256 palette setup code (previously gtkwin.c and window.c each had their own version of it). In this rewrite, I've also introduced a multi-layered storage system for the palette data in Terminal. One layer contains the palette information derived from Conf; the next contains platform overrides (currently just Windows's 'Use system colours'); the last one contains overrides set by escape sequences in the middle of the session. The topmost two layers can each _conditionally_ override the ones below. As a result, if a server-side application manually resets (say) the default fg and bg colours in mid-session to something that works well in a particular application, those changes won't be wiped out by a change in the Windows system colours or the Conf, which they would have been before. Instead, changes in Conf or the system colours alter the lower layers of the structure, but then when palette_rebuild is called, the upper layer continues to override them, until a palette reset (ESC]R) or terminal reset (e.g. ESC c) removes those upper-layer changes. This seems like a more consistent strategy, in that the same set of configuration settings will produce the same end result regardless of what order they were applied in. The palette-related methods in TermWin have had a total rework. palette_get and palette_reset are both gone; palette_set can now set a contiguous range of colours in one go; and the new palette_get_overrides replaces window.c's old systopalette().
2021-02-07 19:59:21 +00:00
for (unsigned i = 0; i < OSC4_NCOLOURS; i++)
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
wgs->logpal->palPalEntry[i].peFlags = PC_NOCOLLAPSE;
Initial checkin: beta 0.43 [originally from svn r11]
1999-01-08 13:02:13 +00:00
}
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
static void wintw_palette_set(TermWin *tw, unsigned start,
Centralise palette setup into terminal.c. Now terminal.c makes nearly all the decisions about what the colour palette should actually contain: it does the job of reading the GUI-configurable colours out of Conf, and also the job of making up the rest of the xterm-256 palette. The only exception is that TermWin can provide a method to override some of the default colours, which on Windows is used to implement the 'Use system colours' config option. This saves code overall, partly because the front ends don't have to be able to send palette data back to the Terminal any more (the Terminal keeps the master copy and can answer palette-query escape sequences from its own knowledge), and also because now there's only one copy of the xterm-256 palette setup code (previously gtkwin.c and window.c each had their own version of it). In this rewrite, I've also introduced a multi-layered storage system for the palette data in Terminal. One layer contains the palette information derived from Conf; the next contains platform overrides (currently just Windows's 'Use system colours'); the last one contains overrides set by escape sequences in the middle of the session. The topmost two layers can each _conditionally_ override the ones below. As a result, if a server-side application manually resets (say) the default fg and bg colours in mid-session to something that works well in a particular application, those changes won't be wiped out by a change in the Windows system colours or the Conf, which they would have been before. Instead, changes in Conf or the system colours alter the lower layers of the structure, but then when palette_rebuild is called, the upper layer continues to override them, until a palette reset (ESC]R) or terminal reset (e.g. ESC c) removes those upper-layer changes. This seems like a more consistent strategy, in that the same set of configuration settings will produce the same end result regardless of what order they were applied in. The palette-related methods in TermWin have had a total rework. palette_get and palette_reset are both gone; palette_set can now set a contiguous range of colours in one go; and the new palette_get_overrides replaces window.c's old systopalette().
2021-02-07 19:59:21 +00:00
unsigned ncolours, const rgb *colours_in)
Run entire source base through GNU indent to tidy up the varying coding styles of the various contributors! Woohoo! [originally from svn r1098]
2001-05-06 14:35:20 +00:00
{
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
WinGuiSeat *wgs = container_of(tw, WinGuiSeat, termwin);
Centralise palette setup into terminal.c. Now terminal.c makes nearly all the decisions about what the colour palette should actually contain: it does the job of reading the GUI-configurable colours out of Conf, and also the job of making up the rest of the xterm-256 palette. The only exception is that TermWin can provide a method to override some of the default colours, which on Windows is used to implement the 'Use system colours' config option. This saves code overall, partly because the front ends don't have to be able to send palette data back to the Terminal any more (the Terminal keeps the master copy and can answer palette-query escape sequences from its own knowledge), and also because now there's only one copy of the xterm-256 palette setup code (previously gtkwin.c and window.c each had their own version of it). In this rewrite, I've also introduced a multi-layered storage system for the palette data in Terminal. One layer contains the palette information derived from Conf; the next contains platform overrides (currently just Windows's 'Use system colours'); the last one contains overrides set by escape sequences in the middle of the session. The topmost two layers can each _conditionally_ override the ones below. As a result, if a server-side application manually resets (say) the default fg and bg colours in mid-session to something that works well in a particular application, those changes won't be wiped out by a change in the Windows system colours or the Conf, which they would have been before. Instead, changes in Conf or the system colours alter the lower layers of the structure, but then when palette_rebuild is called, the upper layer continues to override them, until a palette reset (ESC]R) or terminal reset (e.g. ESC c) removes those upper-layer changes. This seems like a more consistent strategy, in that the same set of configuration settings will produce the same end result regardless of what order they were applied in. The palette-related methods in TermWin have had a total rework. palette_get and palette_reset are both gone; palette_set can now set a contiguous range of colours in one go; and the new palette_get_overrides replaces window.c's old systopalette().
2021-02-07 19:59:21 +00:00
assert(start <= OSC4_NCOLOURS);
assert(ncolours <= OSC4_NCOLOURS - start);
for (unsigned i = 0; i < ncolours; i++) {
const rgb *in = &colours_in[i];
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
PALETTEENTRY *out = &wgs->logpal->palPalEntry[i + start];
Centralise palette setup into terminal.c. Now terminal.c makes nearly all the decisions about what the colour palette should actually contain: it does the job of reading the GUI-configurable colours out of Conf, and also the job of making up the rest of the xterm-256 palette. The only exception is that TermWin can provide a method to override some of the default colours, which on Windows is used to implement the 'Use system colours' config option. This saves code overall, partly because the front ends don't have to be able to send palette data back to the Terminal any more (the Terminal keeps the master copy and can answer palette-query escape sequences from its own knowledge), and also because now there's only one copy of the xterm-256 palette setup code (previously gtkwin.c and window.c each had their own version of it). In this rewrite, I've also introduced a multi-layered storage system for the palette data in Terminal. One layer contains the palette information derived from Conf; the next contains platform overrides (currently just Windows's 'Use system colours'); the last one contains overrides set by escape sequences in the middle of the session. The topmost two layers can each _conditionally_ override the ones below. As a result, if a server-side application manually resets (say) the default fg and bg colours in mid-session to something that works well in a particular application, those changes won't be wiped out by a change in the Windows system colours or the Conf, which they would have been before. Instead, changes in Conf or the system colours alter the lower layers of the structure, but then when palette_rebuild is called, the upper layer continues to override them, until a palette reset (ESC]R) or terminal reset (e.g. ESC c) removes those upper-layer changes. This seems like a more consistent strategy, in that the same set of configuration settings will produce the same end result regardless of what order they were applied in. The palette-related methods in TermWin have had a total rework. palette_get and palette_reset are both gone; palette_set can now set a contiguous range of colours in one go; and the new palette_get_overrides replaces window.c's old systopalette().
2021-02-07 19:59:21 +00:00
out->peRed = in->r;
out->peGreen = in->g;
out->peBlue = in->b;
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
wgs->colours[i + start] =
RGB(in->r, in->g, in->b) ^ wgs->colorref_modifier;
Initial checkin: beta 0.43 [originally from svn r11]
1999-01-08 13:02:13 +00:00
}
Centralise palette setup into terminal.c. Now terminal.c makes nearly all the decisions about what the colour palette should actually contain: it does the job of reading the GUI-configurable colours out of Conf, and also the job of making up the rest of the xterm-256 palette. The only exception is that TermWin can provide a method to override some of the default colours, which on Windows is used to implement the 'Use system colours' config option. This saves code overall, partly because the front ends don't have to be able to send palette data back to the Terminal any more (the Terminal keeps the master copy and can answer palette-query escape sequences from its own knowledge), and also because now there's only one copy of the xterm-256 palette setup code (previously gtkwin.c and window.c each had their own version of it). In this rewrite, I've also introduced a multi-layered storage system for the palette data in Terminal. One layer contains the palette information derived from Conf; the next contains platform overrides (currently just Windows's 'Use system colours'); the last one contains overrides set by escape sequences in the middle of the session. The topmost two layers can each _conditionally_ override the ones below. As a result, if a server-side application manually resets (say) the default fg and bg colours in mid-session to something that works well in a particular application, those changes won't be wiped out by a change in the Windows system colours or the Conf, which they would have been before. Instead, changes in Conf or the system colours alter the lower layers of the structure, but then when palette_rebuild is called, the upper layer continues to override them, until a palette reset (ESC]R) or terminal reset (e.g. ESC c) removes those upper-layer changes. This seems like a more consistent strategy, in that the same set of configuration settings will produce the same end result regardless of what order they were applied in. The palette-related methods in TermWin have had a total rework. palette_get and palette_reset are both gone; palette_set can now set a contiguous range of colours in one go; and the new palette_get_overrides replaces window.c's old systopalette().
2021-02-07 19:59:21 +00:00
bool got_new_palette = false;
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
if (!wgs->tried_pal && conf_get_bool(wgs->conf, CONF_try_palette)) {
HDC hdc = GetDC(wgs->term_hwnd);
Centralise palette setup into terminal.c. Now terminal.c makes nearly all the decisions about what the colour palette should actually contain: it does the job of reading the GUI-configurable colours out of Conf, and also the job of making up the rest of the xterm-256 palette. The only exception is that TermWin can provide a method to override some of the default colours, which on Windows is used to implement the 'Use system colours' config option. This saves code overall, partly because the front ends don't have to be able to send palette data back to the Terminal any more (the Terminal keeps the master copy and can answer palette-query escape sequences from its own knowledge), and also because now there's only one copy of the xterm-256 palette setup code (previously gtkwin.c and window.c each had their own version of it). In this rewrite, I've also introduced a multi-layered storage system for the palette data in Terminal. One layer contains the palette information derived from Conf; the next contains platform overrides (currently just Windows's 'Use system colours'); the last one contains overrides set by escape sequences in the middle of the session. The topmost two layers can each _conditionally_ override the ones below. As a result, if a server-side application manually resets (say) the default fg and bg colours in mid-session to something that works well in a particular application, those changes won't be wiped out by a change in the Windows system colours or the Conf, which they would have been before. Instead, changes in Conf or the system colours alter the lower layers of the structure, but then when palette_rebuild is called, the upper layer continues to override them, until a palette reset (ESC]R) or terminal reset (e.g. ESC c) removes those upper-layer changes. This seems like a more consistent strategy, in that the same set of configuration settings will produce the same end result regardless of what order they were applied in. The palette-related methods in TermWin have had a total rework. palette_get and palette_reset are both gone; palette_set can now set a contiguous range of colours in one go; and the new palette_get_overrides replaces window.c's old systopalette().
2021-02-07 19:59:21 +00:00
if (GetDeviceCaps(hdc, RASTERCAPS) & RC_PALETTE) {
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
wgs->pal = CreatePalette(wgs->logpal);
if (wgs->pal) {
SelectPalette(hdc, wgs->pal, false);
Centralise palette setup into terminal.c. Now terminal.c makes nearly all the decisions about what the colour palette should actually contain: it does the job of reading the GUI-configurable colours out of Conf, and also the job of making up the rest of the xterm-256 palette. The only exception is that TermWin can provide a method to override some of the default colours, which on Windows is used to implement the 'Use system colours' config option. This saves code overall, partly because the front ends don't have to be able to send palette data back to the Terminal any more (the Terminal keeps the master copy and can answer palette-query escape sequences from its own knowledge), and also because now there's only one copy of the xterm-256 palette setup code (previously gtkwin.c and window.c each had their own version of it). In this rewrite, I've also introduced a multi-layered storage system for the palette data in Terminal. One layer contains the palette information derived from Conf; the next contains platform overrides (currently just Windows's 'Use system colours'); the last one contains overrides set by escape sequences in the middle of the session. The topmost two layers can each _conditionally_ override the ones below. As a result, if a server-side application manually resets (say) the default fg and bg colours in mid-session to something that works well in a particular application, those changes won't be wiped out by a change in the Windows system colours or the Conf, which they would have been before. Instead, changes in Conf or the system colours alter the lower layers of the structure, but then when palette_rebuild is called, the upper layer continues to override them, until a palette reset (ESC]R) or terminal reset (e.g. ESC c) removes those upper-layer changes. This seems like a more consistent strategy, in that the same set of configuration settings will produce the same end result regardless of what order they were applied in. The palette-related methods in TermWin have had a total rework. palette_get and palette_reset are both gone; palette_set can now set a contiguous range of colours in one go; and the new palette_get_overrides replaces window.c's old systopalette().
2021-02-07 19:59:21 +00:00
RealizePalette(hdc);
SelectPalette(hdc, GetStockObject(DEFAULT_PALETTE), false);
/* Convert all RGB() values in colours[] into PALETTERGB(),
* and ensure we stick to that later */
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
wgs->colorref_modifier = PALETTERGB(0, 0, 0) ^ RGB(0, 0, 0);
Centralise palette setup into terminal.c. Now terminal.c makes nearly all the decisions about what the colour palette should actually contain: it does the job of reading the GUI-configurable colours out of Conf, and also the job of making up the rest of the xterm-256 palette. The only exception is that TermWin can provide a method to override some of the default colours, which on Windows is used to implement the 'Use system colours' config option. This saves code overall, partly because the front ends don't have to be able to send palette data back to the Terminal any more (the Terminal keeps the master copy and can answer palette-query escape sequences from its own knowledge), and also because now there's only one copy of the xterm-256 palette setup code (previously gtkwin.c and window.c each had their own version of it). In this rewrite, I've also introduced a multi-layered storage system for the palette data in Terminal. One layer contains the palette information derived from Conf; the next contains platform overrides (currently just Windows's 'Use system colours'); the last one contains overrides set by escape sequences in the middle of the session. The topmost two layers can each _conditionally_ override the ones below. As a result, if a server-side application manually resets (say) the default fg and bg colours in mid-session to something that works well in a particular application, those changes won't be wiped out by a change in the Windows system colours or the Conf, which they would have been before. Instead, changes in Conf or the system colours alter the lower layers of the structure, but then when palette_rebuild is called, the upper layer continues to override them, until a palette reset (ESC]R) or terminal reset (e.g. ESC c) removes those upper-layer changes. This seems like a more consistent strategy, in that the same set of configuration settings will produce the same end result regardless of what order they were applied in. The palette-related methods in TermWin have had a total rework. palette_get and palette_reset are both gone; palette_set can now set a contiguous range of colours in one go; and the new palette_get_overrides replaces window.c's old systopalette().
2021-02-07 19:59:21 +00:00
for (unsigned i = 0; i < OSC4_NCOLOURS; i++)
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
wgs->colours[i] ^= wgs->colorref_modifier;
Centralise palette setup into terminal.c. Now terminal.c makes nearly all the decisions about what the colour palette should actually contain: it does the job of reading the GUI-configurable colours out of Conf, and also the job of making up the rest of the xterm-256 palette. The only exception is that TermWin can provide a method to override some of the default colours, which on Windows is used to implement the 'Use system colours' config option. This saves code overall, partly because the front ends don't have to be able to send palette data back to the Terminal any more (the Terminal keeps the master copy and can answer palette-query escape sequences from its own knowledge), and also because now there's only one copy of the xterm-256 palette setup code (previously gtkwin.c and window.c each had their own version of it). In this rewrite, I've also introduced a multi-layered storage system for the palette data in Terminal. One layer contains the palette information derived from Conf; the next contains platform overrides (currently just Windows's 'Use system colours'); the last one contains overrides set by escape sequences in the middle of the session. The topmost two layers can each _conditionally_ override the ones below. As a result, if a server-side application manually resets (say) the default fg and bg colours in mid-session to something that works well in a particular application, those changes won't be wiped out by a change in the Windows system colours or the Conf, which they would have been before. Instead, changes in Conf or the system colours alter the lower layers of the structure, but then when palette_rebuild is called, the upper layer continues to override them, until a palette reset (ESC]R) or terminal reset (e.g. ESC c) removes those upper-layer changes. This seems like a more consistent strategy, in that the same set of configuration settings will produce the same end result regardless of what order they were applied in. The palette-related methods in TermWin have had a total rework. palette_get and palette_reset are both gone; palette_set can now set a contiguous range of colours in one go; and the new palette_get_overrides replaces window.c's old systopalette().
2021-02-07 19:59:21 +00:00
/* Inhibit the SetPaletteEntries call below */
got_new_palette = true;
}
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
}
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
ReleaseDC(wgs->term_hwnd, hdc);
wgs->tried_pal = true;
Initial checkin: beta 0.43 [originally from svn r11]
1999-01-08 13:02:13 +00:00
}
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
if (wgs->pal && !got_new_palette) {
Centralise palette setup into terminal.c. Now terminal.c makes nearly all the decisions about what the colour palette should actually contain: it does the job of reading the GUI-configurable colours out of Conf, and also the job of making up the rest of the xterm-256 palette. The only exception is that TermWin can provide a method to override some of the default colours, which on Windows is used to implement the 'Use system colours' config option. This saves code overall, partly because the front ends don't have to be able to send palette data back to the Terminal any more (the Terminal keeps the master copy and can answer palette-query escape sequences from its own knowledge), and also because now there's only one copy of the xterm-256 palette setup code (previously gtkwin.c and window.c each had their own version of it). In this rewrite, I've also introduced a multi-layered storage system for the palette data in Terminal. One layer contains the palette information derived from Conf; the next contains platform overrides (currently just Windows's 'Use system colours'); the last one contains overrides set by escape sequences in the middle of the session. The topmost two layers can each _conditionally_ override the ones below. As a result, if a server-side application manually resets (say) the default fg and bg colours in mid-session to something that works well in a particular application, those changes won't be wiped out by a change in the Windows system colours or the Conf, which they would have been before. Instead, changes in Conf or the system colours alter the lower layers of the structure, but then when palette_rebuild is called, the upper layer continues to override them, until a palette reset (ESC]R) or terminal reset (e.g. ESC c) removes those upper-layer changes. This seems like a more consistent strategy, in that the same set of configuration settings will produce the same end result regardless of what order they were applied in. The palette-related methods in TermWin have had a total rework. palette_get and palette_reset are both gone; palette_set can now set a contiguous range of colours in one go; and the new palette_get_overrides replaces window.c's old systopalette().
2021-02-07 19:59:21 +00:00
/* We already had a palette, so replace the changed colours in the
* existing one. */
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
SetPaletteEntries(wgs->pal, start, ncolours,
wgs->logpal->palPalEntry + start);
Centralise palette setup into terminal.c. Now terminal.c makes nearly all the decisions about what the colour palette should actually contain: it does the job of reading the GUI-configurable colours out of Conf, and also the job of making up the rest of the xterm-256 palette. The only exception is that TermWin can provide a method to override some of the default colours, which on Windows is used to implement the 'Use system colours' config option. This saves code overall, partly because the front ends don't have to be able to send palette data back to the Terminal any more (the Terminal keeps the master copy and can answer palette-query escape sequences from its own knowledge), and also because now there's only one copy of the xterm-256 palette setup code (previously gtkwin.c and window.c each had their own version of it). In this rewrite, I've also introduced a multi-layered storage system for the palette data in Terminal. One layer contains the palette information derived from Conf; the next contains platform overrides (currently just Windows's 'Use system colours'); the last one contains overrides set by escape sequences in the middle of the session. The topmost two layers can each _conditionally_ override the ones below. As a result, if a server-side application manually resets (say) the default fg and bg colours in mid-session to something that works well in a particular application, those changes won't be wiped out by a change in the Windows system colours or the Conf, which they would have been before. Instead, changes in Conf or the system colours alter the lower layers of the structure, but then when palette_rebuild is called, the upper layer continues to override them, until a palette reset (ESC]R) or terminal reset (e.g. ESC c) removes those upper-layer changes. This seems like a more consistent strategy, in that the same set of configuration settings will produce the same end result regardless of what order they were applied in. The palette-related methods in TermWin have had a total rework. palette_get and palette_reset are both gone; palette_set can now set a contiguous range of colours in one go; and the new palette_get_overrides replaces window.c's old systopalette().
2021-02-07 19:59:21 +00:00
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
HDC hdc = make_hdc(wgs);
UnrealizeObject(wgs->pal);
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
RealizePalette(hdc);
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
free_hdc(wgs, hdc);
Centralise palette setup into terminal.c. Now terminal.c makes nearly all the decisions about what the colour palette should actually contain: it does the job of reading the GUI-configurable colours out of Conf, and also the job of making up the rest of the xterm-256 palette. The only exception is that TermWin can provide a method to override some of the default colours, which on Windows is used to implement the 'Use system colours' config option. This saves code overall, partly because the front ends don't have to be able to send palette data back to the Terminal any more (the Terminal keeps the master copy and can answer palette-query escape sequences from its own knowledge), and also because now there's only one copy of the xterm-256 palette setup code (previously gtkwin.c and window.c each had their own version of it). In this rewrite, I've also introduced a multi-layered storage system for the palette data in Terminal. One layer contains the palette information derived from Conf; the next contains platform overrides (currently just Windows's 'Use system colours'); the last one contains overrides set by escape sequences in the middle of the session. The topmost two layers can each _conditionally_ override the ones below. As a result, if a server-side application manually resets (say) the default fg and bg colours in mid-session to something that works well in a particular application, those changes won't be wiped out by a change in the Windows system colours or the Conf, which they would have been before. Instead, changes in Conf or the system colours alter the lower layers of the structure, but then when palette_rebuild is called, the upper layer continues to override them, until a palette reset (ESC]R) or terminal reset (e.g. ESC c) removes those upper-layer changes. This seems like a more consistent strategy, in that the same set of configuration settings will produce the same end result regardless of what order they were applied in. The palette-related methods in TermWin have had a total rework. palette_get and palette_reset are both gone; palette_set can now set a contiguous range of colours in one go; and the new palette_get_overrides replaces window.c's old systopalette().
2021-02-07 19:59:21 +00:00
}
if (start <= OSC4_COLOUR_bg && OSC4_COLOUR_bg < start + ncolours) {
/* If Default Background changes, we need to ensure any space between
* the text area and the window border is redrawn. */
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
InvalidateRect(wgs->term_hwnd, NULL, true);
Initial checkin: beta 0.43 [originally from svn r11]
1999-01-08 13:02:13 +00:00
}
}
Windows: rethink API of write_aclip(). That clipboard-writing function is called just once, from the Event Log dialog procedure, for when the user deliberately copies to the clipboard. That call always passes must_deselect = true, which means the conditional WM_IGNORE_CLIP messages are not sent. So it's simpler to remove that parameter completely, and the conditional calls which are never used. Also, the clipboard data copied from the Event Log dialog is being put in the clipboard associated with the main PuTTY terminal window. But anything else we copy from a dialog box using Windows's built-in copy-paste mechanisms would surely be associated with the _dialog_, not its parent window. So we should do the same thing here. Therefore, I've added a HWND parameter to write_aclip() and used that in place of wgs.term_hwnd, so that we can pass in the HWND of the dialog itself.
2022-09-12 10:27:34 +00:00
void write_aclip(HWND hwnd, int clipboard, char *data, int len)
Run entire source base through GNU indent to tidy up the varying coding styles of the various contributors! Woohoo! [originally from svn r1098]
2001-05-06 14:35:20 +00:00
{
Initial checkin: beta 0.43 [originally from svn r11]
1999-01-08 13:02:13 +00:00
HGLOBAL clipdata;
void *lock;
Add a system of clipboard identifiers. This lays some groundwork for making PuTTY's cut and paste handling more flexible in the area of which clipboard(s) it reads and writes, if more than one is available on the system. I've introduced a system of list macros which define an enumeration of integer clipboard ids, some defined centrally in putty.h (at present just a CLIP_NULL which never has any text in it, because that seems like the sort of thing that will come in useful for configuring a given copy or paste UI action to be ignored) and some defined per platform. All the front end functions that copy and paste take a clipboard id, and the Terminal structure is now configured at startup to tell it which clipboard id it should paste from on a mouse click, and which it should copy from on a selection. However, I haven't actually added _real_ support for multiple X11 clipboards, in that the Unix front end supports a single CLIP_SYSTEM regardless of whether it's in OS X or GTK mode. So this is currently a NFC refactoring which does nothing but prepare the way for real changes to come.
2017-12-09 12:00:13 +00:00
if (clipboard != CLIP_SYSTEM)
return;
Run entire source base through GNU indent to tidy up the varying coding styles of the various contributors! Woohoo! [originally from svn r1098]
2001-05-06 14:35:20 +00:00
clipdata = GlobalAlloc(GMEM_DDESHARE | GMEM_MOVEABLE, len + 1);
Initial checkin: beta 0.43 [originally from svn r11]
1999-01-08 13:02:13 +00:00
if (!clipdata)
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
return;
Run entire source base through GNU indent to tidy up the varying coding styles of the various contributors! Woohoo! [originally from svn r1098]
2001-05-06 14:35:20 +00:00
lock = GlobalLock(clipdata);
Initial checkin: beta 0.43 [originally from svn r11]
1999-01-08 13:02:13 +00:00
if (!lock)
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
return;
Run entire source base through GNU indent to tidy up the varying coding styles of the various contributors! Woohoo! [originally from svn r1098]
2001-05-06 14:35:20 +00:00
memcpy(lock, data, len);
((unsigned char *) lock)[len] = 0;
GlobalUnlock(clipdata);
Initial checkin: beta 0.43 [originally from svn r11]
1999-01-08 13:02:13 +00:00
Windows: rethink API of write_aclip(). That clipboard-writing function is called just once, from the Event Log dialog procedure, for when the user deliberately copies to the clipboard. That call always passes must_deselect = true, which means the conditional WM_IGNORE_CLIP messages are not sent. So it's simpler to remove that parameter completely, and the conditional calls which are never used. Also, the clipboard data copied from the Event Log dialog is being put in the clipboard associated with the main PuTTY terminal window. But anything else we copy from a dialog box using Windows's built-in copy-paste mechanisms would surely be associated with the _dialog_, not its parent window. So we should do the same thing here. Therefore, I've added a HWND parameter to write_aclip() and used that in place of wgs.term_hwnd, so that we can pass in the HWND of the dialog itself.
2022-09-12 10:27:34 +00:00
if (OpenClipboard(hwnd)) {
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
EmptyClipboard();
SetClipboardData(CF_TEXT, clipdata);
CloseClipboard();
Initial checkin: beta 0.43 [originally from svn r11]
1999-01-08 13:02:13 +00:00
} else
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
GlobalFree(clipdata);
Initial checkin: beta 0.43 [originally from svn r11]
1999-01-08 13:02:13 +00:00
}
Implement true-colour in write_clip for Windows This allows text copied from PuTTY to a rich-text program to retain the true-colour attribute.
2017-06-13 04:55:57 +00:00
typedef struct _rgbindex {
int index;
COLORREF ref;
} rgbindex;
int cmpCOLORREF(void *va, void *vb)
{
COLORREF a = ((rgbindex *)va)->ref;
COLORREF b = ((rgbindex *)vb)->ref;
return (a < b) ? -1 : (a > b) ? +1 : 0;
}
RDB's Unicode patch. Fonts are now used in Unicode mode where possible and we have a single unified means of trying to display any Unicode code point. Instead of the various ad-hoc translation modes we had before, we now have a single `codepage' option which allows us to treat the incoming (and outgoing) text as any given character set, and locally we map that to Unicode and back. [originally from svn r1110]
2001-05-10 08:34:20 +00:00
/*
* Note: unlike write_aclip() this will not append a nul.
*/
Remove the 'Frontend' type and replace it with a vtable. After the recent Seat and LogContext revamps, _nearly_ all the remaining uses of the type 'Frontend' were in terminal.c, which needs all sorts of interactions with the GUI window the terminal lives in, from the obvious (actually drawing text on the window, reading and writing the clipboard) to the obscure (minimising, maximising and moving the window in response to particular escape sequences). All of those functions are now provided by an abstraction called TermWin. The few remaining uses of Frontend after _that_ are internal to a particular platform directory, so as to spread the implementation of that particular kind of Frontend between multiple source files; so I've renamed all of those so that they take a more specifically named type that refers to the particular implementation rather than the general abstraction. So now the name 'Frontend' no longer exists in the code base at all, and everywhere one used to be used, it's completely clear whether it was operating in one of Frontend's three abstract roles (and if so, which), or whether it was specific to a particular implementation. Another type that's disappeared is 'Context', which used to be a typedef defined to something different on each platform, describing whatever short-lived resources were necessary to draw on the terminal window: the front end would provide a ready-made one when calling term_paint, and the terminal could request one with get_ctx/free_ctx if it wanted to do proactive window updates. Now that drawing context lives inside the TermWin itself, because there was never any need to have two of those contexts live at the same time. (Another minor API change is that the window-title functions - both reading and writing - have had a missing 'const' added to their char * parameters / return values.) I don't expect this change to enable any particularly interesting new functionality (in particular, I have no plans that need more than one implementation of TermWin in the same application). But it completes the tidying-up that began with the Seat and LogContext rework.
2018-10-25 17:44:04 +00:00
static void wintw_clip_write(
TermWin *tw, int clipboard, wchar_t *data, int *attr,
Convert a lot of 'int' variables to 'bool'. My normal habit these days, in new code, is to treat int and bool as _almost_ completely separate types. I'm still willing to use C's implicit test for zero on an integer (e.g. 'if (!blob.len)' is fine, no need to spell it out as blob.len != 0), but generally, if a variable is going to be conceptually a boolean, I like to declare it bool and assign to it using 'true' or 'false' rather than 0 or 1. PuTTY is an exception, because it predates the C99 bool, and I've stuck to its existing coding style even when adding new code to it. But it's been annoying me more and more, so now that I've decided C99 bool is an acceptable thing to require from our toolchain in the first place, here's a quite thorough trawl through the source doing 'boolification'. Many variables and function parameters are now typed as bool rather than int; many assignments of 0 or 1 to those variables are now spelled 'true' or 'false'. I managed this thorough conversion with the help of a custom clang plugin that I wrote to trawl the AST and apply heuristics to point out where things might want changing. So I've even managed to do a decent job on parts of the code I haven't looked at in years! To make the plugin's work easier, I pushed platform front ends generally in the direction of using standard 'bool' in preference to platform-specific boolean types like Windows BOOL or GTK's gboolean; I've left the platform booleans in places they _have_ to be for the platform APIs to work right, but variables only used by my own code have been converted wherever I found them. In a few places there are int values that look very like booleans in _most_ of the places they're used, but have a rarely-used third value, or a distinction between different nonzero values that most users don't care about. In these cases, I've _removed_ uses of 'true' and 'false' for the return values, to emphasise that there's something more subtle going on than a simple boolean answer: - the 'multisel' field in dialog.h's list box structure, for which the GTK front end in particular recognises a difference between 1 and 2 but nearly everything else treats as boolean - the 'urgent' parameter to plug_receive, where 1 vs 2 tells you something about the specific location of the urgent pointer, but most clients only care about 0 vs 'something nonzero' - the return value of wc_match, where -1 indicates a syntax error in the wildcard. - the return values from SSH-1 RSA-key loading functions, which use -1 for 'wrong passphrase' and 0 for all other failures (so any caller which already knows it's not loading an _encrypted private_ key can treat them as boolean) - term->esc_query, and the 'query' parameter in toggle_mode in terminal.c, which _usually_ hold 0 for ESC[123h or 1 for ESC[?123h, but can also hold -1 for some other intervening character that we don't support. In a few places there's an integer that I haven't turned into a bool even though it really _can_ only take values 0 or 1 (and, as above, tried to make the call sites consistent in not calling those values true and false), on the grounds that I thought it would make it more confusing to imply that the 0 value was in some sense 'negative' or bad and the 1 positive or good: - the return value of plug_accepting uses the POSIXish convention of 0=success and nonzero=error; I think if I made it bool then I'd also want to reverse its sense, and that's a job for a separate piece of work. - the 'screen' parameter to lineptr() in terminal.c, where 0 and 1 represent the default and alternate screens. There's no obvious reason why one of those should be considered 'true' or 'positive' or 'success' - they're just indices - so I've left it as int. ssh_scp_recv had particularly confusing semantics for its previous int return value: its call sites used '<= 0' to check for error, but it never actually returned a negative number, just 0 or 1. Now the function and its call sites agree that it's a bool. In a couple of places I've renamed variables called 'ret', because I don't like that name any more - it's unclear whether it means the return value (in preparation) for the _containing_ function or the return value received from a subroutine call, and occasionally I've accidentally used the same variable for both and introduced a bug. So where one of those got in my way, I've renamed it to 'toret' or 'retd' (the latter short for 'returned') in line with my usual modern practice, but I haven't done a thorough job of finding all of them. Finally, one amusing side effect of doing this is that I've had to separate quite a few chained assignments. It used to be perfectly fine to write 'a = b = c = TRUE' when a,b,c were int and TRUE was just a the 'true' defined by stdbool.h, that idiom provokes a warning from gcc: 'suggest parentheses around assignment used as truth value'!
2018-11-02 19:23:19 +00:00
truecolour *truecolour, int len, bool must_deselect)
RDB's Unicode patch. Fonts are now used in Unicode mode where possible and we have a single unified means of trying to display any Unicode code point. Instead of the various ad-hoc translation modes we had before, we now have a single `codepage' option which allows us to treat the incoming (and outgoing) text as any given character set, and locally we map that to Unicode and back. [originally from svn r1110]
2001-05-10 08:34:20 +00:00
{
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
WinGuiSeat *wgs = container_of(tw, WinGuiSeat, termwin);
Implement writing RTF to the clipboard (off by default), so that if you enable it text will paste into Word et al in the same font as PuTTY itself is displaying in. In particular, this will be a fixed- pitch font, so tables and `ls' and the like will naturally line up. [originally from svn r1373]
2001-11-07 22:22:53 +00:00
HGLOBAL clipdata, clipdata2, clipdata3;
RDB's Unicode patch. Fonts are now used in Unicode mode where possible and we have a single unified means of trying to display any Unicode code point. Instead of the various ad-hoc translation modes we had before, we now have a single `codepage' option which allows us to treat the incoming (and outgoing) text as any given character set, and locally we map that to Unicode and back. [originally from svn r1110]
2001-05-10 08:34:20 +00:00
int len2;
Implement writing RTF to the clipboard (off by default), so that if you enable it text will paste into Word et al in the same font as PuTTY itself is displaying in. In particular, this will be a fixed- pitch font, so tables and `ls' and the like will naturally line up. [originally from svn r1373]
2001-11-07 22:22:53 +00:00
void *lock, *lock2, *lock3;
RDB's Unicode patch. Fonts are now used in Unicode mode where possible and we have a single unified means of trying to display any Unicode code point. Instead of the various ad-hoc translation modes we had before, we now have a single `codepage' option which allows us to treat the incoming (and outgoing) text as any given character set, and locally we map that to Unicode and back. [originally from svn r1110]
2001-05-10 08:34:20 +00:00
Add a system of clipboard identifiers. This lays some groundwork for making PuTTY's cut and paste handling more flexible in the area of which clipboard(s) it reads and writes, if more than one is available on the system. I've introduced a system of list macros which define an enumeration of integer clipboard ids, some defined centrally in putty.h (at present just a CLIP_NULL which never has any text in it, because that seems like the sort of thing that will come in useful for configuring a given copy or paste UI action to be ignored) and some defined per platform. All the front end functions that copy and paste take a clipboard id, and the Terminal structure is now configured at startup to tell it which clipboard id it should paste from on a mouse click, and which it should copy from on a selection. However, I haven't actually added _real_ support for multiple X11 clipboards, in that the Unix front end supports a single CLIP_SYSTEM regardless of whether it's in OS X or GTK mode. So this is currently a NFC refactoring which does nothing but prepare the way for real changes to come.
2017-12-09 12:00:13 +00:00
if (clipboard != CLIP_SYSTEM)
return;
RDB's Unicode patch. Fonts are now used in Unicode mode where possible and we have a single unified means of trying to display any Unicode code point. Instead of the various ad-hoc translation modes we had before, we now have a single `codepage' option which allows us to treat the incoming (and outgoing) text as any given character set, and locally we map that to Unicode and back. [originally from svn r1110]
2001-05-10 08:34:20 +00:00
len2 = WideCharToMultiByte(CP_ACP, 0, data, len, 0, 0, NULL, NULL);
clipdata = GlobalAlloc(GMEM_DDESHARE | GMEM_MOVEABLE,
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
len * sizeof(wchar_t));
RDB's Unicode patch. Fonts are now used in Unicode mode where possible and we have a single unified means of trying to display any Unicode code point. Instead of the various ad-hoc translation modes we had before, we now have a single `codepage' option which allows us to treat the incoming (and outgoing) text as any given character set, and locally we map that to Unicode and back. [originally from svn r1110]
2001-05-10 08:34:20 +00:00
clipdata2 = GlobalAlloc(GMEM_DDESHARE | GMEM_MOVEABLE, len2);
Fix compiler warnings [originally from svn r1469]
2001-12-11 18:47:35 +00:00
if (!clipdata || !clipdata2) {
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
if (clipdata)
GlobalFree(clipdata);
if (clipdata2)
GlobalFree(clipdata2);
return;
RDB's Unicode patch. Fonts are now used in Unicode mode where possible and we have a single unified means of trying to display any Unicode code point. Instead of the various ad-hoc translation modes we had before, we now have a single `codepage' option which allows us to treat the incoming (and outgoing) text as any given character set, and locally we map that to Unicode and back. [originally from svn r1110]
2001-05-10 08:34:20 +00:00
}
Another big batch of memory leak fixes, again mostly on error paths. The most interesting one is printer_add_enum, which I've modified to take a char ** rather than a char * so that it can both realloc its input buffer _and_ return NULL to indicate error. [originally from svn r9959]
2013-07-22 07:11:54 +00:00
if (!(lock = GlobalLock(clipdata))) {
GlobalFree(clipdata);
GlobalFree(clipdata2);
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
return;
Another big batch of memory leak fixes, again mostly on error paths. The most interesting one is printer_add_enum, which I've modified to take a char ** rather than a char * so that it can both realloc its input buffer _and_ return NULL to indicate error. [originally from svn r9959]
2013-07-22 07:11:54 +00:00
}
if (!(lock2 = GlobalLock(clipdata2))) {
GlobalUnlock(clipdata);
GlobalFree(clipdata);
GlobalFree(clipdata2);
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
return;
Another big batch of memory leak fixes, again mostly on error paths. The most interesting one is printer_add_enum, which I've modified to take a char ** rather than a char * so that it can both realloc its input buffer _and_ return NULL to indicate error. [originally from svn r9959]
2013-07-22 07:11:54 +00:00
}
RDB's Unicode patch. Fonts are now used in Unicode mode where possible and we have a single unified means of trying to display any Unicode code point. Instead of the various ad-hoc translation modes we had before, we now have a single `codepage' option which allows us to treat the incoming (and outgoing) text as any given character set, and locally we map that to Unicode and back. [originally from svn r1110]
2001-05-10 08:34:20 +00:00
memcpy(lock, data, len * sizeof(wchar_t));
WideCharToMultiByte(CP_ACP, 0, data, len, lock2, len2, NULL, NULL);
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
if (conf_get_bool(wgs->conf, CONF_rtf_paste)) {
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
wchar_t unitab[256];
strbuf *rtf = strbuf_new();
unsigned char *tdata = (unsigned char *)lock2;
wchar_t *udata = (wchar_t *)lock;
int uindex = 0, tindex = 0;
Remove a completely unused loop in RTF pasting. In commit d07d7d66f662b67 I rewrote the code that constructs RTF paste data so that it uses a strbuf, in place of the previous ad-hoc code that counted up the lengths of pieces of RTF in advance in order to realloc the buffer. But apparently I left in an entire loop whose job was to count up one of those lengths, failing to notice that it's now completely pointless because its output value is never needed! Happily a clang upgrade has just improved the 'variable set but not used' warning to the point where it can spot that. I expect previously the variable still counted as 'used' because each increment of it used the previous value.
2023-04-07 06:51:17 +00:00
int multilen, blen, alen, i;
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
char before[16], after[4];
int fgcolour, lastfgcolour = -1;
int bgcolour, lastbgcolour = -1;
COLORREF fg, lastfg = -1;
COLORREF bg, lastbg = -1;
int attrBold, lastAttrBold = 0;
int attrUnder, lastAttrUnder = 0;
Bring some order to colour palette indexing. There are three separate indexing schemes in use by various bits of the PuTTY front ends, and _none_ of them was clearly documented, let alone all in the same place. Worse, functions that looked obviously related, like win_palette_set and win_palette_get, used different encodings. Now all the encodings are defined together in putty.h, with explanation of why there are three in the first place and clear documentation of where each one is used; terminal.c provides mapping tables that convert between them; the terminology is consistent throughout; and win_palette_set has been converted to use the sensible encoding.
2021-02-07 19:59:20 +00:00
int palette[OSC4_NCOLOURS];
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
int numcolours;
tree234 *rgbtree = NULL;
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
FontSpec *font = conf_get_fontspec(wgs->conf, CONF_font);
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
get_unitab(CP_ACP, unitab, 0);
Generalise strbuf_catf() into put_fmt(). marshal.h now provides a macro put_fmt() which allows you to write arbitrary printf-formatted data to an arbitrary BinarySink. We already had this facility for strbufs in particular, in the form of strbuf_catf(). That was able to take advantage of knowing the inner structure of a strbuf to minimise memory allocation (it would snprintf directly into the strbuf's existing buffer if possible). For a general black-box BinarySink we can't do that, so instead we dupvprintf into a temporary buffer. For consistency, I've removed strbuf_catf, and converted all uses of it into the new put_fmt - and I've also added an extra vtable method in the BinarySink API, so that put_fmt can still use strbuf_catf's more efficient memory management when talking to a strbuf, and fall back to the simpler strategy when that's not available.
2021-11-19 10:23:32 +00:00
put_fmt(
Replace more ad-hoc growing char buffers with strbuf. I've fixed a handful of these where I found them in passing, but when I went systematically looking, there were a lot more that I hadn't found! A particular highlight of this collection is the code that formats Windows clipboard data in RTF, which was absolutely crying out for strbuf_catf, and now it's got it.
2019-02-11 06:58:07 +00:00
rtf, "{\\rtf1\\ansi\\deff0{\\fonttbl\\f0\\fmodern %s;}\\f0\\fs%d",
font->name, font->height*2);
Preserve more attributes of text copied as RTF. Thanks to Stephen Balousek. [originally from svn r6555]
2006-02-13 22:18:17 +00:00
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
/*
* Add colour palette
* {\colortbl ;\red255\green0\blue0;\red0\green0\blue128;}
*/
/*
* First - Determine all colours in use
* o Foregound and background colours share the same palette
*/
if (attr) {
memset(palette, 0, sizeof(palette));
for (i = 0; i < (len-1); i++) {
fgcolour = ((attr[i] & ATTR_FGMASK) >> ATTR_FGSHIFT);
bgcolour = ((attr[i] & ATTR_BGMASK) >> ATTR_BGSHIFT);
if (attr[i] & ATTR_REVERSE) {
int tmpcolour = fgcolour; /* Swap foreground and background */
fgcolour = bgcolour;
bgcolour = tmpcolour;
}
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
if (wgs->bold_colours && (attr[i] & ATTR_BOLD)) {
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
if (fgcolour < 8) /* ANSI colours */
fgcolour += 8;
else if (fgcolour >= 256) /* Default colours */
fgcolour ++;
}
if ((attr[i] & ATTR_BLINK)) {
if (bgcolour < 8) /* ANSI colours */
bgcolour += 8;
else if (bgcolour >= 256) /* Default colours */
bgcolour ++;
}
palette[fgcolour]++;
palette[bgcolour]++;
}
if (truecolour) {
rgbtree = newtree234(cmpCOLORREF);
for (i = 0; i < (len-1); i++) {
if (truecolour[i].fg.enabled) {
rgbindex *rgbp = snew(rgbindex);
rgbp->ref = RGB(truecolour[i].fg.r,
truecolour[i].fg.g,
truecolour[i].fg.b);
if (add234(rgbtree, rgbp) != rgbp)
sfree(rgbp);
}
if (truecolour[i].bg.enabled) {
rgbindex *rgbp = snew(rgbindex);
rgbp->ref = RGB(truecolour[i].bg.r,
truecolour[i].bg.g,
truecolour[i].bg.b);
if (add234(rgbtree, rgbp) != rgbp)
sfree(rgbp);
}
}
}
/*
* Next - Create a reduced palette
*/
numcolours = 0;
Bring some order to colour palette indexing. There are three separate indexing schemes in use by various bits of the PuTTY front ends, and _none_ of them was clearly documented, let alone all in the same place. Worse, functions that looked obviously related, like win_palette_set and win_palette_get, used different encodings. Now all the encodings are defined together in putty.h, with explanation of why there are three in the first place and clear documentation of where each one is used; terminal.c provides mapping tables that convert between them; the terminology is consistent throughout; and win_palette_set has been converted to use the sensible encoding.
2021-02-07 19:59:20 +00:00
for (i = 0; i < OSC4_NCOLOURS; i++) {
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
if (palette[i] != 0)
palette[i] = ++numcolours;
}
if (rgbtree) {
rgbindex *rgbp;
for (i = 0; (rgbp = index234(rgbtree, i)) != NULL; i++)
rgbp->index = ++numcolours;
}
/*
* Finally - Write the colour table
*/
put_datapl(rtf, PTRLEN_LITERAL("{\\colortbl ;"));
Bring some order to colour palette indexing. There are three separate indexing schemes in use by various bits of the PuTTY front ends, and _none_ of them was clearly documented, let alone all in the same place. Worse, functions that looked obviously related, like win_palette_set and win_palette_get, used different encodings. Now all the encodings are defined together in putty.h, with explanation of why there are three in the first place and clear documentation of where each one is used; terminal.c provides mapping tables that convert between them; the terminology is consistent throughout; and win_palette_set has been converted to use the sensible encoding.
2021-02-07 19:59:20 +00:00
for (i = 0; i < OSC4_NCOLOURS; i++) {
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
if (palette[i] != 0) {
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
const PALETTEENTRY *pe = &wgs->logpal->palPalEntry[i];
Generalise strbuf_catf() into put_fmt(). marshal.h now provides a macro put_fmt() which allows you to write arbitrary printf-formatted data to an arbitrary BinarySink. We already had this facility for strbufs in particular, in the form of strbuf_catf(). That was able to take advantage of knowing the inner structure of a strbuf to minimise memory allocation (it would snprintf directly into the strbuf's existing buffer if possible). For a general black-box BinarySink we can't do that, so instead we dupvprintf into a temporary buffer. For consistency, I've removed strbuf_catf, and converted all uses of it into the new put_fmt - and I've also added an extra vtable method in the BinarySink API, so that put_fmt can still use strbuf_catf's more efficient memory management when talking to a strbuf, and fall back to the simpler strategy when that's not available.
2021-11-19 10:23:32 +00:00
put_fmt(rtf, "\\red%d\\green%d\\blue%d;",
pe->peRed, pe->peGreen, pe->peBlue);
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
}
}
if (rgbtree) {
rgbindex *rgbp;
for (i = 0; (rgbp = index234(rgbtree, i)) != NULL; i++)
Generalise strbuf_catf() into put_fmt(). marshal.h now provides a macro put_fmt() which allows you to write arbitrary printf-formatted data to an arbitrary BinarySink. We already had this facility for strbufs in particular, in the form of strbuf_catf(). That was able to take advantage of knowing the inner structure of a strbuf to minimise memory allocation (it would snprintf directly into the strbuf's existing buffer if possible). For a general black-box BinarySink we can't do that, so instead we dupvprintf into a temporary buffer. For consistency, I've removed strbuf_catf, and converted all uses of it into the new put_fmt - and I've also added an extra vtable method in the BinarySink API, so that put_fmt can still use strbuf_catf's more efficient memory management when talking to a strbuf, and fall back to the simpler strategy when that's not available.
2021-11-19 10:23:32 +00:00
put_fmt(rtf, "\\red%d\\green%d\\blue%d;",
GetRValue(rgbp->ref), GetGValue(rgbp->ref),
GetBValue(rgbp->ref));
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
}
put_datapl(rtf, PTRLEN_LITERAL("}"));
}
/*
* We want to construct a piece of RTF that specifies the
* same Unicode text. To do this we will read back in
* parallel from the Unicode data in `udata' and the
* non-Unicode data in `tdata'. For each character in
* `tdata' which becomes the right thing in `udata' when
* looked up in `unitab', we just copy straight over from
* tdata. For each one that doesn't, we must WCToMB it
* individually and produce a \u escape sequence.
*
* It would probably be more robust to just bite the bullet
* and WCToMB each individual Unicode character one by one,
* then MBToWC each one back to see if it was an accurate
* translation; but that strikes me as a horrifying number
* of Windows API calls so I want to see if this faster way
* will work. If it screws up badly we can always revert to
* the simple and slow way.
*/
while (tindex < len2 && uindex < len &&
tdata[tindex] && udata[uindex]) {
if (tindex + 1 < len2 &&
tdata[tindex] == '\r' &&
tdata[tindex+1] == '\n') {
tindex++;
uindex++;
Preserve more attributes of text copied as RTF. Thanks to Stephen Balousek. [originally from svn r6555]
2006-02-13 22:18:17 +00:00
}
/*
* Set text attributes
*/
if (attr) {
/*
* Determine foreground and background colours
*/
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
if (truecolour && truecolour[tindex].fg.enabled) {
fgcolour = -1;
fg = RGB(truecolour[tindex].fg.r,
truecolour[tindex].fg.g,
truecolour[tindex].fg.b);
} else {
fgcolour = ((attr[tindex] & ATTR_FGMASK) >> ATTR_FGSHIFT);
fg = -1;
Preserve more attributes of text copied as RTF. Thanks to Stephen Balousek. [originally from svn r6555]
2006-02-13 22:18:17 +00:00
}
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
if (truecolour && truecolour[tindex].bg.enabled) {
bgcolour = -1;
bg = RGB(truecolour[tindex].bg.r,
truecolour[tindex].bg.g,
truecolour[tindex].bg.b);
} else {
bgcolour = ((attr[tindex] & ATTR_BGMASK) >> ATTR_BGSHIFT);
bg = -1;
}
if (attr[tindex] & ATTR_REVERSE) {
int tmpcolour = fgcolour; /* Swap foreground and background */
fgcolour = bgcolour;
bgcolour = tmpcolour;
COLORREF tmpref = fg;
fg = bg;
bg = tmpref;
}
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
if (wgs->bold_colours && (attr[tindex] & ATTR_BOLD) &&
(fgcolour >= 0)) {
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
if (fgcolour < 8) /* ANSI colours */
fgcolour += 8;
else if (fgcolour >= 256) /* Default colours */
fgcolour ++;
}
if ((attr[tindex] & ATTR_BLINK) && (bgcolour >= 0)) {
if (bgcolour < 8) /* ANSI colours */
bgcolour += 8;
else if (bgcolour >= 256) /* Default colours */
bgcolour ++;
Preserve more attributes of text copied as RTF. Thanks to Stephen Balousek. [originally from svn r6555]
2006-02-13 22:18:17 +00:00
}
/*
* Collect other attributes
*/
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
if (wgs->bold_font_mode != BOLD_NONE)
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
attrBold = attr[tindex] & ATTR_BOLD;
else
attrBold = 0;
attrUnder = attr[tindex] & ATTR_UNDER;
Preserve more attributes of text copied as RTF. Thanks to Stephen Balousek. [originally from svn r6555]
2006-02-13 22:18:17 +00:00
/*
* Reverse video
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
* o If video isn't reversed, ignore colour attributes for default foregound
* or background.
* o Special case where bolded text is displayed using the default foregound
* and background colours - force to bolded RTF.
Preserve more attributes of text copied as RTF. Thanks to Stephen Balousek. [originally from svn r6555]
2006-02-13 22:18:17 +00:00
*/
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
if (!(attr[tindex] & ATTR_REVERSE)) {
if (bgcolour >= 256) /* Default color */
bgcolour = -1; /* No coloring */
Preserve more attributes of text copied as RTF. Thanks to Stephen Balousek. [originally from svn r6555]
2006-02-13 22:18:17 +00:00
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
if (fgcolour >= 256) { /* Default colour */
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
if (wgs->bold_colours && (fgcolour & 1) &&
bgcolour == -1)
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
attrBold = ATTR_BOLD; /* Emphasize text with bold attribute */
Preserve more attributes of text copied as RTF. Thanks to Stephen Balousek. [originally from svn r6555]
2006-02-13 22:18:17 +00:00
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
fgcolour = -1; /* No coloring */
}
}
Preserve more attributes of text copied as RTF. Thanks to Stephen Balousek. [originally from svn r6555]
2006-02-13 22:18:17 +00:00
/*
* Write RTF text attributes
*/
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
if ((lastfgcolour != fgcolour) || (lastfg != fg)) {
lastfgcolour = fgcolour;
lastfg = fg;
Replace more ad-hoc growing char buffers with strbuf. I've fixed a handful of these where I found them in passing, but when I went systematically looking, there were a lot more that I hadn't found! A particular highlight of this collection is the code that formats Windows clipboard data in RTF, which was absolutely crying out for strbuf_catf, and now it's got it.
2019-02-11 06:58:07 +00:00
if (fg == -1) {
Generalise strbuf_catf() into put_fmt(). marshal.h now provides a macro put_fmt() which allows you to write arbitrary printf-formatted data to an arbitrary BinarySink. We already had this facility for strbufs in particular, in the form of strbuf_catf(). That was able to take advantage of knowing the inner structure of a strbuf to minimise memory allocation (it would snprintf directly into the strbuf's existing buffer if possible). For a general black-box BinarySink we can't do that, so instead we dupvprintf into a temporary buffer. For consistency, I've removed strbuf_catf, and converted all uses of it into the new put_fmt - and I've also added an extra vtable method in the BinarySink API, so that put_fmt can still use strbuf_catf's more efficient memory management when talking to a strbuf, and fall back to the simpler strategy when that's not available.
2021-11-19 10:23:32 +00:00
put_fmt(rtf, "\\cf%d ",
(fgcolour >= 0) ? palette[fgcolour] : 0);
Replace more ad-hoc growing char buffers with strbuf. I've fixed a handful of these where I found them in passing, but when I went systematically looking, there were a lot more that I hadn't found! A particular highlight of this collection is the code that formats Windows clipboard data in RTF, which was absolutely crying out for strbuf_catf, and now it's got it.
2019-02-11 06:58:07 +00:00
} else {
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
rgbindex rgb, *rgbp;
rgb.ref = fg;
if ((rgbp = find234(rgbtree, &rgb, NULL)) != NULL)
Generalise strbuf_catf() into put_fmt(). marshal.h now provides a macro put_fmt() which allows you to write arbitrary printf-formatted data to an arbitrary BinarySink. We already had this facility for strbufs in particular, in the form of strbuf_catf(). That was able to take advantage of knowing the inner structure of a strbuf to minimise memory allocation (it would snprintf directly into the strbuf's existing buffer if possible). For a general black-box BinarySink we can't do that, so instead we dupvprintf into a temporary buffer. For consistency, I've removed strbuf_catf, and converted all uses of it into the new put_fmt - and I've also added an extra vtable method in the BinarySink API, so that put_fmt can still use strbuf_catf's more efficient memory management when talking to a strbuf, and fall back to the simpler strategy when that's not available.
2021-11-19 10:23:32 +00:00
put_fmt(rtf, "\\cf%d ", rgbp->index);
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
}
}
if ((lastbgcolour != bgcolour) || (lastbg != bg)) {
lastbgcolour = bgcolour;
lastbg = bg;
if (bg == -1)
Generalise strbuf_catf() into put_fmt(). marshal.h now provides a macro put_fmt() which allows you to write arbitrary printf-formatted data to an arbitrary BinarySink. We already had this facility for strbufs in particular, in the form of strbuf_catf(). That was able to take advantage of knowing the inner structure of a strbuf to minimise memory allocation (it would snprintf directly into the strbuf's existing buffer if possible). For a general black-box BinarySink we can't do that, so instead we dupvprintf into a temporary buffer. For consistency, I've removed strbuf_catf, and converted all uses of it into the new put_fmt - and I've also added an extra vtable method in the BinarySink API, so that put_fmt can still use strbuf_catf's more efficient memory management when talking to a strbuf, and fall back to the simpler strategy when that's not available.
2021-11-19 10:23:32 +00:00
put_fmt(rtf, "\\highlight%d ",
(bgcolour >= 0) ? palette[bgcolour] : 0);
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
else {
rgbindex rgb, *rgbp;
rgb.ref = bg;
if ((rgbp = find234(rgbtree, &rgb, NULL)) != NULL)
Generalise strbuf_catf() into put_fmt(). marshal.h now provides a macro put_fmt() which allows you to write arbitrary printf-formatted data to an arbitrary BinarySink. We already had this facility for strbufs in particular, in the form of strbuf_catf(). That was able to take advantage of knowing the inner structure of a strbuf to minimise memory allocation (it would snprintf directly into the strbuf's existing buffer if possible). For a general black-box BinarySink we can't do that, so instead we dupvprintf into a temporary buffer. For consistency, I've removed strbuf_catf, and converted all uses of it into the new put_fmt - and I've also added an extra vtable method in the BinarySink API, so that put_fmt can still use strbuf_catf's more efficient memory management when talking to a strbuf, and fall back to the simpler strategy when that's not available.
2021-11-19 10:23:32 +00:00
put_fmt(rtf, "\\highlight%d ", rgbp->index);
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
}
}
if (lastAttrBold != attrBold) {
lastAttrBold = attrBold;
put_datapl(rtf, attrBold ?
Replace more ad-hoc growing char buffers with strbuf. I've fixed a handful of these where I found them in passing, but when I went systematically looking, there were a lot more that I hadn't found! A particular highlight of this collection is the code that formats Windows clipboard data in RTF, which was absolutely crying out for strbuf_catf, and now it's got it.
2019-02-11 06:58:07 +00:00
PTRLEN_LITERAL("\\b ") :
PTRLEN_LITERAL("\\b0 "));
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
}
Preserve more attributes of text copied as RTF. Thanks to Stephen Balousek. [originally from svn r6555]
2006-02-13 22:18:17 +00:00
if (lastAttrUnder != attrUnder) {
lastAttrUnder = attrUnder;
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
put_datapl(rtf, attrUnder ?
Replace more ad-hoc growing char buffers with strbuf. I've fixed a handful of these where I found them in passing, but when I went systematically looking, there were a lot more that I hadn't found! A particular highlight of this collection is the code that formats Windows clipboard data in RTF, which was absolutely crying out for strbuf_catf, and now it's got it.
2019-02-11 06:58:07 +00:00
PTRLEN_LITERAL("\\ul ") :
PTRLEN_LITERAL("\\ulnone "));
Preserve more attributes of text copied as RTF. Thanks to Stephen Balousek. [originally from svn r6555]
2006-02-13 22:18:17 +00:00
}
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
}
if (unitab[tdata[tindex]] == udata[uindex]) {
multilen = 1;
before[0] = '\0';
after[0] = '\0';
blen = alen = 0;
} else {
multilen = WideCharToMultiByte(CP_ACP, 0, unitab+uindex, 1,
NULL, 0, NULL, NULL);
if (multilen != 1) {
blen = sprintf(before, "{\\uc%d\\u%d", (int)multilen,
(int)udata[uindex]);
alen = 1; strcpy(after, "}");
} else {
Add missing cast in RTF paste data construction. udata[uindex] is a wchar_t, so if we pass it to sprintf("%d") we should cast it to int (because who knows what primitive integer type that might have corresponded to otherwise). I had done this in the first of the two sprintfs that use it, but missed the second one a few lines further on. Spotted by Coverity.
2020-06-16 16:43:55 +00:00
blen = sprintf(before, "\\u%d", (int)udata[uindex]);
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
alen = 0; after[0] = '\0';
}
}
assert(tindex + multilen <= len2);
put_data(rtf, before, blen);
for (i = 0; i < multilen; i++) {
if (tdata[tindex+i] == '\\' ||
tdata[tindex+i] == '{' ||
tdata[tindex+i] == '}') {
Replace more ad-hoc growing char buffers with strbuf. I've fixed a handful of these where I found them in passing, but when I went systematically looking, there were a lot more that I hadn't found! A particular highlight of this collection is the code that formats Windows clipboard data in RTF, which was absolutely crying out for strbuf_catf, and now it's got it.
2019-02-11 06:58:07 +00:00
put_byte(rtf, '\\');
put_byte(rtf, tdata[tindex+i]);
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
} else if (tdata[tindex+i] == 0x0D || tdata[tindex+i] == 0x0A) {
Replace more ad-hoc growing char buffers with strbuf. I've fixed a handful of these where I found them in passing, but when I went systematically looking, there were a lot more that I hadn't found! A particular highlight of this collection is the code that formats Windows clipboard data in RTF, which was absolutely crying out for strbuf_catf, and now it's got it.
2019-02-11 06:58:07 +00:00
put_datapl(rtf, PTRLEN_LITERAL("\\par\r\n"));
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
} else if (tdata[tindex+i] > 0x7E || tdata[tindex+i] < 0x20) {
Generalise strbuf_catf() into put_fmt(). marshal.h now provides a macro put_fmt() which allows you to write arbitrary printf-formatted data to an arbitrary BinarySink. We already had this facility for strbufs in particular, in the form of strbuf_catf(). That was able to take advantage of knowing the inner structure of a strbuf to minimise memory allocation (it would snprintf directly into the strbuf's existing buffer if possible). For a general black-box BinarySink we can't do that, so instead we dupvprintf into a temporary buffer. For consistency, I've removed strbuf_catf, and converted all uses of it into the new put_fmt - and I've also added an extra vtable method in the BinarySink API, so that put_fmt can still use strbuf_catf's more efficient memory management when talking to a strbuf, and fall back to the simpler strategy when that's not available.
2021-11-19 10:23:32 +00:00
put_fmt(rtf, "\\'%02x", tdata[tindex+i]);
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
} else {
Replace more ad-hoc growing char buffers with strbuf. I've fixed a handful of these where I found them in passing, but when I went systematically looking, there were a lot more that I hadn't found! A particular highlight of this collection is the code that formats Windows clipboard data in RTF, which was absolutely crying out for strbuf_catf, and now it's got it.
2019-02-11 06:58:07 +00:00
put_byte(rtf, tdata[tindex+i]);
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
}
}
put_data(rtf, after, alen);
Implement writing RTF to the clipboard (off by default), so that if you enable it text will paste into Word et al in the same font as PuTTY itself is displaying in. In particular, this will be a fixed- pitch font, so tables and `ls' and the like will naturally line up. [originally from svn r1373]
2001-11-07 22:22:53 +00:00
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
tindex += multilen;
uindex++;
}
Implement writing RTF to the clipboard (off by default), so that if you enable it text will paste into Word et al in the same font as PuTTY itself is displaying in. In particular, this will be a fixed- pitch font, so tables and `ls' and the like will naturally line up. [originally from svn r1373]
2001-11-07 22:22:53 +00:00
Replace more ad-hoc growing char buffers with strbuf. I've fixed a handful of these where I found them in passing, but when I went systematically looking, there were a lot more that I hadn't found! A particular highlight of this collection is the code that formats Windows clipboard data in RTF, which was absolutely crying out for strbuf_catf, and now it's got it.
2019-02-11 06:58:07 +00:00
put_datapl(rtf, PTRLEN_LITERAL("}\0\0")); /* Terminate RTF stream */
Implement writing RTF to the clipboard (off by default), so that if you enable it text will paste into Word et al in the same font as PuTTY itself is displaying in. In particular, this will be a fixed- pitch font, so tables and `ls' and the like will naturally line up. [originally from svn r1373]
2001-11-07 22:22:53 +00:00
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
clipdata3 = GlobalAlloc(GMEM_DDESHARE | GMEM_MOVEABLE, rtf->len);
if (clipdata3 && (lock3 = GlobalLock(clipdata3)) != NULL) {
memcpy(lock3, rtf->u, rtf->len);
GlobalUnlock(clipdata3);
}
strbuf_free(rtf);
if (rgbtree) {
rgbindex *rgbp;
while ((rgbp = delpos234(rgbtree, 0)) != NULL)
sfree(rgbp);
freetree234(rgbtree);
}
Implement writing RTF to the clipboard (off by default), so that if you enable it text will paste into Word et al in the same font as PuTTY itself is displaying in. In particular, this will be a fixed- pitch font, so tables and `ls' and the like will naturally line up. [originally from svn r1373]
2001-11-07 22:22:53 +00:00
} else
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
clipdata3 = NULL;
Implement writing RTF to the clipboard (off by default), so that if you enable it text will paste into Word et al in the same font as PuTTY itself is displaying in. In particular, this will be a fixed- pitch font, so tables and `ls' and the like will naturally line up. [originally from svn r1373]
2001-11-07 22:22:53 +00:00
RDB's Unicode patch. Fonts are now used in Unicode mode where possible and we have a single unified means of trying to display any Unicode code point. Instead of the various ad-hoc translation modes we had before, we now have a single `codepage' option which allows us to treat the incoming (and outgoing) text as any given character set, and locally we map that to Unicode and back. [originally from svn r1110]
2001-05-10 08:34:20 +00:00
GlobalUnlock(clipdata);
GlobalUnlock(clipdata2);
if (!must_deselect)
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
SendMessage(wgs->term_hwnd, WM_IGNORE_CLIP, true, 0);
RDB's Unicode patch. Fonts are now used in Unicode mode where possible and we have a single unified means of trying to display any Unicode code point. Instead of the various ad-hoc translation modes we had before, we now have a single `codepage' option which allows us to treat the incoming (and outgoing) text as any given character set, and locally we map that to Unicode and back. [originally from svn r1110]
2001-05-10 08:34:20 +00:00
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
if (OpenClipboard(wgs->term_hwnd)) {
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
EmptyClipboard();
SetClipboardData(CF_UNICODETEXT, clipdata);
SetClipboardData(CF_TEXT, clipdata2);
if (clipdata3)
SetClipboardData(RegisterClipboardFormat(CF_RTF), clipdata3);
CloseClipboard();
RDB's Unicode patch. Fonts are now used in Unicode mode where possible and we have a single unified means of trying to display any Unicode code point. Instead of the various ad-hoc translation modes we had before, we now have a single `codepage' option which allows us to treat the incoming (and outgoing) text as any given character set, and locally we map that to Unicode and back. [originally from svn r1110]
2001-05-10 08:34:20 +00:00
} else {
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
GlobalFree(clipdata);
GlobalFree(clipdata2);
RDB's Unicode patch. Fonts are now used in Unicode mode where possible and we have a single unified means of trying to display any Unicode code point. Instead of the various ad-hoc translation modes we had before, we now have a single `codepage' option which allows us to treat the incoming (and outgoing) text as any given character set, and locally we map that to Unicode and back. [originally from svn r1110]
2001-05-10 08:34:20 +00:00
}
if (!must_deselect)
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
SendMessage(wgs->term_hwnd, WM_IGNORE_CLIP, false, 0);
RDB's Unicode patch. Fonts are now used in Unicode mode where possible and we have a single unified means of trying to display any Unicode code point. Instead of the various ad-hoc translation modes we had before, we now have a single `codepage' option which allows us to treat the incoming (and outgoing) text as any given character set, and locally we map that to Unicode and back. [originally from svn r1110]
2001-05-10 08:34:20 +00:00
}
Move the code that reads the Windows clipboard into a trivial subthread, so that it won't deadlock if fetching the content of the clipboard turns out to depend on a network connection forwarded through PuTTY. [originally from svn r8338]
2008-11-28 18:28:23 +00:00
static DWORD WINAPI clipboard_read_threadfunc(void *param)
Run entire source base through GNU indent to tidy up the varying coding styles of the various contributors! Woohoo! [originally from svn r1098]
2001-05-06 14:35:20 +00:00
{
Move the code that reads the Windows clipboard into a trivial subthread, so that it won't deadlock if fetching the content of the clipboard turns out to depend on a network connection forwarded through PuTTY. [originally from svn r8338]
2008-11-28 18:28:23 +00:00
HWND hwnd = (HWND)param;
HGLOBAL clipdata;
Initial checkin: beta 0.43 [originally from svn r11]
1999-01-08 13:02:13 +00:00
Move the code that reads the Windows clipboard into a trivial subthread, so that it won't deadlock if fetching the content of the clipboard turns out to depend on a network connection forwarded through PuTTY. [originally from svn r8338]
2008-11-28 18:28:23 +00:00
if (OpenClipboard(NULL)) {
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
if ((clipdata = GetClipboardData(CF_UNICODETEXT))) {
SendMessage(hwnd, WM_GOT_CLIPDATA,
Convert a lot of 'int' variables to 'bool'. My normal habit these days, in new code, is to treat int and bool as _almost_ completely separate types. I'm still willing to use C's implicit test for zero on an integer (e.g. 'if (!blob.len)' is fine, no need to spell it out as blob.len != 0), but generally, if a variable is going to be conceptually a boolean, I like to declare it bool and assign to it using 'true' or 'false' rather than 0 or 1. PuTTY is an exception, because it predates the C99 bool, and I've stuck to its existing coding style even when adding new code to it. But it's been annoying me more and more, so now that I've decided C99 bool is an acceptable thing to require from our toolchain in the first place, here's a quite thorough trawl through the source doing 'boolification'. Many variables and function parameters are now typed as bool rather than int; many assignments of 0 or 1 to those variables are now spelled 'true' or 'false'. I managed this thorough conversion with the help of a custom clang plugin that I wrote to trawl the AST and apply heuristics to point out where things might want changing. So I've even managed to do a decent job on parts of the code I haven't looked at in years! To make the plugin's work easier, I pushed platform front ends generally in the direction of using standard 'bool' in preference to platform-specific boolean types like Windows BOOL or GTK's gboolean; I've left the platform booleans in places they _have_ to be for the platform APIs to work right, but variables only used by my own code have been converted wherever I found them. In a few places there are int values that look very like booleans in _most_ of the places they're used, but have a rarely-used third value, or a distinction between different nonzero values that most users don't care about. In these cases, I've _removed_ uses of 'true' and 'false' for the return values, to emphasise that there's something more subtle going on than a simple boolean answer: - the 'multisel' field in dialog.h's list box structure, for which the GTK front end in particular recognises a difference between 1 and 2 but nearly everything else treats as boolean - the 'urgent' parameter to plug_receive, where 1 vs 2 tells you something about the specific location of the urgent pointer, but most clients only care about 0 vs 'something nonzero' - the return value of wc_match, where -1 indicates a syntax error in the wildcard. - the return values from SSH-1 RSA-key loading functions, which use -1 for 'wrong passphrase' and 0 for all other failures (so any caller which already knows it's not loading an _encrypted private_ key can treat them as boolean) - term->esc_query, and the 'query' parameter in toggle_mode in terminal.c, which _usually_ hold 0 for ESC[123h or 1 for ESC[?123h, but can also hold -1 for some other intervening character that we don't support. In a few places there's an integer that I haven't turned into a bool even though it really _can_ only take values 0 or 1 (and, as above, tried to make the call sites consistent in not calling those values true and false), on the grounds that I thought it would make it more confusing to imply that the 0 value was in some sense 'negative' or bad and the 1 positive or good: - the return value of plug_accepting uses the POSIXish convention of 0=success and nonzero=error; I think if I made it bool then I'd also want to reverse its sense, and that's a job for a separate piece of work. - the 'screen' parameter to lineptr() in terminal.c, where 0 and 1 represent the default and alternate screens. There's no obvious reason why one of those should be considered 'true' or 'positive' or 'success' - they're just indices - so I've left it as int. ssh_scp_recv had particularly confusing semantics for its previous int return value: its call sites used '<= 0' to check for error, but it never actually returned a negative number, just 0 or 1. Now the function and its call sites agree that it's a bool. In a couple of places I've renamed variables called 'ret', because I don't like that name any more - it's unclear whether it means the return value (in preparation) for the _containing_ function or the return value received from a subroutine call, and occasionally I've accidentally used the same variable for both and introduced a bug. So where one of those got in my way, I've renamed it to 'toret' or 'retd' (the latter short for 'returned') in line with my usual modern practice, but I haven't done a thorough job of finding all of them. Finally, one amusing side effect of doing this is that I've had to separate quite a few chained assignments. It used to be perfectly fine to write 'a = b = c = TRUE' when a,b,c were int and TRUE was just a the 'true' defined by stdbool.h, that idiom provokes a warning from gcc: 'suggest parentheses around assignment used as truth value'!
2018-11-02 19:23:19 +00:00
(WPARAM)true, (LPARAM)clipdata);
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
} else if ((clipdata = GetClipboardData(CF_TEXT))) {
SendMessage(hwnd, WM_GOT_CLIPDATA,
Convert a lot of 'int' variables to 'bool'. My normal habit these days, in new code, is to treat int and bool as _almost_ completely separate types. I'm still willing to use C's implicit test for zero on an integer (e.g. 'if (!blob.len)' is fine, no need to spell it out as blob.len != 0), but generally, if a variable is going to be conceptually a boolean, I like to declare it bool and assign to it using 'true' or 'false' rather than 0 or 1. PuTTY is an exception, because it predates the C99 bool, and I've stuck to its existing coding style even when adding new code to it. But it's been annoying me more and more, so now that I've decided C99 bool is an acceptable thing to require from our toolchain in the first place, here's a quite thorough trawl through the source doing 'boolification'. Many variables and function parameters are now typed as bool rather than int; many assignments of 0 or 1 to those variables are now spelled 'true' or 'false'. I managed this thorough conversion with the help of a custom clang plugin that I wrote to trawl the AST and apply heuristics to point out where things might want changing. So I've even managed to do a decent job on parts of the code I haven't looked at in years! To make the plugin's work easier, I pushed platform front ends generally in the direction of using standard 'bool' in preference to platform-specific boolean types like Windows BOOL or GTK's gboolean; I've left the platform booleans in places they _have_ to be for the platform APIs to work right, but variables only used by my own code have been converted wherever I found them. In a few places there are int values that look very like booleans in _most_ of the places they're used, but have a rarely-used third value, or a distinction between different nonzero values that most users don't care about. In these cases, I've _removed_ uses of 'true' and 'false' for the return values, to emphasise that there's something more subtle going on than a simple boolean answer: - the 'multisel' field in dialog.h's list box structure, for which the GTK front end in particular recognises a difference between 1 and 2 but nearly everything else treats as boolean - the 'urgent' parameter to plug_receive, where 1 vs 2 tells you something about the specific location of the urgent pointer, but most clients only care about 0 vs 'something nonzero' - the return value of wc_match, where -1 indicates a syntax error in the wildcard. - the return values from SSH-1 RSA-key loading functions, which use -1 for 'wrong passphrase' and 0 for all other failures (so any caller which already knows it's not loading an _encrypted private_ key can treat them as boolean) - term->esc_query, and the 'query' parameter in toggle_mode in terminal.c, which _usually_ hold 0 for ESC[123h or 1 for ESC[?123h, but can also hold -1 for some other intervening character that we don't support. In a few places there's an integer that I haven't turned into a bool even though it really _can_ only take values 0 or 1 (and, as above, tried to make the call sites consistent in not calling those values true and false), on the grounds that I thought it would make it more confusing to imply that the 0 value was in some sense 'negative' or bad and the 1 positive or good: - the return value of plug_accepting uses the POSIXish convention of 0=success and nonzero=error; I think if I made it bool then I'd also want to reverse its sense, and that's a job for a separate piece of work. - the 'screen' parameter to lineptr() in terminal.c, where 0 and 1 represent the default and alternate screens. There's no obvious reason why one of those should be considered 'true' or 'positive' or 'success' - they're just indices - so I've left it as int. ssh_scp_recv had particularly confusing semantics for its previous int return value: its call sites used '<= 0' to check for error, but it never actually returned a negative number, just 0 or 1. Now the function and its call sites agree that it's a bool. In a couple of places I've renamed variables called 'ret', because I don't like that name any more - it's unclear whether it means the return value (in preparation) for the _containing_ function or the return value received from a subroutine call, and occasionally I've accidentally used the same variable for both and introduced a bug. So where one of those got in my way, I've renamed it to 'toret' or 'retd' (the latter short for 'returned') in line with my usual modern practice, but I haven't done a thorough job of finding all of them. Finally, one amusing side effect of doing this is that I've had to separate quite a few chained assignments. It used to be perfectly fine to write 'a = b = c = TRUE' when a,b,c were int and TRUE was just a the 'true' defined by stdbool.h, that idiom provokes a warning from gcc: 'suggest parentheses around assignment used as truth value'!
2018-11-02 19:23:19 +00:00
(WPARAM)false, (LPARAM)clipdata);
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
}
CloseClipboard();
Move the code that reads the Windows clipboard into a trivial subthread, so that it won't deadlock if fetching the content of the clipboard turns out to depend on a network connection forwarded through PuTTY. [originally from svn r8338]
2008-11-28 18:28:23 +00:00
}
return 0;
}
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
static void process_clipdata(WinGuiSeat *wgs, HGLOBAL clipdata, bool unicode)
Move the code that reads the Windows clipboard into a trivial subthread, so that it won't deadlock if fetching the content of the clipboard turns out to depend on a network connection forwarded through PuTTY. [originally from svn r8338]
2008-11-28 18:28:23 +00:00
{
Stop front ends remembering the data of their last paste. Previously, both the Unix and Windows front ends would respond to a paste action by retrieving data from the system clipboard, converting it appropriately, _storing_ it in a persistent dynamic data block inside the front end, and then calling term_do_paste(term), which in turn would call back to the front end via get_clip() to retrieve the current contents of that stored data block. But, as far as I can tell, this was a completely pointless mechanism, because after a data block was written into this storage area, it would be immediately used for exactly one paste, and then never accessed again until the next paste action caused it to be freed and replaced with a new chunk of pasted data. So why on earth was it stored persistently at all, and why that callback mechanism from frontend to terminal back to frontend to retrieve it for the actual paste action? I have no idea. This change removes the entire system and replaces it with the completely obvious alternative: the character-set-converted version of paste data is allocated in a _local_ variable in the frontend paste functions, passed directly to term_do_paste which now takes (buffer,length) parameters, and freed immediately afterwards. get_clip() is gone.
2017-12-09 08:41:03 +00:00
wchar_t *clipboard_contents = NULL;
size_t clipboard_length = 0;
Move the code that reads the Windows clipboard into a trivial subthread, so that it won't deadlock if fetching the content of the clipboard turns out to depend on a network connection forwarded through PuTTY. [originally from svn r8338]
2008-11-28 18:28:23 +00:00
if (unicode) {
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
wchar_t *p = GlobalLock(clipdata);
wchar_t *p2;
if (p) {
/* Unwilling to rely on Windows having wcslen() */
for (p2 = p; *p2; p2++);
clipboard_length = p2 - p;
clipboard_contents = snewn(clipboard_length + 1, wchar_t);
memcpy(clipboard_contents, p, clipboard_length * sizeof(wchar_t));
clipboard_contents[clipboard_length] = L'\0';
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
term_do_paste(wgs->term, clipboard_contents, clipboard_length);
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
}
Move the code that reads the Windows clipboard into a trivial subthread, so that it won't deadlock if fetching the content of the clipboard turns out to depend on a network connection forwarded through PuTTY. [originally from svn r8338]
2008-11-28 18:28:23 +00:00
} else {
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
char *s = GlobalLock(clipdata);
int i;
if (s) {
i = MultiByteToWideChar(CP_ACP, 0, s, strlen(s) + 1, 0, 0);
clipboard_contents = snewn(i, wchar_t);
MultiByteToWideChar(CP_ACP, 0, s, strlen(s) + 1,
clipboard_contents, i);
clipboard_length = i - 1;
clipboard_contents[clipboard_length] = L'\0';
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
term_do_paste(wgs->term, clipboard_contents, clipboard_length);
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
}
Initial checkin: beta 0.43 [originally from svn r11]
1999-01-08 13:02:13 +00:00
}
Stop front ends remembering the data of their last paste. Previously, both the Unix and Windows front ends would respond to a paste action by retrieving data from the system clipboard, converting it appropriately, _storing_ it in a persistent dynamic data block inside the front end, and then calling term_do_paste(term), which in turn would call back to the front end via get_clip() to retrieve the current contents of that stored data block. But, as far as I can tell, this was a completely pointless mechanism, because after a data block was written into this storage area, it would be immediately used for exactly one paste, and then never accessed again until the next paste action caused it to be freed and replaced with a new chunk of pasted data. So why on earth was it stored persistently at all, and why that callback mechanism from frontend to terminal back to frontend to retrieve it for the actual paste action? I have no idea. This change removes the entire system and replaces it with the completely obvious alternative: the character-set-converted version of paste data is allocated in a _local_ variable in the frontend paste functions, passed directly to term_do_paste which now takes (buffer,length) parameters, and freed immediately afterwards. get_clip() is gone.
2017-12-09 08:41:03 +00:00
sfree(clipboard_contents);
Move the code that reads the Windows clipboard into a trivial subthread, so that it won't deadlock if fetching the content of the clipboard turns out to depend on a network connection forwarded through PuTTY. [originally from svn r8338]
2008-11-28 18:28:23 +00:00
}
Remove the 'Frontend' type and replace it with a vtable. After the recent Seat and LogContext revamps, _nearly_ all the remaining uses of the type 'Frontend' were in terminal.c, which needs all sorts of interactions with the GUI window the terminal lives in, from the obvious (actually drawing text on the window, reading and writing the clipboard) to the obscure (minimising, maximising and moving the window in response to particular escape sequences). All of those functions are now provided by an abstraction called TermWin. The few remaining uses of Frontend after _that_ are internal to a particular platform directory, so as to spread the implementation of that particular kind of Frontend between multiple source files; so I've renamed all of those so that they take a more specifically named type that refers to the particular implementation rather than the general abstraction. So now the name 'Frontend' no longer exists in the code base at all, and everywhere one used to be used, it's completely clear whether it was operating in one of Frontend's three abstract roles (and if so, which), or whether it was specific to a particular implementation. Another type that's disappeared is 'Context', which used to be a typedef defined to something different on each platform, describing whatever short-lived resources were necessary to draw on the terminal window: the front end would provide a ready-made one when calling term_paint, and the terminal could request one with get_ctx/free_ctx if it wanted to do proactive window updates. Now that drawing context lives inside the TermWin itself, because there was never any need to have two of those contexts live at the same time. (Another minor API change is that the window-title functions - both reading and writing - have had a missing 'const' added to their char * parameters / return values.) I don't expect this change to enable any particularly interesting new functionality (in particular, I have no plans that need more than one implementation of TermWin in the same application). But it completes the tidying-up that began with the Seat and LogContext rework.
2018-10-25 17:44:04 +00:00
static void wintw_clip_request_paste(TermWin *tw, int clipboard)
Move the code that reads the Windows clipboard into a trivial subthread, so that it won't deadlock if fetching the content of the clipboard turns out to depend on a network connection forwarded through PuTTY. [originally from svn r8338]
2008-11-28 18:28:23 +00:00
{
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
WinGuiSeat *wgs = container_of(tw, WinGuiSeat, termwin);
Add a system of clipboard identifiers. This lays some groundwork for making PuTTY's cut and paste handling more flexible in the area of which clipboard(s) it reads and writes, if more than one is available on the system. I've introduced a system of list macros which define an enumeration of integer clipboard ids, some defined centrally in putty.h (at present just a CLIP_NULL which never has any text in it, because that seems like the sort of thing that will come in useful for configuring a given copy or paste UI action to be ignored) and some defined per platform. All the front end functions that copy and paste take a clipboard id, and the Terminal structure is now configured at startup to tell it which clipboard id it should paste from on a mouse click, and which it should copy from on a selection. However, I haven't actually added _real_ support for multiple X11 clipboards, in that the Unix front end supports a single CLIP_SYSTEM regardless of whether it's in OS X or GTK mode. So this is currently a NFC refactoring which does nothing but prepare the way for real changes to come.
2017-12-09 12:00:13 +00:00
assert(clipboard == CLIP_SYSTEM);
Move the code that reads the Windows clipboard into a trivial subthread, so that it won't deadlock if fetching the content of the clipboard turns out to depend on a network connection forwarded through PuTTY. [originally from svn r8338]
2008-11-28 18:28:23 +00:00
/*
* I always thought pasting was synchronous in Windows; the
* clipboard access functions certainly _look_ synchronous,
* unlike the X ones. But in fact it seems that in some
* situations the contents of the clipboard might not be
* immediately available, and the clipboard-reading functions
* may block. This leads to trouble if the application
* delivering the clipboard data has to get hold of it by -
* for example - talking over a network connection which is
* forwarded through this very PuTTY.
*
* Hence, we spawn a subthread to read the clipboard, and do
* our paste when it's finished. The thread will send a
* message back to our main window when it terminates, and
* that tells us it's OK to paste.
*/
DWORD in_threadid; /* required for Win9x */
Close all thread handles returned from CreateThread. If you don't, they are permanently leaked. A user points out that this is particularly bad in Pageant, with the new named-pipe-based IPC, since it will spawn an input and output I/O thread per named pipe connection, leading to two handles being leaked every time.
2021-07-01 17:30:00 +00:00
HANDLE hThread = CreateThread(NULL, 0, clipboard_read_threadfunc,
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
wgs->term_hwnd, 0, &in_threadid);
Close all thread handles returned from CreateThread. If you don't, they are permanently leaked. A user points out that this is particularly bad in Pageant, with the new named-pipe-based IPC, since it will spawn an input and output I/O thread per named pipe connection, leading to two handles being leaked every time.
2021-07-01 17:30:00 +00:00
if (hThread)
CloseHandle(hThread); /* we don't need the thread handle */
Move the code that reads the Windows clipboard into a trivial subthread, so that it won't deadlock if fetching the content of the clipboard turns out to depend on a network connection forwarded through PuTTY. [originally from svn r8338]
2008-11-28 18:28:23 +00:00
}
First phase of porting. pterm now compiles and runs under Linux+gtk. The current pty.c backend is temporarily a loopback device for terminal emulator testing, the display handling is only just enough to show that terminal.c is functioning, the keyboard handling is laughable, and most features are absent. Next step: bring output and input up to a plausibly working state, and put a real pty on the back to create a vaguely usable prototype. Oh, and a scrollbar would be nice too. In _theory_ the Windows builds should still work fine after this... [originally from svn r2010]
2002-10-09 18:09:42 +00:00
/*
* Print a modal (Really Bad) message box and perform a fatal exit.
*/
Giant const-correctness patch of doom! Having found a lot of unfixed constness issues in recent development, I thought perhaps it was time to get proactive, so I compiled the whole codebase with -Wwrite-strings. That turned up a huge load of const problems, which I've fixed in this commit: the Unix build now goes cleanly through with -Wwrite-strings, and the Windows build is as close as I could get it (there are some lingering issues due to occasional Windows API functions like AcquireCredentialsHandle not having the right constness). Notable fallout beyond the purely mechanical changing of types: - the stuff saved by cmdline_save_param() is now explicitly dupstr()ed, and freed in cmdline_run_saved. - I couldn't make both string arguments to cmdline_process_param() const, because it intentionally writes to one of them in the case where it's the argument to -pw (in the vain hope of being at least slightly friendly to 'ps'), so elsewhere I had to temporarily dupstr() something for the sake of passing it to that function - I had to invent a silly parallel version of const_cmp() so I could pass const string literals in to lookup functions. - stripslashes() in pscp.c and psftp.c has the annoying strchr nature
2015-05-15 10:15:42 +00:00
void modalfatalbox(const char *fmt, ...)
First phase of porting. pterm now compiles and runs under Linux+gtk. The current pty.c backend is temporarily a loopback device for terminal emulator testing, the display handling is only just enough to show that terminal.c is functioning, the keyboard handling is laughable, and most features are absent. Next step: bring output and input up to a plausibly working state, and put a real pty on the back to create a vaguely usable prototype. Oh, and a scrollbar would be nice too. In _theory_ the Windows builds should still work fine after this... [originally from svn r2010]
2002-10-09 18:09:42 +00:00
{
va_list ap;
Remove a load of obsolete printf string limits. In the previous commit I happened to notice a %.150s in a ppl_logevent call, which was probably an important safety precaution a couple of decades ago when that format string was being used for an sprintf into a fixed-size buffer, but now it's just pointless cruft. This commit removes all printf string formatting directives with a compile-time fixed size, with the one exception of a %.3s used to cut out a 3-letter month name in scpserver.c. In cases where the format string in question was already going to an arbitrary-length function like dupprintf or ppl_logevent, that's all I've done; in cases where there was still a fixed-size buffer, I've replaced it with a dynamic buffer and dupprintf.
2018-12-08 21:03:51 +00:00
char *message, *title;
First phase of porting. pterm now compiles and runs under Linux+gtk. The current pty.c backend is temporarily a loopback device for terminal emulator testing, the display handling is only just enough to show that terminal.c is functioning, the keyboard handling is laughable, and most features are absent. Next step: bring output and input up to a plausibly working state, and put a real pty on the back to create a vaguely usable prototype. Oh, and a scrollbar would be nice too. In _theory_ the Windows builds should still work fine after this... [originally from svn r2010]
2002-10-09 18:09:42 +00:00
va_start(ap, fmt);
Remove a load of obsolete printf string limits. In the previous commit I happened to notice a %.150s in a ppl_logevent call, which was probably an important safety precaution a couple of decades ago when that format string was being used for an sprintf into a fixed-size buffer, but now it's just pointless cruft. This commit removes all printf string formatting directives with a compile-time fixed size, with the one exception of a %.3s used to cut out a 3-letter month name in scpserver.c. In cases where the format string in question was already going to an arbitrary-length function like dupprintf or ppl_logevent, that's all I've done; in cases where there was still a fixed-size buffer, I've replaced it with a dynamic buffer and dupprintf.
2018-12-08 21:03:51 +00:00
message = dupvprintf(fmt, ap);
First phase of porting. pterm now compiles and runs under Linux+gtk. The current pty.c backend is temporarily a loopback device for terminal emulator testing, the display handling is only just enough to show that terminal.c is functioning, the keyboard handling is laughable, and most features are absent. Next step: bring output and input up to a plausibly working state, and put a real pty on the back to create a vaguely usable prototype. Oh, and a scrollbar would be nice too. In _theory_ the Windows builds should still work fine after this... [originally from svn r2010]
2002-10-09 18:09:42 +00:00
va_end(ap);
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
show_mouseptr(NULL, true);
Remove a load of obsolete printf string limits. In the previous commit I happened to notice a %.150s in a ppl_logevent call, which was probably an important safety precaution a couple of decades ago when that format string was being used for an sprintf into a fixed-size buffer, but now it's just pointless cruft. This commit removes all printf string formatting directives with a compile-time fixed size, with the one exception of a %.3s used to cut out a 3-letter month name in scpserver.c. In cases where the format string in question was already going to an arbitrary-length function like dupprintf or ppl_logevent, that's all I've done; in cases where there was still a fixed-size buffer, I've replaced it with a dynamic buffer and dupprintf.
2018-12-08 21:03:51 +00:00
title = dupprintf("%s Fatal Error", appname);
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
MessageBox(find_window_for_msgbox(), message, title,
GUI PuTTY: stop using the global 'hwnd'. This was the difficult part of cleaning up that global variable. The main Windows PuTTY GUI is split between source files, so that _does_ actually need to refer to the main window from multiple places. But all the places where windlg.c needed to use 'hwnd' are seat methods, so they were already receiving a Seat pointer as a parameter. In other words, the methods of the Windows GUI Seat were already split between source files. So it seems only fair that they should be able to share knowledge of the seat's data as well. Hence, I've created a small 'WinGuiSeat' structure which both window.c and windlg.c can see the layout of, and put the main terminal window handle in there. Then the seat methods implemented in windlg.c, like win_seat_verify_ssh_host_key, can use container_of to turn the Seat pointer parameter back into the address of that structure, just as the methods in window.c can do (even though they currently don't need to). (Who knows: now that it _exists_, perhaps that structure can be gradually expanded in future to turn it into a proper encapsulation of all the Windows frontend's state, like we should have had all along...) I've also moved the Windows GUI LogPolicy implementation into the same object (i.e. WinGuiSeat implements both traits at once). That allows win_gui_logging_error to recover the same WinGuiSeat from its input LogPolicy pointer, which means it can get from there to the Seat facet of the same object, so that I don't need the extern variable 'win_seat' any more either.
2020-02-02 10:00:43 +00:00
MB_SYSTEMMODAL | MB_ICONERROR | MB_OK);
Remove a load of obsolete printf string limits. In the previous commit I happened to notice a %.150s in a ppl_logevent call, which was probably an important safety precaution a couple of decades ago when that format string was being used for an sprintf into a fixed-size buffer, but now it's just pointless cruft. This commit removes all printf string formatting directives with a compile-time fixed size, with the one exception of a %.3s used to cut out a 3-letter month name in scpserver.c. In cases where the format string in question was already going to an arbitrary-length function like dupprintf or ppl_logevent, that's all I've done; in cases where there was still a fixed-size buffer, I've replaced it with a dynamic buffer and dupprintf.
2018-12-08 21:03:51 +00:00
sfree(message);
sfree(title);
First phase of porting. pterm now compiles and runs under Linux+gtk. The current pty.c backend is temporarily a loopback device for terminal emulator testing, the display handling is only just enough to show that terminal.c is functioning, the keyboard handling is laughable, and most features are absent. Next step: bring output and input up to a plausibly working state, and put a real pty on the back to create a vaguely usable prototype. Oh, and a scrollbar would be nice too. In _theory_ the Windows builds should still work fine after this... [originally from svn r2010]
2002-10-09 18:09:42 +00:00
cleanup_exit(1);
}
Add a nonfatal() function everywhere, to be used for reporting things that the user really ought to know but that are not actually fatal to continued operation of PuTTY or a single network connection. [originally from svn r9932]
2013-07-19 17:44:28 +00:00
/*
* Print a message box and don't close the connection.
*/
Giant const-correctness patch of doom! Having found a lot of unfixed constness issues in recent development, I thought perhaps it was time to get proactive, so I compiled the whole codebase with -Wwrite-strings. That turned up a huge load of const problems, which I've fixed in this commit: the Unix build now goes cleanly through with -Wwrite-strings, and the Windows build is as close as I could get it (there are some lingering issues due to occasional Windows API functions like AcquireCredentialsHandle not having the right constness). Notable fallout beyond the purely mechanical changing of types: - the stuff saved by cmdline_save_param() is now explicitly dupstr()ed, and freed in cmdline_run_saved. - I couldn't make both string arguments to cmdline_process_param() const, because it intentionally writes to one of them in the case where it's the argument to -pw (in the vain hope of being at least slightly friendly to 'ps'), so elsewhere I had to temporarily dupstr() something for the sake of passing it to that function - I had to invent a silly parallel version of const_cmp() so I could pass const string literals in to lookup functions. - stripslashes() in pscp.c and psftp.c has the annoying strchr nature
2015-05-15 10:15:42 +00:00
void nonfatal(const char *fmt, ...)
Add a nonfatal() function everywhere, to be used for reporting things that the user really ought to know but that are not actually fatal to continued operation of PuTTY or a single network connection. [originally from svn r9932]
2013-07-19 17:44:28 +00:00
{
va_list ap;
Remove a load of obsolete printf string limits. In the previous commit I happened to notice a %.150s in a ppl_logevent call, which was probably an important safety precaution a couple of decades ago when that format string was being used for an sprintf into a fixed-size buffer, but now it's just pointless cruft. This commit removes all printf string formatting directives with a compile-time fixed size, with the one exception of a %.3s used to cut out a 3-letter month name in scpserver.c. In cases where the format string in question was already going to an arbitrary-length function like dupprintf or ppl_logevent, that's all I've done; in cases where there was still a fixed-size buffer, I've replaced it with a dynamic buffer and dupprintf.
2018-12-08 21:03:51 +00:00
char *message, *title;
Add a nonfatal() function everywhere, to be used for reporting things that the user really ought to know but that are not actually fatal to continued operation of PuTTY or a single network connection. [originally from svn r9932]
2013-07-19 17:44:28 +00:00
va_start(ap, fmt);
Remove a load of obsolete printf string limits. In the previous commit I happened to notice a %.150s in a ppl_logevent call, which was probably an important safety precaution a couple of decades ago when that format string was being used for an sprintf into a fixed-size buffer, but now it's just pointless cruft. This commit removes all printf string formatting directives with a compile-time fixed size, with the one exception of a %.3s used to cut out a 3-letter month name in scpserver.c. In cases where the format string in question was already going to an arbitrary-length function like dupprintf or ppl_logevent, that's all I've done; in cases where there was still a fixed-size buffer, I've replaced it with a dynamic buffer and dupprintf.
2018-12-08 21:03:51 +00:00
message = dupvprintf(fmt, ap);
Add a nonfatal() function everywhere, to be used for reporting things that the user really ought to know but that are not actually fatal to continued operation of PuTTY or a single network connection. [originally from svn r9932]
2013-07-19 17:44:28 +00:00
va_end(ap);
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
show_mouseptr(NULL, true);
Remove a load of obsolete printf string limits. In the previous commit I happened to notice a %.150s in a ppl_logevent call, which was probably an important safety precaution a couple of decades ago when that format string was being used for an sprintf into a fixed-size buffer, but now it's just pointless cruft. This commit removes all printf string formatting directives with a compile-time fixed size, with the one exception of a %.3s used to cut out a 3-letter month name in scpserver.c. In cases where the format string in question was already going to an arbitrary-length function like dupprintf or ppl_logevent, that's all I've done; in cases where there was still a fixed-size buffer, I've replaced it with a dynamic buffer and dupprintf.
2018-12-08 21:03:51 +00:00
title = dupprintf("%s Error", appname);
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
MessageBox(find_window_for_msgbox(), message, title, MB_ICONERROR | MB_OK);
Remove a load of obsolete printf string limits. In the previous commit I happened to notice a %.150s in a ppl_logevent call, which was probably an important safety precaution a couple of decades ago when that format string was being used for an sprintf into a fixed-size buffer, but now it's just pointless cruft. This commit removes all printf string formatting directives with a compile-time fixed size, with the one exception of a %.3s used to cut out a 3-letter month name in scpserver.c. In cases where the format string in question was already going to an arbitrary-length function like dupprintf or ppl_logevent, that's all I've done; in cases where there was still a fixed-size buffer, I've replaced it with a dynamic buffer and dupprintf.
2018-12-08 21:03:51 +00:00
sfree(message);
sfree(title);
Add a nonfatal() function everywhere, to be used for reporting things that the user really ought to know but that are not actually fatal to continued operation of PuTTY or a single network connection. [originally from svn r9932]
2013-07-19 17:44:28 +00:00
}
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
static bool flash_window_ex(WinGuiSeat *wgs, DWORD dwFlags,
UINT uCount, DWORD dwTimeout)
At least, I have the technology to fix `beepind-win2k'. Tested on Win98, Win2K, and WinXP. [originally from svn r7119] [this svn revision also touched putty-wishlist]
2007-01-16 20:54:58 +00:00
{
if (p_FlashWindowEx) {
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
FLASHWINFO fi;
fi.cbSize = sizeof(fi);
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
fi.hwnd = wgs->term_hwnd;
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
fi.dwFlags = dwFlags;
fi.uCount = uCount;
fi.dwTimeout = dwTimeout;
return (*p_FlashWindowEx)(&fi);
At least, I have the technology to fix `beepind-win2k'. Tested on Win98, Win2K, and WinXP. [originally from svn r7119] [this svn revision also touched putty-wishlist]
2007-01-16 20:54:58 +00:00
}
else
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
return false; /* shrug */
At least, I have the technology to fix `beepind-win2k'. Tested on Win98, Win2K, and WinXP. [originally from svn r7119] [this svn revision also touched putty-wishlist]
2007-01-16 20:54:58 +00:00
}
/*
* Timer for platforms where we must maintain window flashing manually
* (e.g., Win95).
*/
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
static void flash_window_timer(void *vctx, unsigned long now)
New timing infrastructure. There's a new function schedule_timer() which pretty much any module can call to request a call-back in the future. So terminal.c can do its own handling of blinking, visual bells and deferred screen updates, without having to rely on term_update() being called 50 times a second (fixes: pterm-timer); and ssh.c and telnet.c both invoke a new module pinger.c which takes care of sending keepalives, so they get sent uniformly in all front ends (fixes: plink-keepalives, unix-keepalives). [originally from svn r4906] [this svn revision also touched putty-wishlist]
2004-11-27 13:20:21 +00:00
{
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
WinGuiSeat *wgs = (WinGuiSeat *)vctx;
if (wgs->flashing && now == wgs->next_flash) {
flash_window(wgs, 1);
New timing infrastructure. There's a new function schedule_timer() which pretty much any module can call to request a call-back in the future. So terminal.c can do its own handling of blinking, visual bells and deferred screen updates, without having to rely on term_update() being called 50 times a second (fixes: pterm-timer); and ssh.c and telnet.c both invoke a new module pinger.c which takes care of sending keepalives, so they get sent uniformly in all front ends (fixes: plink-keepalives, unix-keepalives). [originally from svn r4906] [this svn revision also touched putty-wishlist]
2004-11-27 13:20:21 +00:00
}
}
Glenn Maynard's patch (as adapted by Jacob) for taskbar flashing when a bell occurs and the window is minimised. [originally from svn r1123]
2001-05-13 14:42:17 +00:00
/*
* Manage window caption / taskbar flashing, if enabled.
* 0 = stop, 1 = maintain, 2 = start
*/
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
static void flash_window(WinGuiSeat *wgs, int mode)
Glenn Maynard's patch (as adapted by Jacob) for taskbar flashing when a bell occurs and the window is minimised. [originally from svn r1123]
2001-05-13 14:42:17 +00:00
{
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
int beep_ind = conf_get_int(wgs->conf, CONF_beep_ind);
Post-release destabilisation! Completely remove the struct type 'Config' in putty.h, which stores all PuTTY's settings and includes an arbitrary length limit on every single one of those settings which is stored in string form. In place of it is 'Conf', an opaque data type everywhere outside the new file conf.c, which stores a list of (key, value) pairs in which every key contains an integer identifying a configuration setting, and for some of those integers the key also contains extra parts (so that, for instance, CONF_environmt is a string-to-string mapping). Everywhere that a Config was previously used, a Conf is now; everywhere there was a Config structure copy, conf_copy() is called; every lookup, adjustment, load and save operation on a Config has been rewritten; and there's a mechanism for serialising a Conf into a binary blob and back for use with Duplicate Session. User-visible effects of this change _should_ be minimal, though I don't doubt I've introduced one or two bugs here and there which will eventually be found. The _intended_ visible effects of this change are that all arbitrary limits on configuration strings and lists (e.g. limit on number of port forwardings) should now disappear; that list boxes in the configuration will now be displayed in a sorted order rather than the arbitrary order in which they were added to the list (since the underlying data structure is now a sorted tree234 rather than an ad-hoc comma-separated string); and one more specific change, which is that local and dynamic port forwardings on the same port number are now mutually exclusive in the configuration (putting 'D' in the key rather than the value was a mistake in the first place). One other reorganisation as a result of this is that I've moved all the dialog.c standard handlers (dlg_stdeditbox_handler and friends) out into config.c, because I can't really justify calling them generic any more. When they took a pointer to an arbitrary structure type and the offset of a field within that structure, they were independent of whether that structure was a Config or something completely different, but now they really do expect to talk to a Conf, which can _only_ be used for PuTTY configuration, so I've renamed them all things like conf_editbox_handler and moved them out of the nominally independent dialog-box management module into the PuTTY-specific config.c. [originally from svn r9214]
2011-07-14 18:52:21 +00:00
if ((mode == 0) || (beep_ind == B_IND_DISABLED)) {
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
/* stop */
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
if (wgs->flashing) {
wgs->flashing = false;
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
if (p_FlashWindowEx)
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
flash_window_ex(wgs, FLASHW_STOP, 0, 0);
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
else
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
FlashWindow(wgs->term_hwnd, false);
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
}
Glenn Maynard's patch (as adapted by Jacob) for taskbar flashing when a bell occurs and the window is minimised. [originally from svn r1123]
2001-05-13 14:42:17 +00:00
} else if (mode == 2) {
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
/* start */
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
if (!wgs->flashing) {
wgs->flashing = true;
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
if (p_FlashWindowEx) {
/* For so-called "steady" mode, we use uCount=2, which
* seems to be the traditional number of flashes used
* by user notifications (e.g., by Explorer).
* uCount=0 appears to enable continuous flashing, per
* "flashing" mode, although I haven't seen this
* documented. */
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
flash_window_ex(wgs, FLASHW_ALL | FLASHW_TIMER,
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
(beep_ind == B_IND_FLASH ? 0 : 2),
0 /* system cursor blink rate */);
/* No need to schedule timer */
} else {
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
FlashWindow(wgs->term_hwnd, true);
wgs->next_flash = schedule_timer(450, flash_window_timer, wgs);
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
}
}
Glenn Maynard's patch (as adapted by Jacob) for taskbar flashing when a bell occurs and the window is minimised. [originally from svn r1123]
2001-05-13 14:42:17 +00:00
Post-release destabilisation! Completely remove the struct type 'Config' in putty.h, which stores all PuTTY's settings and includes an arbitrary length limit on every single one of those settings which is stored in string form. In place of it is 'Conf', an opaque data type everywhere outside the new file conf.c, which stores a list of (key, value) pairs in which every key contains an integer identifying a configuration setting, and for some of those integers the key also contains extra parts (so that, for instance, CONF_environmt is a string-to-string mapping). Everywhere that a Config was previously used, a Conf is now; everywhere there was a Config structure copy, conf_copy() is called; every lookup, adjustment, load and save operation on a Config has been rewritten; and there's a mechanism for serialising a Conf into a binary blob and back for use with Duplicate Session. User-visible effects of this change _should_ be minimal, though I don't doubt I've introduced one or two bugs here and there which will eventually be found. The _intended_ visible effects of this change are that all arbitrary limits on configuration strings and lists (e.g. limit on number of port forwardings) should now disappear; that list boxes in the configuration will now be displayed in a sorted order rather than the arbitrary order in which they were added to the list (since the underlying data structure is now a sorted tree234 rather than an ad-hoc comma-separated string); and one more specific change, which is that local and dynamic port forwardings on the same port number are now mutually exclusive in the configuration (putting 'D' in the key rather than the value was a mistake in the first place). One other reorganisation as a result of this is that I've moved all the dialog.c standard handlers (dlg_stdeditbox_handler and friends) out into config.c, because I can't really justify calling them generic any more. When they took a pointer to an arbitrary structure type and the offset of a field within that structure, they were independent of whether that structure was a Config or something completely different, but now they really do expect to talk to a Conf, which can _only_ be used for PuTTY configuration, so I've renamed them all things like conf_editbox_handler and moved them out of the nominally independent dialog-box management module into the PuTTY-specific config.c. [originally from svn r9214]
2011-07-14 18:52:21 +00:00
} else if ((mode == 1) && (beep_ind == B_IND_FLASH)) {
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
/* maintain */
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
if (wgs->flashing && !p_FlashWindowEx) {
FlashWindow(wgs->term_hwnd, true); /* toggle */
wgs->next_flash = schedule_timer(450, flash_window_timer, wgs);
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
}
Glenn Maynard's patch (as adapted by Jacob) for taskbar flashing when a bell occurs and the window is minimised. [originally from svn r1123]
2001-05-13 14:42:17 +00:00
}
}
Initial checkin: beta 0.43 [originally from svn r11]
1999-01-08 13:02:13 +00:00
/*
* Beep.
*/
Remove the 'Frontend' type and replace it with a vtable. After the recent Seat and LogContext revamps, _nearly_ all the remaining uses of the type 'Frontend' were in terminal.c, which needs all sorts of interactions with the GUI window the terminal lives in, from the obvious (actually drawing text on the window, reading and writing the clipboard) to the obscure (minimising, maximising and moving the window in response to particular escape sequences). All of those functions are now provided by an abstraction called TermWin. The few remaining uses of Frontend after _that_ are internal to a particular platform directory, so as to spread the implementation of that particular kind of Frontend between multiple source files; so I've renamed all of those so that they take a more specifically named type that refers to the particular implementation rather than the general abstraction. So now the name 'Frontend' no longer exists in the code base at all, and everywhere one used to be used, it's completely clear whether it was operating in one of Frontend's three abstract roles (and if so, which), or whether it was specific to a particular implementation. Another type that's disappeared is 'Context', which used to be a typedef defined to something different on each platform, describing whatever short-lived resources were necessary to draw on the terminal window: the front end would provide a ready-made one when calling term_paint, and the terminal could request one with get_ctx/free_ctx if it wanted to do proactive window updates. Now that drawing context lives inside the TermWin itself, because there was never any need to have two of those contexts live at the same time. (Another minor API change is that the window-title functions - both reading and writing - have had a missing 'const' added to their char * parameters / return values.) I don't expect this change to enable any particularly interesting new functionality (in particular, I have no plans that need more than one implementation of TermWin in the same application). But it completes the tidying-up that began with the Seat and LogContext rework.
2018-10-25 17:44:04 +00:00
static void wintw_bell(TermWin *tw, int mode)
Run entire source base through GNU indent to tidy up the varying coding styles of the various contributors! Woohoo! [originally from svn r1098]
2001-05-06 14:35:20 +00:00
{
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
WinGuiSeat *wgs = container_of(tw, WinGuiSeat, termwin);
Bell can now play an arbitrary sound file. [originally from svn r1041]
2001-04-14 11:37:47 +00:00
if (mode == BELL_DEFAULT) {
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
/*
* For MessageBeep style bells, we want to be careful of
* timing, because they don't have the nice property of
* PlaySound bells that each one cancels the previous
* active one. So we limit the rate to one per 50ms or so.
*/
long beepdiff;
windows/window.c: move more variables into WinGuiSeat. In commit f9e572595bb8cb6 I claimed that I'd removed very nearly all the global and static variables from windows/window.c. It turns out that this was wildly overoptimistic - I missed quite a few of them! I'm not quite sure how I managed that; my best guess is that I used an underpowered 'nm' command that failed to find some classes of variable. Some of the remaining function-scope statics were removed completely by commit afb3dab1e97a09f just now. In this commit, I've swept up some more and turn them into fields of WinGuiSeat, where they should have been moved last September. The (hopefully complete this time) list of remaining variables, generated by running this rune in the Windows build directory: nm windows/CMakeFiles/putty.dir/window.c.obj | grep -E '^([^ ]+)? *[bBcCdDgGsS] [^\.]' consists of the following variables which are legitimately global across the whole process and not related to a particular window: - 'hinst' and 'hprev', instance handles for Windows loadable modules - 'classname' in the terminal_window_class_a() and terminal_window_class_w() functions, which allocate a window class reusably - some pointers to Windows API functions retrieved via the DECL_WINDOWS_FUNCTION / GET_WINDOWS_FUNCTION system, such as p_AdjustWindowRectExForDpi and p_FlashWindowEx - some pointers to Windows API functions set up by assigning them at startup to the right one of the ANSI or Unicode version depending on the Windows version, e.g. sw_DefWindowProc and sw_DispatchMessage - 'unicode_window', a boolean flag set at the same time as those sw_Foo function pointers - 'sesslist', storing the last-retrieved version of the saved sessions menu - 'cursor_visible' in show_mouseptr() and 'forced_visible' in update_mouse_pointer(), each of which tracks the cumulative number of times that function has shown or hidden the mouse pointer, so as to manage its effect on the global state updated by ShowCursor - 'trust_icon', loaded from the executable's resources - 'wgslisthead', the list of all active WinGuiSeats - 'wm_mousewheel', the window-message id we use for mouse wheel events and the following which are nothing to do with our code: - '_OptionsStorage' in __local_stdio_printf_options() and __local_stdio_scanf_options(), which I'd never noticed before, but apparently are internal to a standard library header.
2023-05-27 13:59:20 +00:00
beepdiff = GetTickCount() - wgs->last_beep_time;
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
if (beepdiff >= 0 && beepdiff < 50)
return;
MessageBeep(MB_OK);
/*
* The above MessageBeep call takes time, so we record the
* time _after_ it finishes rather than before it starts.
*/
windows/window.c: move more variables into WinGuiSeat. In commit f9e572595bb8cb6 I claimed that I'd removed very nearly all the global and static variables from windows/window.c. It turns out that this was wildly overoptimistic - I missed quite a few of them! I'm not quite sure how I managed that; my best guess is that I used an underpowered 'nm' command that failed to find some classes of variable. Some of the remaining function-scope statics were removed completely by commit afb3dab1e97a09f just now. In this commit, I've swept up some more and turn them into fields of WinGuiSeat, where they should have been moved last September. The (hopefully complete this time) list of remaining variables, generated by running this rune in the Windows build directory: nm windows/CMakeFiles/putty.dir/window.c.obj | grep -E '^([^ ]+)? *[bBcCdDgGsS] [^\.]' consists of the following variables which are legitimately global across the whole process and not related to a particular window: - 'hinst' and 'hprev', instance handles for Windows loadable modules - 'classname' in the terminal_window_class_a() and terminal_window_class_w() functions, which allocate a window class reusably - some pointers to Windows API functions retrieved via the DECL_WINDOWS_FUNCTION / GET_WINDOWS_FUNCTION system, such as p_AdjustWindowRectExForDpi and p_FlashWindowEx - some pointers to Windows API functions set up by assigning them at startup to the right one of the ANSI or Unicode version depending on the Windows version, e.g. sw_DefWindowProc and sw_DispatchMessage - 'unicode_window', a boolean flag set at the same time as those sw_Foo function pointers - 'sesslist', storing the last-retrieved version of the saved sessions menu - 'cursor_visible' in show_mouseptr() and 'forced_visible' in update_mouse_pointer(), each of which tracks the cumulative number of times that function has shown or hidden the mouse pointer, so as to manage its effect on the global state updated by ShowCursor - 'trust_icon', loaded from the executable's resources - 'wgslisthead', the list of all active WinGuiSeats - 'wm_mousewheel', the window-message id we use for mouse wheel events and the following which are nothing to do with our code: - '_OptionsStorage' in __local_stdio_printf_options() and __local_stdio_scanf_options(), which I'd never noticed before, but apparently are internal to a standard library header.
2023-05-27 13:59:20 +00:00
wgs->last_beep_time = GetTickCount();
Bell can now play an arbitrary sound file. [originally from svn r1041]
2001-04-14 11:37:47 +00:00
} else if (mode == BELL_WAVEFILE) {
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
Filename *bell_wavefile = conf_get_filename(
wgs->conf, CONF_bell_wavefile);
Some support for wide-character filenames in Windows. The Windows version of the Filename structure now contains three versions of the pathname, in UTF-16, UTF-8 and the system code page. Callers can use whichever is most convenient. All uses of filenames for actually opening files now use the UTF-16 version, which means they can tolerate 'exotic' filenames, by which I mean those including Unicode characters outside the host system's CP_ACP default code page. Other uses of Filename structures inside the 'windows' subdirectory do something appropriate, e.g. when printing a filename inside a message box or a console message, we use the UTF-8 version of the filename with the UTF-8 version of the appropriate API. There are three remaining pieces to full Unicode filename support: One is that the cross-platform code has many calls to filename_to_str(), embodying the assumption that a file name can be reliably converted into the unspecified current character set; those will all need changing in some way. Another is that write_setting_filename(), in windows/storage.c, still saves filenames to the Registry as an ordinary REG_SZ in the system code page. So even if an exotic filename were stored in a Conf, that Conf couldn't round-trip via the Registry and back without corrupting that filename by coercing it back to a string that fits in CP_ACP and therefore doesn't represent the same file. This can't be fixed without a compatibility break in the storage format, and I don't want to make a minimal change in that area: if we're going to break compatibility, then we should break it good and hard (the Nanny Ogg principle), and devise a completely fresh storage representation that fixes as many other legacy problems as possible at the same time. So that's my plan, not yet started. The final point, much more obviously, is that we're still short of methods to _construct_ any Filename structures using a Unicode input string! It should now work to enter one in the GUI configurer (either by manual text input or via the file selector), but it won't round-trip through a save and load (as discussed above), and there's still no way to specify one on the command line (the groundwork is laid by commit 10e1ac7752de928 but not yet linked up). But this is a start.
2023-05-28 10:30:59 +00:00
bool success = (
p_PlaySoundW ? p_PlaySoundW(bell_wavefile->wpath, NULL,
SND_ASYNC | SND_FILENAME) :
p_PlaySoundA ? p_PlaySoundA(bell_wavefile->cpath, NULL,
SND_ASYNC | SND_FILENAME) : false);
if (!success) {
Remove a load of obsolete printf string limits. In the previous commit I happened to notice a %.150s in a ppl_logevent call, which was probably an important safety precaution a couple of decades ago when that format string was being used for an sprintf into a fixed-size buffer, but now it's just pointless cruft. This commit removes all printf string formatting directives with a compile-time fixed size, with the one exception of a %.3s used to cut out a 3-letter month name in scpserver.c. In cases where the format string in question was already going to an arbitrary-length function like dupprintf or ppl_logevent, that's all I've done; in cases where there was still a fixed-size buffer, I've replaced it with a dynamic buffer and dupprintf.
2018-12-08 21:03:51 +00:00
char *buf, *otherbuf;
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
show_mouseptr(wgs, true);
Remove a load of obsolete printf string limits. In the previous commit I happened to notice a %.150s in a ppl_logevent call, which was probably an important safety precaution a couple of decades ago when that format string was being used for an sprintf into a fixed-size buffer, but now it's just pointless cruft. This commit removes all printf string formatting directives with a compile-time fixed size, with the one exception of a %.3s used to cut out a 3-letter month name in scpserver.c. In cases where the format string in question was already going to an arbitrary-length function like dupprintf or ppl_logevent, that's all I've done; in cases where there was still a fixed-size buffer, I've replaced it with a dynamic buffer and dupprintf.
2018-12-08 21:03:51 +00:00
buf = dupprintf(
"Unable to play sound file\n%s\nUsing default sound instead",
Some support for wide-character filenames in Windows. The Windows version of the Filename structure now contains three versions of the pathname, in UTF-16, UTF-8 and the system code page. Callers can use whichever is most convenient. All uses of filenames for actually opening files now use the UTF-16 version, which means they can tolerate 'exotic' filenames, by which I mean those including Unicode characters outside the host system's CP_ACP default code page. Other uses of Filename structures inside the 'windows' subdirectory do something appropriate, e.g. when printing a filename inside a message box or a console message, we use the UTF-8 version of the filename with the UTF-8 version of the appropriate API. There are three remaining pieces to full Unicode filename support: One is that the cross-platform code has many calls to filename_to_str(), embodying the assumption that a file name can be reliably converted into the unspecified current character set; those will all need changing in some way. Another is that write_setting_filename(), in windows/storage.c, still saves filenames to the Registry as an ordinary REG_SZ in the system code page. So even if an exotic filename were stored in a Conf, that Conf couldn't round-trip via the Registry and back without corrupting that filename by coercing it back to a string that fits in CP_ACP and therefore doesn't represent the same file. This can't be fixed without a compatibility break in the storage format, and I don't want to make a minimal change in that area: if we're going to break compatibility, then we should break it good and hard (the Nanny Ogg principle), and devise a completely fresh storage representation that fixes as many other legacy problems as possible at the same time. So that's my plan, not yet started. The final point, much more obviously, is that we're still short of methods to _construct_ any Filename structures using a Unicode input string! It should now work to enter one in the GUI configurer (either by manual text input or via the file selector), but it won't round-trip through a save and load (as discussed above), and there's still no way to specify one on the command line (the groundwork is laid by commit 10e1ac7752de928 but not yet linked up). But this is a start.
2023-05-28 10:30:59 +00:00
bell_wavefile->utf8path);
Remove a load of obsolete printf string limits. In the previous commit I happened to notice a %.150s in a ppl_logevent call, which was probably an important safety precaution a couple of decades ago when that format string was being used for an sprintf into a fixed-size buffer, but now it's just pointless cruft. This commit removes all printf string formatting directives with a compile-time fixed size, with the one exception of a %.3s used to cut out a 3-letter month name in scpserver.c. In cases where the format string in question was already going to an arbitrary-length function like dupprintf or ppl_logevent, that's all I've done; in cases where there was still a fixed-size buffer, I've replaced it with a dynamic buffer and dupprintf.
2018-12-08 21:03:51 +00:00
otherbuf = dupprintf("%s Sound Error", appname);
Some support for wide-character filenames in Windows. The Windows version of the Filename structure now contains three versions of the pathname, in UTF-16, UTF-8 and the system code page. Callers can use whichever is most convenient. All uses of filenames for actually opening files now use the UTF-16 version, which means they can tolerate 'exotic' filenames, by which I mean those including Unicode characters outside the host system's CP_ACP default code page. Other uses of Filename structures inside the 'windows' subdirectory do something appropriate, e.g. when printing a filename inside a message box or a console message, we use the UTF-8 version of the filename with the UTF-8 version of the appropriate API. There are three remaining pieces to full Unicode filename support: One is that the cross-platform code has many calls to filename_to_str(), embodying the assumption that a file name can be reliably converted into the unspecified current character set; those will all need changing in some way. Another is that write_setting_filename(), in windows/storage.c, still saves filenames to the Registry as an ordinary REG_SZ in the system code page. So even if an exotic filename were stored in a Conf, that Conf couldn't round-trip via the Registry and back without corrupting that filename by coercing it back to a string that fits in CP_ACP and therefore doesn't represent the same file. This can't be fixed without a compatibility break in the storage format, and I don't want to make a minimal change in that area: if we're going to break compatibility, then we should break it good and hard (the Nanny Ogg principle), and devise a completely fresh storage representation that fixes as many other legacy problems as possible at the same time. So that's my plan, not yet started. The final point, much more obviously, is that we're still short of methods to _construct_ any Filename structures using a Unicode input string! It should now work to enter one in the GUI configurer (either by manual text input or via the file selector), but it won't round-trip through a save and load (as discussed above), and there's still no way to specify one on the command line (the groundwork is laid by commit 10e1ac7752de928 but not yet linked up). But this is a start.
2023-05-28 10:30:59 +00:00
message_box(wgs->term_hwnd, buf, otherbuf,
MB_OK | MB_ICONEXCLAMATION, true, 0);
Remove a load of obsolete printf string limits. In the previous commit I happened to notice a %.150s in a ppl_logevent call, which was probably an important safety precaution a couple of decades ago when that format string was being used for an sprintf into a fixed-size buffer, but now it's just pointless cruft. This commit removes all printf string formatting directives with a compile-time fixed size, with the one exception of a %.3s used to cut out a 3-letter month name in scpserver.c. In cases where the format string in question was already going to an arbitrary-length function like dupprintf or ppl_logevent, that's all I've done; in cases where there was still a fixed-size buffer, I've replaced it with a dynamic buffer and dupprintf.
2018-12-08 21:03:51 +00:00
sfree(buf);
sfree(otherbuf);
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
conf_set_int(wgs->conf, CONF_beep, BELL_DEFAULT);
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
}
Modified form of Jim Lucas's PC speaker patch. I don't like discriminating on the Windows version in order to decide whether to call MessageBeep(-1) or Beep() - I'd prefer to directly test the specific OS property in any given case - but it looks as if this is the best available option. [originally from svn r3208]
2003-05-24 12:31:32 +00:00
} else if (mode == BELL_PCSPEAKER) {
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
long beepdiff;
windows/window.c: move more variables into WinGuiSeat. In commit f9e572595bb8cb6 I claimed that I'd removed very nearly all the global and static variables from windows/window.c. It turns out that this was wildly overoptimistic - I missed quite a few of them! I'm not quite sure how I managed that; my best guess is that I used an underpowered 'nm' command that failed to find some classes of variable. Some of the remaining function-scope statics were removed completely by commit afb3dab1e97a09f just now. In this commit, I've swept up some more and turn them into fields of WinGuiSeat, where they should have been moved last September. The (hopefully complete this time) list of remaining variables, generated by running this rune in the Windows build directory: nm windows/CMakeFiles/putty.dir/window.c.obj | grep -E '^([^ ]+)? *[bBcCdDgGsS] [^\.]' consists of the following variables which are legitimately global across the whole process and not related to a particular window: - 'hinst' and 'hprev', instance handles for Windows loadable modules - 'classname' in the terminal_window_class_a() and terminal_window_class_w() functions, which allocate a window class reusably - some pointers to Windows API functions retrieved via the DECL_WINDOWS_FUNCTION / GET_WINDOWS_FUNCTION system, such as p_AdjustWindowRectExForDpi and p_FlashWindowEx - some pointers to Windows API functions set up by assigning them at startup to the right one of the ANSI or Unicode version depending on the Windows version, e.g. sw_DefWindowProc and sw_DispatchMessage - 'unicode_window', a boolean flag set at the same time as those sw_Foo function pointers - 'sesslist', storing the last-retrieved version of the saved sessions menu - 'cursor_visible' in show_mouseptr() and 'forced_visible' in update_mouse_pointer(), each of which tracks the cumulative number of times that function has shown or hidden the mouse pointer, so as to manage its effect on the global state updated by ShowCursor - 'trust_icon', loaded from the executable's resources - 'wgslisthead', the list of all active WinGuiSeats - 'wm_mousewheel', the window-message id we use for mouse wheel events and the following which are nothing to do with our code: - '_OptionsStorage' in __local_stdio_printf_options() and __local_stdio_scanf_options(), which I'd never noticed before, but apparently are internal to a standard library header.
2023-05-27 13:59:20 +00:00
beepdiff = GetTickCount() - wgs->last_beep_time;
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
if (beepdiff >= 0 && beepdiff < 50)
return;
/*
* We must beep in different ways depending on whether this
* is a 95-series or NT-series OS.
*/
if (osPlatformId == VER_PLATFORM_WIN32_NT)
Beep(800, 100);
else
MessageBeep(-1);
windows/window.c: move more variables into WinGuiSeat. In commit f9e572595bb8cb6 I claimed that I'd removed very nearly all the global and static variables from windows/window.c. It turns out that this was wildly overoptimistic - I missed quite a few of them! I'm not quite sure how I managed that; my best guess is that I used an underpowered 'nm' command that failed to find some classes of variable. Some of the remaining function-scope statics were removed completely by commit afb3dab1e97a09f just now. In this commit, I've swept up some more and turn them into fields of WinGuiSeat, where they should have been moved last September. The (hopefully complete this time) list of remaining variables, generated by running this rune in the Windows build directory: nm windows/CMakeFiles/putty.dir/window.c.obj | grep -E '^([^ ]+)? *[bBcCdDgGsS] [^\.]' consists of the following variables which are legitimately global across the whole process and not related to a particular window: - 'hinst' and 'hprev', instance handles for Windows loadable modules - 'classname' in the terminal_window_class_a() and terminal_window_class_w() functions, which allocate a window class reusably - some pointers to Windows API functions retrieved via the DECL_WINDOWS_FUNCTION / GET_WINDOWS_FUNCTION system, such as p_AdjustWindowRectExForDpi and p_FlashWindowEx - some pointers to Windows API functions set up by assigning them at startup to the right one of the ANSI or Unicode version depending on the Windows version, e.g. sw_DefWindowProc and sw_DispatchMessage - 'unicode_window', a boolean flag set at the same time as those sw_Foo function pointers - 'sesslist', storing the last-retrieved version of the saved sessions menu - 'cursor_visible' in show_mouseptr() and 'forced_visible' in update_mouse_pointer(), each of which tracks the cumulative number of times that function has shown or hidden the mouse pointer, so as to manage its effect on the global state updated by ShowCursor - 'trust_icon', loaded from the executable's resources - 'wgslisthead', the list of all active WinGuiSeats - 'wm_mousewheel', the window-message id we use for mouse wheel events and the following which are nothing to do with our code: - '_OptionsStorage' in __local_stdio_printf_options() and __local_stdio_scanf_options(), which I'd never noticed before, but apparently are internal to a standard library header.
2023-05-27 13:59:20 +00:00
wgs->last_beep_time = GetTickCount();
Bell can now play an arbitrary sound file. [originally from svn r1041]
2001-04-14 11:37:47 +00:00
}
Glenn Maynard's patch (as adapted by Jacob) for taskbar flashing when a bell occurs and the window is minimised. [originally from svn r1123]
2001-05-13 14:42:17 +00:00
/* Otherwise, either visual bell or disabled; do nothing here */
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
if (!wgs->term->has_focus) {
flash_window(wgs, 2); /* start */
Glenn Maynard's patch (as adapted by Jacob) for taskbar flashing when a bell occurs and the window is minimised. [originally from svn r1123]
2001-05-13 14:42:17 +00:00
}
Initial checkin: beta 0.43 [originally from svn r11]
1999-01-08 13:02:13 +00:00
}
Christopher Allene's patch for going full-screen on Alt-Enter. [originally from svn r1267]
2001-09-13 18:24:51 +00:00
Add support for most of the ESC[<low number>t sequences, which xterm uses to manipulate the window (minimise, maximise, front, back, move, resize) and report things about the window (is it minimised or maximised, how big is it, what's its title). Missing are ESC[4;X;Yt (resize to a specified pixel size; our resize code doesn't like it) and ESC[19;X;Yt (report size of _screen_ in _characters_, which it isn't even obvious how to do when you've got a variable font size). [originally from svn r1414]
2001-11-25 15:21:25 +00:00
/*
* Minimise or restore the window in response to a server-side
* request.
*/
Convert a lot of 'int' variables to 'bool'. My normal habit these days, in new code, is to treat int and bool as _almost_ completely separate types. I'm still willing to use C's implicit test for zero on an integer (e.g. 'if (!blob.len)' is fine, no need to spell it out as blob.len != 0), but generally, if a variable is going to be conceptually a boolean, I like to declare it bool and assign to it using 'true' or 'false' rather than 0 or 1. PuTTY is an exception, because it predates the C99 bool, and I've stuck to its existing coding style even when adding new code to it. But it's been annoying me more and more, so now that I've decided C99 bool is an acceptable thing to require from our toolchain in the first place, here's a quite thorough trawl through the source doing 'boolification'. Many variables and function parameters are now typed as bool rather than int; many assignments of 0 or 1 to those variables are now spelled 'true' or 'false'. I managed this thorough conversion with the help of a custom clang plugin that I wrote to trawl the AST and apply heuristics to point out where things might want changing. So I've even managed to do a decent job on parts of the code I haven't looked at in years! To make the plugin's work easier, I pushed platform front ends generally in the direction of using standard 'bool' in preference to platform-specific boolean types like Windows BOOL or GTK's gboolean; I've left the platform booleans in places they _have_ to be for the platform APIs to work right, but variables only used by my own code have been converted wherever I found them. In a few places there are int values that look very like booleans in _most_ of the places they're used, but have a rarely-used third value, or a distinction between different nonzero values that most users don't care about. In these cases, I've _removed_ uses of 'true' and 'false' for the return values, to emphasise that there's something more subtle going on than a simple boolean answer: - the 'multisel' field in dialog.h's list box structure, for which the GTK front end in particular recognises a difference between 1 and 2 but nearly everything else treats as boolean - the 'urgent' parameter to plug_receive, where 1 vs 2 tells you something about the specific location of the urgent pointer, but most clients only care about 0 vs 'something nonzero' - the return value of wc_match, where -1 indicates a syntax error in the wildcard. - the return values from SSH-1 RSA-key loading functions, which use -1 for 'wrong passphrase' and 0 for all other failures (so any caller which already knows it's not loading an _encrypted private_ key can treat them as boolean) - term->esc_query, and the 'query' parameter in toggle_mode in terminal.c, which _usually_ hold 0 for ESC[123h or 1 for ESC[?123h, but can also hold -1 for some other intervening character that we don't support. In a few places there's an integer that I haven't turned into a bool even though it really _can_ only take values 0 or 1 (and, as above, tried to make the call sites consistent in not calling those values true and false), on the grounds that I thought it would make it more confusing to imply that the 0 value was in some sense 'negative' or bad and the 1 positive or good: - the return value of plug_accepting uses the POSIXish convention of 0=success and nonzero=error; I think if I made it bool then I'd also want to reverse its sense, and that's a job for a separate piece of work. - the 'screen' parameter to lineptr() in terminal.c, where 0 and 1 represent the default and alternate screens. There's no obvious reason why one of those should be considered 'true' or 'positive' or 'success' - they're just indices - so I've left it as int. ssh_scp_recv had particularly confusing semantics for its previous int return value: its call sites used '<= 0' to check for error, but it never actually returned a negative number, just 0 or 1. Now the function and its call sites agree that it's a bool. In a couple of places I've renamed variables called 'ret', because I don't like that name any more - it's unclear whether it means the return value (in preparation) for the _containing_ function or the return value received from a subroutine call, and occasionally I've accidentally used the same variable for both and introduced a bug. So where one of those got in my way, I've renamed it to 'toret' or 'retd' (the latter short for 'returned') in line with my usual modern practice, but I haven't done a thorough job of finding all of them. Finally, one amusing side effect of doing this is that I've had to separate quite a few chained assignments. It used to be perfectly fine to write 'a = b = c = TRUE' when a,b,c were int and TRUE was just a the 'true' defined by stdbool.h, that idiom provokes a warning from gcc: 'suggest parentheses around assignment used as truth value'!
2018-11-02 19:23:19 +00:00
static void wintw_set_minimised(TermWin *tw, bool minimised)
Add support for most of the ESC[<low number>t sequences, which xterm uses to manipulate the window (minimise, maximise, front, back, move, resize) and report things about the window (is it minimised or maximised, how big is it, what's its title). Missing are ESC[4;X;Yt (resize to a specified pixel size; our resize code doesn't like it) and ESC[19;X;Yt (report size of _screen_ in _characters_, which it isn't even obvious how to do when you've got a variable font size). [originally from svn r1414]
2001-11-25 15:21:25 +00:00
{
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
WinGuiSeat *wgs = container_of(tw, WinGuiSeat, termwin);
if (IsIconic(wgs->term_hwnd)) {
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
if (!minimised)
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
ShowWindow(wgs->term_hwnd, SW_RESTORE);
Add support for most of the ESC[<low number>t sequences, which xterm uses to manipulate the window (minimise, maximise, front, back, move, resize) and report things about the window (is it minimised or maximised, how big is it, what's its title). Missing are ESC[4;X;Yt (resize to a specified pixel size; our resize code doesn't like it) and ESC[19;X;Yt (report size of _screen_ in _characters_, which it isn't even obvious how to do when you've got a variable font size). [originally from svn r1414]
2001-11-25 15:21:25 +00:00
} else {
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
if (minimised)
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
ShowWindow(wgs->term_hwnd, SW_MINIMIZE);
Add support for most of the ESC[<low number>t sequences, which xterm uses to manipulate the window (minimise, maximise, front, back, move, resize) and report things about the window (is it minimised or maximised, how big is it, what's its title). Missing are ESC[4;X;Yt (resize to a specified pixel size; our resize code doesn't like it) and ESC[19;X;Yt (report size of _screen_ in _characters_, which it isn't even obvious how to do when you've got a variable font size). [originally from svn r1414]
2001-11-25 15:21:25 +00:00
}
}
/*
* Move the window in response to a server-side request.
*/
Remove the 'Frontend' type and replace it with a vtable. After the recent Seat and LogContext revamps, _nearly_ all the remaining uses of the type 'Frontend' were in terminal.c, which needs all sorts of interactions with the GUI window the terminal lives in, from the obvious (actually drawing text on the window, reading and writing the clipboard) to the obscure (minimising, maximising and moving the window in response to particular escape sequences). All of those functions are now provided by an abstraction called TermWin. The few remaining uses of Frontend after _that_ are internal to a particular platform directory, so as to spread the implementation of that particular kind of Frontend between multiple source files; so I've renamed all of those so that they take a more specifically named type that refers to the particular implementation rather than the general abstraction. So now the name 'Frontend' no longer exists in the code base at all, and everywhere one used to be used, it's completely clear whether it was operating in one of Frontend's three abstract roles (and if so, which), or whether it was specific to a particular implementation. Another type that's disappeared is 'Context', which used to be a typedef defined to something different on each platform, describing whatever short-lived resources were necessary to draw on the terminal window: the front end would provide a ready-made one when calling term_paint, and the terminal could request one with get_ctx/free_ctx if it wanted to do proactive window updates. Now that drawing context lives inside the TermWin itself, because there was never any need to have two of those contexts live at the same time. (Another minor API change is that the window-title functions - both reading and writing - have had a missing 'const' added to their char * parameters / return values.) I don't expect this change to enable any particularly interesting new functionality (in particular, I have no plans that need more than one implementation of TermWin in the same application). But it completes the tidying-up that began with the Seat and LogContext rework.
2018-10-25 17:44:04 +00:00
static void wintw_move(TermWin *tw, int x, int y)
Add support for most of the ESC[<low number>t sequences, which xterm uses to manipulate the window (minimise, maximise, front, back, move, resize) and report things about the window (is it minimised or maximised, how big is it, what's its title). Missing are ESC[4;X;Yt (resize to a specified pixel size; our resize code doesn't like it) and ESC[19;X;Yt (report size of _screen_ in _characters_, which it isn't even obvious how to do when you've got a variable font size). [originally from svn r1414]
2001-11-25 15:21:25 +00:00
{
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
WinGuiSeat *wgs = container_of(tw, WinGuiSeat, termwin);
int resize_action = conf_get_int(wgs->conf, CONF_resize_action);
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
if (resize_action == RESIZE_DISABLED ||
resize_action == RESIZE_FONT ||
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
IsZoomed(wgs->term_hwnd))
Formatting: normalise back to 4-space indentation. In several pieces of development recently I've run across the occasional code block in the middle of a function which suddenly switched to 2-space indent from this code base's usual 4. I decided I was tired of it, so I ran the whole code base through a re-indenter, which made a huge mess, and then manually sifted out the changes that actually made sense from that pass. Indeed, this caught quite a few large sections with 2-space indent level, a couple with 8, and a handful of even weirder things like 3 spaces or 12. This commit fixes them all.
2022-08-03 19:48:46 +00:00
return;
Patch from RDB: the xterm move-window sequences now don't screw up when the window is e.g. maximised. [originally from svn r1533]
2002-01-08 09:56:06 +00:00
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
SetWindowPos(wgs->term_hwnd, NULL, x, y, 0, 0, SWP_NOSIZE | SWP_NOZORDER);
Add support for most of the ESC[<low number>t sequences, which xterm uses to manipulate the window (minimise, maximise, front, back, move, resize) and report things about the window (is it minimised or maximised, how big is it, what's its title). Missing are ESC[4;X;Yt (resize to a specified pixel size; our resize code doesn't like it) and ESC[19;X;Yt (report size of _screen_ in _characters_, which it isn't even obvious how to do when you've got a variable font size). [originally from svn r1414]
2001-11-25 15:21:25 +00:00
}
/*
* Move the window to the top or bottom of the z-order in response
* to a server-side request.
*/
Convert a lot of 'int' variables to 'bool'. My normal habit these days, in new code, is to treat int and bool as _almost_ completely separate types. I'm still willing to use C's implicit test for zero on an integer (e.g. 'if (!blob.len)' is fine, no need to spell it out as blob.len != 0), but generally, if a variable is going to be conceptually a boolean, I like to declare it bool and assign to it using 'true' or 'false' rather than 0 or 1. PuTTY is an exception, because it predates the C99 bool, and I've stuck to its existing coding style even when adding new code to it. But it's been annoying me more and more, so now that I've decided C99 bool is an acceptable thing to require from our toolchain in the first place, here's a quite thorough trawl through the source doing 'boolification'. Many variables and function parameters are now typed as bool rather than int; many assignments of 0 or 1 to those variables are now spelled 'true' or 'false'. I managed this thorough conversion with the help of a custom clang plugin that I wrote to trawl the AST and apply heuristics to point out where things might want changing. So I've even managed to do a decent job on parts of the code I haven't looked at in years! To make the plugin's work easier, I pushed platform front ends generally in the direction of using standard 'bool' in preference to platform-specific boolean types like Windows BOOL or GTK's gboolean; I've left the platform booleans in places they _have_ to be for the platform APIs to work right, but variables only used by my own code have been converted wherever I found them. In a few places there are int values that look very like booleans in _most_ of the places they're used, but have a rarely-used third value, or a distinction between different nonzero values that most users don't care about. In these cases, I've _removed_ uses of 'true' and 'false' for the return values, to emphasise that there's something more subtle going on than a simple boolean answer: - the 'multisel' field in dialog.h's list box structure, for which the GTK front end in particular recognises a difference between 1 and 2 but nearly everything else treats as boolean - the 'urgent' parameter to plug_receive, where 1 vs 2 tells you something about the specific location of the urgent pointer, but most clients only care about 0 vs 'something nonzero' - the return value of wc_match, where -1 indicates a syntax error in the wildcard. - the return values from SSH-1 RSA-key loading functions, which use -1 for 'wrong passphrase' and 0 for all other failures (so any caller which already knows it's not loading an _encrypted private_ key can treat them as boolean) - term->esc_query, and the 'query' parameter in toggle_mode in terminal.c, which _usually_ hold 0 for ESC[123h or 1 for ESC[?123h, but can also hold -1 for some other intervening character that we don't support. In a few places there's an integer that I haven't turned into a bool even though it really _can_ only take values 0 or 1 (and, as above, tried to make the call sites consistent in not calling those values true and false), on the grounds that I thought it would make it more confusing to imply that the 0 value was in some sense 'negative' or bad and the 1 positive or good: - the return value of plug_accepting uses the POSIXish convention of 0=success and nonzero=error; I think if I made it bool then I'd also want to reverse its sense, and that's a job for a separate piece of work. - the 'screen' parameter to lineptr() in terminal.c, where 0 and 1 represent the default and alternate screens. There's no obvious reason why one of those should be considered 'true' or 'positive' or 'success' - they're just indices - so I've left it as int. ssh_scp_recv had particularly confusing semantics for its previous int return value: its call sites used '<= 0' to check for error, but it never actually returned a negative number, just 0 or 1. Now the function and its call sites agree that it's a bool. In a couple of places I've renamed variables called 'ret', because I don't like that name any more - it's unclear whether it means the return value (in preparation) for the _containing_ function or the return value received from a subroutine call, and occasionally I've accidentally used the same variable for both and introduced a bug. So where one of those got in my way, I've renamed it to 'toret' or 'retd' (the latter short for 'returned') in line with my usual modern practice, but I haven't done a thorough job of finding all of them. Finally, one amusing side effect of doing this is that I've had to separate quite a few chained assignments. It used to be perfectly fine to write 'a = b = c = TRUE' when a,b,c were int and TRUE was just a the 'true' defined by stdbool.h, that idiom provokes a warning from gcc: 'suggest parentheses around assignment used as truth value'!
2018-11-02 19:23:19 +00:00
static void wintw_set_zorder(TermWin *tw, bool top)
Add support for most of the ESC[<low number>t sequences, which xterm uses to manipulate the window (minimise, maximise, front, back, move, resize) and report things about the window (is it minimised or maximised, how big is it, what's its title). Missing are ESC[4;X;Yt (resize to a specified pixel size; our resize code doesn't like it) and ESC[19;X;Yt (report size of _screen_ in _characters_, which it isn't even obvious how to do when you've got a variable font size). [originally from svn r1414]
2001-11-25 15:21:25 +00:00
{
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
WinGuiSeat *wgs = container_of(tw, WinGuiSeat, termwin);
if (conf_get_bool(wgs->conf, CONF_alwaysontop))
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
return; /* ignore */
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
SetWindowPos(wgs->term_hwnd, top ? HWND_TOP : HWND_BOTTOM, 0, 0, 0, 0,
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
SWP_NOMOVE | SWP_NOSIZE);
Add support for most of the ESC[<low number>t sequences, which xterm uses to manipulate the window (minimise, maximise, front, back, move, resize) and report things about the window (is it minimised or maximised, how big is it, what's its title). Missing are ESC[4;X;Yt (resize to a specified pixel size; our resize code doesn't like it) and ESC[19;X;Yt (report size of _screen_ in _characters_, which it isn't even obvious how to do when you've got a variable font size). [originally from svn r1414]
2001-11-25 15:21:25 +00:00
}
/*
* Refresh the window in response to a server-side request.
*/
Remove the 'Frontend' type and replace it with a vtable. After the recent Seat and LogContext revamps, _nearly_ all the remaining uses of the type 'Frontend' were in terminal.c, which needs all sorts of interactions with the GUI window the terminal lives in, from the obvious (actually drawing text on the window, reading and writing the clipboard) to the obscure (minimising, maximising and moving the window in response to particular escape sequences). All of those functions are now provided by an abstraction called TermWin. The few remaining uses of Frontend after _that_ are internal to a particular platform directory, so as to spread the implementation of that particular kind of Frontend between multiple source files; so I've renamed all of those so that they take a more specifically named type that refers to the particular implementation rather than the general abstraction. So now the name 'Frontend' no longer exists in the code base at all, and everywhere one used to be used, it's completely clear whether it was operating in one of Frontend's three abstract roles (and if so, which), or whether it was specific to a particular implementation. Another type that's disappeared is 'Context', which used to be a typedef defined to something different on each platform, describing whatever short-lived resources were necessary to draw on the terminal window: the front end would provide a ready-made one when calling term_paint, and the terminal could request one with get_ctx/free_ctx if it wanted to do proactive window updates. Now that drawing context lives inside the TermWin itself, because there was never any need to have two of those contexts live at the same time. (Another minor API change is that the window-title functions - both reading and writing - have had a missing 'const' added to their char * parameters / return values.) I don't expect this change to enable any particularly interesting new functionality (in particular, I have no plans that need more than one implementation of TermWin in the same application). But it completes the tidying-up that began with the Seat and LogContext rework.
2018-10-25 17:44:04 +00:00
static void wintw_refresh(TermWin *tw)
Add support for most of the ESC[<low number>t sequences, which xterm uses to manipulate the window (minimise, maximise, front, back, move, resize) and report things about the window (is it minimised or maximised, how big is it, what's its title). Missing are ESC[4;X;Yt (resize to a specified pixel size; our resize code doesn't like it) and ESC[19;X;Yt (report size of _screen_ in _characters_, which it isn't even obvious how to do when you've got a variable font size). [originally from svn r1414]
2001-11-25 15:21:25 +00:00
{
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
WinGuiSeat *wgs = container_of(tw, WinGuiSeat, termwin);
InvalidateRect(wgs->term_hwnd, NULL, true);
Add support for most of the ESC[<low number>t sequences, which xterm uses to manipulate the window (minimise, maximise, front, back, move, resize) and report things about the window (is it minimised or maximised, how big is it, what's its title). Missing are ESC[4;X;Yt (resize to a specified pixel size; our resize code doesn't like it) and ESC[19;X;Yt (report size of _screen_ in _characters_, which it isn't even obvious how to do when you've got a variable font size). [originally from svn r1414]
2001-11-25 15:21:25 +00:00
}
/*
* Maximise or restore the window in response to a server-side
* request.
*/
Convert a lot of 'int' variables to 'bool'. My normal habit these days, in new code, is to treat int and bool as _almost_ completely separate types. I'm still willing to use C's implicit test for zero on an integer (e.g. 'if (!blob.len)' is fine, no need to spell it out as blob.len != 0), but generally, if a variable is going to be conceptually a boolean, I like to declare it bool and assign to it using 'true' or 'false' rather than 0 or 1. PuTTY is an exception, because it predates the C99 bool, and I've stuck to its existing coding style even when adding new code to it. But it's been annoying me more and more, so now that I've decided C99 bool is an acceptable thing to require from our toolchain in the first place, here's a quite thorough trawl through the source doing 'boolification'. Many variables and function parameters are now typed as bool rather than int; many assignments of 0 or 1 to those variables are now spelled 'true' or 'false'. I managed this thorough conversion with the help of a custom clang plugin that I wrote to trawl the AST and apply heuristics to point out where things might want changing. So I've even managed to do a decent job on parts of the code I haven't looked at in years! To make the plugin's work easier, I pushed platform front ends generally in the direction of using standard 'bool' in preference to platform-specific boolean types like Windows BOOL or GTK's gboolean; I've left the platform booleans in places they _have_ to be for the platform APIs to work right, but variables only used by my own code have been converted wherever I found them. In a few places there are int values that look very like booleans in _most_ of the places they're used, but have a rarely-used third value, or a distinction between different nonzero values that most users don't care about. In these cases, I've _removed_ uses of 'true' and 'false' for the return values, to emphasise that there's something more subtle going on than a simple boolean answer: - the 'multisel' field in dialog.h's list box structure, for which the GTK front end in particular recognises a difference between 1 and 2 but nearly everything else treats as boolean - the 'urgent' parameter to plug_receive, where 1 vs 2 tells you something about the specific location of the urgent pointer, but most clients only care about 0 vs 'something nonzero' - the return value of wc_match, where -1 indicates a syntax error in the wildcard. - the return values from SSH-1 RSA-key loading functions, which use -1 for 'wrong passphrase' and 0 for all other failures (so any caller which already knows it's not loading an _encrypted private_ key can treat them as boolean) - term->esc_query, and the 'query' parameter in toggle_mode in terminal.c, which _usually_ hold 0 for ESC[123h or 1 for ESC[?123h, but can also hold -1 for some other intervening character that we don't support. In a few places there's an integer that I haven't turned into a bool even though it really _can_ only take values 0 or 1 (and, as above, tried to make the call sites consistent in not calling those values true and false), on the grounds that I thought it would make it more confusing to imply that the 0 value was in some sense 'negative' or bad and the 1 positive or good: - the return value of plug_accepting uses the POSIXish convention of 0=success and nonzero=error; I think if I made it bool then I'd also want to reverse its sense, and that's a job for a separate piece of work. - the 'screen' parameter to lineptr() in terminal.c, where 0 and 1 represent the default and alternate screens. There's no obvious reason why one of those should be considered 'true' or 'positive' or 'success' - they're just indices - so I've left it as int. ssh_scp_recv had particularly confusing semantics for its previous int return value: its call sites used '<= 0' to check for error, but it never actually returned a negative number, just 0 or 1. Now the function and its call sites agree that it's a bool. In a couple of places I've renamed variables called 'ret', because I don't like that name any more - it's unclear whether it means the return value (in preparation) for the _containing_ function or the return value received from a subroutine call, and occasionally I've accidentally used the same variable for both and introduced a bug. So where one of those got in my way, I've renamed it to 'toret' or 'retd' (the latter short for 'returned') in line with my usual modern practice, but I haven't done a thorough job of finding all of them. Finally, one amusing side effect of doing this is that I've had to separate quite a few chained assignments. It used to be perfectly fine to write 'a = b = c = TRUE' when a,b,c were int and TRUE was just a the 'true' defined by stdbool.h, that idiom provokes a warning from gcc: 'suggest parentheses around assignment used as truth value'!
2018-11-02 19:23:19 +00:00
static void wintw_set_maximised(TermWin *tw, bool maximised)
Add support for most of the ESC[<low number>t sequences, which xterm uses to manipulate the window (minimise, maximise, front, back, move, resize) and report things about the window (is it minimised or maximised, how big is it, what's its title). Missing are ESC[4;X;Yt (resize to a specified pixel size; our resize code doesn't like it) and ESC[19;X;Yt (report size of _screen_ in _characters_, which it isn't even obvious how to do when you've got a variable font size). [originally from svn r1414]
2001-11-25 15:21:25 +00:00
{
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
WinGuiSeat *wgs = container_of(tw, WinGuiSeat, termwin);
if (IsZoomed(wgs->term_hwnd)) {
Remove the 'Frontend' type and replace it with a vtable. After the recent Seat and LogContext revamps, _nearly_ all the remaining uses of the type 'Frontend' were in terminal.c, which needs all sorts of interactions with the GUI window the terminal lives in, from the obvious (actually drawing text on the window, reading and writing the clipboard) to the obscure (minimising, maximising and moving the window in response to particular escape sequences). All of those functions are now provided by an abstraction called TermWin. The few remaining uses of Frontend after _that_ are internal to a particular platform directory, so as to spread the implementation of that particular kind of Frontend between multiple source files; so I've renamed all of those so that they take a more specifically named type that refers to the particular implementation rather than the general abstraction. So now the name 'Frontend' no longer exists in the code base at all, and everywhere one used to be used, it's completely clear whether it was operating in one of Frontend's three abstract roles (and if so, which), or whether it was specific to a particular implementation. Another type that's disappeared is 'Context', which used to be a typedef defined to something different on each platform, describing whatever short-lived resources were necessary to draw on the terminal window: the front end would provide a ready-made one when calling term_paint, and the terminal could request one with get_ctx/free_ctx if it wanted to do proactive window updates. Now that drawing context lives inside the TermWin itself, because there was never any need to have two of those contexts live at the same time. (Another minor API change is that the window-title functions - both reading and writing - have had a missing 'const' added to their char * parameters / return values.) I don't expect this change to enable any particularly interesting new functionality (in particular, I have no plans that need more than one implementation of TermWin in the same application). But it completes the tidying-up that began with the Seat and LogContext rework.
2018-10-25 17:44:04 +00:00
if (!maximised)
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
ShowWindow(wgs->term_hwnd, SW_RESTORE);
Add support for most of the ESC[<low number>t sequences, which xterm uses to manipulate the window (minimise, maximise, front, back, move, resize) and report things about the window (is it minimised or maximised, how big is it, what's its title). Missing are ESC[4;X;Yt (resize to a specified pixel size; our resize code doesn't like it) and ESC[19;X;Yt (report size of _screen_ in _characters_, which it isn't even obvious how to do when you've got a variable font size). [originally from svn r1414]
2001-11-25 15:21:25 +00:00
} else {
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
if (maximised)
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
ShowWindow(wgs->term_hwnd, SW_MAXIMIZE);
Add support for most of the ESC[<low number>t sequences, which xterm uses to manipulate the window (minimise, maximise, front, back, move, resize) and report things about the window (is it minimised or maximised, how big is it, what's its title). Missing are ESC[4;X;Yt (resize to a specified pixel size; our resize code doesn't like it) and ESC[19;X;Yt (report size of _screen_ in _characters_, which it isn't even obvious how to do when you've got a variable font size). [originally from svn r1414]
2001-11-25 15:21:25 +00:00
}
}
FIFTH ATTEMPT at getting full-screen mode right. This new attempt (which I'll comment at some stage) should combine the believable semantics of RDB's fullscreen-by-maximise mode with the multi- monitor friendliness of Wez Furlong's approach while also working on Win98. If we're lucky. [originally from svn r1464]
2001-12-07 21:21:03 +00:00
/*
* See if we're in full-screen mode.
*/
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
static bool is_full_screen(WinGuiSeat *wgs)
FIFTH ATTEMPT at getting full-screen mode right. This new attempt (which I'll comment at some stage) should combine the believable semantics of RDB's fullscreen-by-maximise mode with the multi- monitor friendliness of Wez Furlong's approach while also working on Win98. If we're lucky. [originally from svn r1464]
2001-12-07 21:21:03 +00:00
{
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
if (!IsZoomed(wgs->term_hwnd))
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
return false;
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
if (GetWindowLongPtr(wgs->term_hwnd, GWL_STYLE) & WS_CAPTION)
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
return false;
Adopt C99 <stdbool.h>'s true/false. This commit includes <stdbool.h> from defs.h and deletes my traditional definitions of TRUE and FALSE, but other than that, it's a 100% mechanical search-and-replace transforming all uses of TRUE and FALSE into the C99-standardised lowercase spellings. No actual types are changed in this commit; that will come next. This is just getting the noise out of the way, so that subsequent commits can have a higher proportion of signal.
2018-10-29 19:50:29 +00:00
return true;
FIFTH ATTEMPT at getting full-screen mode right. This new attempt (which I'll comment at some stage) should combine the believable semantics of RDB's fullscreen-by-maximise mode with the multi- monitor friendliness of Wez Furlong's approach while also working on Win98. If we're lucky. [originally from svn r1464]
2001-12-07 21:21:03 +00:00
}
Ensure the whole window is visible at startup During startup, calculate the top/left position of the window so that the whole window is visible. Without this change, sometimes the window is clipped vertically and you can't see the bottom. Thanks to Bruno Kraychete da Costa for the original version of this patch; I've tweaked it slightly, but the basic strategy of adjusting the output of GetWindowRect against the monitor's working area is all his.
2024-10-16 07:00:32 +00:00
/* Get a MONITORINFO structure for the nearest available monitor, if the
* multimon API is available and returns success. Shared subroutine between
* get_fullscreen_rect() and get_workingarea_rect(). */
static bool get_monitor_info(WinGuiSeat *wgs, MONITORINFO *mi)
Fix multi-monitor / full-screen problems and clean up the code a little. Thanks to Wez Furlong for the patch. [originally from svn r1591]
2002-03-13 22:15:14 +00:00
{
Andy Hood points out that `#ifdef MONITOR_DEFAULTTONEAREST' would benefit from _also_ being conditional on NO_MULTIMON not being defined, to prevent the possibility of only half the multimon code being included. [originally from svn r3644]
2003-12-16 18:28:43 +00:00
#if defined(MONITOR_DEFAULTTONEAREST) && !defined(NO_MULTIMON)
Remove hard dependencies on multi-monitor functions. These are more functions that don't exist on all our supported legacy versions of Windows, so we need to follow the same policy as everywhere else, by trying to acquire them at run time and having a fallback if they aren't available.
2022-03-11 18:32:26 +00:00
if (p_GetMonitorInfoA && p_MonitorFromWindow) {
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
HMONITOR mon;
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
mon = p_MonitorFromWindow(wgs->term_hwnd, MONITOR_DEFAULTTONEAREST);
Ensure the whole window is visible at startup During startup, calculate the top/left position of the window so that the whole window is visible. Without this change, sometimes the window is clipped vertically and you can't see the bottom. Thanks to Bruno Kraychete da Costa for the original version of this patch; I've tweaked it slightly, but the basic strategy of adjusting the output of GetWindowRect against the monitor's working area is all his.
2024-10-16 07:00:32 +00:00
mi->cbSize = sizeof(*mi);
p_GetMonitorInfoA(mon, mi);
return true;
}
#endif
return false;
}
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
Ensure the whole window is visible at startup During startup, calculate the top/left position of the window so that the whole window is visible. Without this change, sometimes the window is clipped vertically and you can't see the bottom. Thanks to Bruno Kraychete da Costa for the original version of this patch; I've tweaked it slightly, but the basic strategy of adjusting the output of GetWindowRect against the monitor's working area is all his.
2024-10-16 07:00:32 +00:00
/* Get the rect/size of a full-screen window on the nearest available
* monitor in multimon systems; default to something sensible if only
* one monitor is present. */
static bool get_fullscreen_rect(WinGuiSeat *wgs, RECT *ss)
{
#if defined(MONITOR_DEFAULTTONEAREST) && !defined(NO_MULTIMON)
MONITORINFO mi;
if (get_monitor_info(wgs, &mi)) {
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
/* structure copy */
*ss = mi.rcMonitor;
return true;
Remove hard dependencies on multi-monitor functions. These are more functions that don't exist on all our supported legacy versions of Windows, so we need to follow the same policy as everywhere else, by trying to acquire them at run time and having a fallback if they aren't available.
2022-03-11 18:32:26 +00:00
}
#endif
Fix multi-monitor / full-screen problems and clean up the code a little. Thanks to Wez Furlong for the patch. [originally from svn r1591]
2002-03-13 22:15:14 +00:00
/* could also use code like this:
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
ss->left = ss->top = 0;
ss->right = GetSystemMetrics(SM_CXSCREEN);
ss->bottom = GetSystemMetrics(SM_CYSCREEN);
*/
Formatting: normalise back to 4-space indentation. In several pieces of development recently I've run across the occasional code block in the middle of a function which suddenly switched to 2-space indent from this code base's usual 4. I decided I was tired of it, so I ran the whole code base through a re-indenter, which made a huge mess, and then manually sifted out the changes that actually made sense from that pass. Indeed, this caught quite a few large sections with 2-space indent level, a couple with 8, and a handful of even weirder things like 3 spaces or 12. This commit fixes them all.
2022-08-03 19:48:46 +00:00
return GetClientRect(GetDesktopWindow(), ss);
Fix multi-monitor / full-screen problems and clean up the code a little. Thanks to Wez Furlong for the patch. [originally from svn r1591]
2002-03-13 22:15:14 +00:00
}
Ensure the whole window is visible at startup During startup, calculate the top/left position of the window so that the whole window is visible. Without this change, sometimes the window is clipped vertically and you can't see the bottom. Thanks to Bruno Kraychete da Costa for the original version of this patch; I've tweaked it slightly, but the basic strategy of adjusting the output of GetWindowRect against the monitor's working area is all his.
2024-10-16 07:00:32 +00:00
/* Similar to get_fullscreen_rect, but retrieves the working area of the
* monitor (minus the taskbar) instead of its full extent. */
static bool get_workingarea_rect(WinGuiSeat *wgs, RECT *ss)
{
#if defined(MONITOR_DEFAULTTONEAREST) && !defined(NO_MULTIMON)
MONITORINFO mi;
if (get_monitor_info(wgs, &mi)) {
/* structure copy */
*ss = mi.rcWork;
return true;
}
#endif
/* Fallback is the same as get_monitor_rect, which is good _enough_:
* if the window overlaps the taskbar, that's not too bad a failure. */
return GetClientRect(GetDesktopWindow(), ss);
}
FIFTH ATTEMPT at getting full-screen mode right. This new attempt (which I'll comment at some stage) should combine the believable semantics of RDB's fullscreen-by-maximise mode with the multi- monitor friendliness of Wez Furlong's approach while also working on Win98. If we're lucky. [originally from svn r1464]
2001-12-07 21:21:03 +00:00
/*
* Go full-screen. This should only be called when we are already
* maximised.
*/
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
static void make_full_screen(WinGuiSeat *wgs)
FIFTH ATTEMPT at getting full-screen mode right. This new attempt (which I'll comment at some stage) should combine the believable semantics of RDB's fullscreen-by-maximise mode with the multi- monitor friendliness of Wez Furlong's approach while also working on Win98. If we're lucky. [originally from svn r1464]
2001-12-07 21:21:03 +00:00
{
DWORD style;
Formatting: normalise back to 4-space indentation. In several pieces of development recently I've run across the occasional code block in the middle of a function which suddenly switched to 2-space indent from this code base's usual 4. I decided I was tired of it, so I ran the whole code base through a re-indenter, which made a huge mess, and then manually sifted out the changes that actually made sense from that pass. Indeed, this caught quite a few large sections with 2-space indent level, a couple with 8, and a handful of even weirder things like 3 spaces or 12. This commit fixes them all.
2022-08-03 19:48:46 +00:00
RECT ss;
FIFTH ATTEMPT at getting full-screen mode right. This new attempt (which I'll comment at some stage) should combine the believable semantics of RDB's fullscreen-by-maximise mode with the multi- monitor friendliness of Wez Furlong's approach while also working on Win98. If we're lucky. [originally from svn r1464]
2001-12-07 21:21:03 +00:00
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
assert(IsZoomed(wgs->term_hwnd));
FIFTH ATTEMPT at getting full-screen mode right. This new attempt (which I'll comment at some stage) should combine the believable semantics of RDB's fullscreen-by-maximise mode with the multi- monitor friendliness of Wez Furlong's approach while also working on Win98. If we're lucky. [originally from svn r1464]
2001-12-07 21:21:03 +00:00
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
if (is_full_screen(wgs))
Formatting: normalise back to 4-space indentation. In several pieces of development recently I've run across the occasional code block in the middle of a function which suddenly switched to 2-space indent from this code base's usual 4. I decided I was tired of it, so I ran the whole code base through a re-indenter, which made a huge mess, and then manually sifted out the changes that actually made sense from that pass. Indeed, this caught quite a few large sections with 2-space indent level, a couple with 8, and a handful of even weirder things like 3 spaces or 12. This commit fixes them all.
2022-08-03 19:48:46 +00:00
return;
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
FIFTH ATTEMPT at getting full-screen mode right. This new attempt (which I'll comment at some stage) should combine the believable semantics of RDB's fullscreen-by-maximise mode with the multi- monitor friendliness of Wez Furlong's approach while also working on Win98. If we're lucky. [originally from svn r1464]
2001-12-07 21:21:03 +00:00
/* Remove the window furniture. */
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
style = GetWindowLongPtr(wgs->term_hwnd, GWL_STYLE);
FIFTH ATTEMPT at getting full-screen mode right. This new attempt (which I'll comment at some stage) should combine the believable semantics of RDB's fullscreen-by-maximise mode with the multi- monitor friendliness of Wez Furlong's approach while also working on Win98. If we're lucky. [originally from svn r1464]
2001-12-07 21:21:03 +00:00
style &= ~(WS_CAPTION | WS_BORDER | WS_THICKFRAME);
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
if (conf_get_bool(wgs->conf, CONF_scrollbar_in_fullscreen))
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
style |= WS_VSCROLL;
FIFTH ATTEMPT at getting full-screen mode right. This new attempt (which I'll comment at some stage) should combine the believable semantics of RDB's fullscreen-by-maximise mode with the multi- monitor friendliness of Wez Furlong's approach while also working on Win98. If we're lucky. [originally from svn r1464]
2001-12-07 21:21:03 +00:00
else
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
style &= ~WS_VSCROLL;
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
SetWindowLongPtr(wgs->term_hwnd, GWL_STYLE, style);
FIFTH ATTEMPT at getting full-screen mode right. This new attempt (which I'll comment at some stage) should combine the believable semantics of RDB's fullscreen-by-maximise mode with the multi- monitor friendliness of Wez Furlong's approach while also working on Win98. If we're lucky. [originally from svn r1464]
2001-12-07 21:21:03 +00:00
/* Resize ourselves to exactly cover the nearest monitor. */
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
get_fullscreen_rect(wgs, &ss);
SetWindowPos(wgs->term_hwnd, HWND_TOP, ss.left, ss.top,
GUI PuTTY: stop using the global 'hwnd'. This was the difficult part of cleaning up that global variable. The main Windows PuTTY GUI is split between source files, so that _does_ actually need to refer to the main window from multiple places. But all the places where windlg.c needed to use 'hwnd' are seat methods, so they were already receiving a Seat pointer as a parameter. In other words, the methods of the Windows GUI Seat were already split between source files. So it seems only fair that they should be able to share knowledge of the seat's data as well. Hence, I've created a small 'WinGuiSeat' structure which both window.c and windlg.c can see the layout of, and put the main terminal window handle in there. Then the seat methods implemented in windlg.c, like win_seat_verify_ssh_host_key, can use container_of to turn the Seat pointer parameter back into the address of that structure, just as the methods in window.c can do (even though they currently don't need to). (Who knows: now that it _exists_, perhaps that structure can be gradually expanded in future to turn it into a proper encapsulation of all the Windows frontend's state, like we should have had all along...) I've also moved the Windows GUI LogPolicy implementation into the same object (i.e. WinGuiSeat implements both traits at once). That allows win_gui_logging_error to recover the same WinGuiSeat from its input LogPolicy pointer, which means it can get from there to the Seat facet of the same object, so that I don't need the extern variable 'win_seat' any more either.
2020-02-02 10:00:43 +00:00
ss.right - ss.left, ss.bottom - ss.top, SWP_FRAMECHANGED);
FIFTH ATTEMPT at getting full-screen mode right. This new attempt (which I'll comment at some stage) should combine the believable semantics of RDB's fullscreen-by-maximise mode with the multi- monitor friendliness of Wez Furlong's approach while also working on Win98. If we're lucky. [originally from svn r1464]
2001-12-07 21:21:03 +00:00
Update size when going from maximised to full screen. [originally from svn r6618]
2006-03-29 17:55:40 +00:00
/* We may have changed size as a result */
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
reset_window(wgs, 0);
Update size when going from maximised to full screen. [originally from svn r6618]
2006-03-29 17:55:40 +00:00
Keep the state of the "Full Screen" menu item on the Ctrl+right-click context menu in sync with reality and the system menu. [originally from svn r8620]
2009-08-15 17:45:17 +00:00
/* Tick the menu item in the System and context menus. */
{
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
int i;
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
for (i = 0; i < lenof(wgs->popup_menus); i++)
CheckMenuItem(wgs->popup_menus[i].menu,
IDM_FULLSCREEN, MF_CHECKED);
Keep the state of the "Full Screen" menu item on the Ctrl+right-click context menu in sync with reality and the system menu. [originally from svn r8620]
2009-08-15 17:45:17 +00:00
}
FIFTH ATTEMPT at getting full-screen mode right. This new attempt (which I'll comment at some stage) should combine the believable semantics of RDB's fullscreen-by-maximise mode with the multi- monitor friendliness of Wez Furlong's approach while also working on Win98. If we're lucky. [originally from svn r1464]
2001-12-07 21:21:03 +00:00
}
/*
* Clear the full-screen attributes.
*/
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
static void clear_full_screen(WinGuiSeat *wgs)
FIFTH ATTEMPT at getting full-screen mode right. This new attempt (which I'll comment at some stage) should combine the believable semantics of RDB's fullscreen-by-maximise mode with the multi- monitor friendliness of Wez Furlong's approach while also working on Win98. If we're lucky. [originally from svn r1464]
2001-12-07 21:21:03 +00:00
{
DWORD oldstyle, style;
/* Reinstate the window furniture. */
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
style = oldstyle = GetWindowLongPtr(wgs->term_hwnd, GWL_STYLE);
Fixes to full-screen mode. There were various problems when you went full-screen, then selected Change Settings and then changed the resize behaviour, ranging from the window staying FS but acquiring borders to the window restoring its previous size and _failing_ to acquire borders. Should now all be fixed. [originally from svn r1470]
2001-12-11 18:47:55 +00:00
style |= WS_CAPTION | WS_BORDER;
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
if (conf_get_int(wgs->conf, CONF_resize_action) == RESIZE_DISABLED)
Fixes to full-screen mode. There were various problems when you went full-screen, then selected Change Settings and then changed the resize behaviour, ranging from the window staying FS but acquiring borders to the window restoring its previous size and _failing_ to acquire borders. Should now all be fixed. [originally from svn r1470]
2001-12-11 18:47:55 +00:00
style &= ~WS_THICKFRAME;
else
style |= WS_THICKFRAME;
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
if (conf_get_bool(wgs->conf, CONF_scrollbar))
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
style |= WS_VSCROLL;
FIFTH ATTEMPT at getting full-screen mode right. This new attempt (which I'll comment at some stage) should combine the believable semantics of RDB's fullscreen-by-maximise mode with the multi- monitor friendliness of Wez Furlong's approach while also working on Win98. If we're lucky. [originally from svn r1464]
2001-12-07 21:21:03 +00:00
else
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
style &= ~WS_VSCROLL;
FIFTH ATTEMPT at getting full-screen mode right. This new attempt (which I'll comment at some stage) should combine the believable semantics of RDB's fullscreen-by-maximise mode with the multi- monitor friendliness of Wez Furlong's approach while also working on Win98. If we're lucky. [originally from svn r1464]
2001-12-07 21:21:03 +00:00
if (style != oldstyle) {
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
SetWindowLongPtr(wgs->term_hwnd, GWL_STYLE, style);
SetWindowPos(wgs->term_hwnd, NULL, 0, 0, 0, 0,
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER |
SWP_FRAMECHANGED);
FIFTH ATTEMPT at getting full-screen mode right. This new attempt (which I'll comment at some stage) should combine the believable semantics of RDB's fullscreen-by-maximise mode with the multi- monitor friendliness of Wez Furlong's approach while also working on Win98. If we're lucky. [originally from svn r1464]
2001-12-07 21:21:03 +00:00
}
Keep the state of the "Full Screen" menu item on the Ctrl+right-click context menu in sync with reality and the system menu. [originally from svn r8620]
2009-08-15 17:45:17 +00:00
/* Untick the menu item in the System and context menus. */
{
Whitespace rationalisation of entire code base. The number of people has been steadily increasing who read our source code with an editor that thinks tab stops are 4 spaces apart, as opposed to the traditional tty-derived 8 that the PuTTY code expects. So I've been wondering for ages about just fixing it, and switching to a spaces-only policy throughout the code. And I recently found out about 'git blame -w', which should make this change not too disruptive for the purposes of source-control archaeology; so perhaps now is the time. While I'm at it, I've also taken the opportunity to remove all the trailing spaces from source lines (on the basis that git dislikes them, and is the only thing that seems to have a strong opinion one way or the other). Apologies to anyone downstream of this code who has complicated patch sets to rebase past this change. I don't intend it to be needed again.
2019-09-08 19:29:00 +00:00
int i;
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
for (i = 0; i < lenof(wgs->popup_menus); i++)
CheckMenuItem(wgs->popup_menus[i].menu,
IDM_FULLSCREEN, MF_UNCHECKED);
Keep the state of the "Full Screen" menu item on the Ctrl+right-click context menu in sync with reality and the system menu. [originally from svn r8620]
2009-08-15 17:45:17 +00:00
}
FIFTH ATTEMPT at getting full-screen mode right. This new attempt (which I'll comment at some stage) should combine the believable semantics of RDB's fullscreen-by-maximise mode with the multi- monitor friendliness of Wez Furlong's approach while also working on Win98. If we're lucky. [originally from svn r1464]
2001-12-07 21:21:03 +00:00
}
/*
* Toggle full-screen mode.
*/
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
static void flip_full_screen(WinGuiSeat *wgs)
FIFTH ATTEMPT at getting full-screen mode right. This new attempt (which I'll comment at some stage) should combine the believable semantics of RDB's fullscreen-by-maximise mode with the multi- monitor friendliness of Wez Furlong's approach while also working on Win98. If we're lucky. [originally from svn r1464]
2001-12-07 21:21:03 +00:00
{
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
if (is_full_screen(wgs)) {
ShowWindow(wgs->term_hwnd, SW_RESTORE);
} else if (IsZoomed(wgs->term_hwnd)) {
make_full_screen(wgs);
FIFTH ATTEMPT at getting full-screen mode right. This new attempt (which I'll comment at some stage) should combine the believable semantics of RDB's fullscreen-by-maximise mode with the multi- monitor friendliness of Wez Furlong's approach while also working on Win98. If we're lucky. [originally from svn r1464]
2001-12-07 21:21:03 +00:00
} else {
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
SendMessage(wgs->term_hwnd, WM_FULLSCR_ON_MAX, 0, 0);
ShowWindow(wgs->term_hwnd, SW_MAXIMIZE);
FIFTH ATTEMPT at getting full-screen mode right. This new attempt (which I'll comment at some stage) should combine the believable semantics of RDB's fullscreen-by-maximise mode with the multi- monitor friendliness of Wez Furlong's approach while also working on Win98. If we're lucky. [originally from svn r1464]
2001-12-07 21:21:03 +00:00
}
}
Oops - repercussions of the close-on-exit stuff which I forgot to check in. I must stop doing my Unix checkins in the Unix subdir :-( [originally from svn r2125]
2002-10-24 14:12:55 +00:00
seat_output: add an output type for SSH banners. (NFC) The jump host system ought really to be treating SSH authentication banners as a distinct thing from the standard-error session output, so that the former can be presented to the user in the same way as the auth banner for the main session. This change converts the 'bool is_stderr' parameter of seat_output() into an enumerated type with three values. For the moment, stderr and banners are treated the same, but the plan is for that to change.
2021-09-16 13:46:49 +00:00
static size_t win_seat_output(Seat *seat, SeatOutputType type,
Make lots of 'int' length fields into size_t. This is a general cleanup which has been overdue for some time: lots of length fields are now the machine word type rather than the (in practice) fixed 'int'.
2019-02-06 20:42:44 +00:00
const void *data, size_t len)
Rationalisation of the system of frontend handles. Most modular bits of PuTTY (terminal, backend, logctx etc) take a `void *' handle passed to them from the frontend, and used as a context for all their callbacks. Most of these point at the frontend structure itself (on platforms where this is meaningful), except that the handle passed to the backend has always pointed at the terminal because from_backend() was implemented in terminal.c. This has finally bitten Unix PuTTY, because both backend and logctx have been passing their respective and very different frontend handles to logevent(), so I've fixed it. from_backend() is now a function supplied by the _frontend_ itself, in all cases, and the frontend handle passed to backends must be the same as that passed to everything else. What was from_backend() in terminal.c is now called term_data(), and the typical implementation of from_backend() in a GUI frontend will just extract the terminal handle from the frontend structure and delegate to that. This appears to work on Unix and Windows, but has most likely broken the Mac build. [originally from svn r3100]
2003-04-11 18:36:27 +00:00
{
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
WinGuiSeat *wgs = container_of(seat, WinGuiSeat, seat);
return term_data(wgs->term, data, len);
Rationalisation of the system of frontend handles. Most modular bits of PuTTY (terminal, backend, logctx etc) take a `void *' handle passed to them from the frontend, and used as a context for all their callbacks. Most of these point at the frontend structure itself (on platforms where this is meaningful), except that the handle passed to the backend has always pointed at the terminal because from_backend() was implemented in terminal.c. This has finally bitten Unix PuTTY, because both backend and logctx have been passing their respective and very different frontend handles to logevent(), so I've fixed it. from_backend() is now a function supplied by the _frontend_ itself, in all cases, and the frontend handle passed to backends must be the same as that passed to everything else. What was from_backend() in terminal.c is now called term_data(), and the typical implementation of from_backend() in a GUI frontend will just extract the terminal handle from the frontend structure and delegate to that. This appears to work on Unix and Windows, but has most likely broken the Mac build. [originally from svn r3100]
2003-04-11 18:36:27 +00:00
}
Asynchronous agent requests on Windows. Actually, I've kept the ability to do synchronous ones as well, because PSCP and PSFTP don't really need async ones and it would have been a serious pain to implement them. Also, Pageant itself when run as a client of its primary instance doesn't benefit noticeably from async agent requests. [originally from svn r3154]
2003-04-28 13:59:32 +00:00
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
static void wintw_unthrottle(TermWin *tw, size_t bufsize)
Proper buffer management between terminal and backend. The return value of term_data() is used as the return value from the GUI-terminal versions of the Seat output method, which means backends will take it to be the amount of standard-output data currently buffered, and exert back-pressure on the remote peer if it gets too big (e.g. by ceasing to extend the window in that particular SSH-2 channel). Historically, as a comment in term_data() explained, we always just returned 0 from that function, on the basis that we were processing all the terminal data through our terminal emulation code immediately, and never retained any of it in the buffer at all. If the terminal emulation code were to start running slowly, then it would slow down the _whole_ PuTTY system, due to single-threadedness, and back-pressure of a sort would be exerted on the remote by it simply failing to get round to reading from the network socket. But by the time we got back to the top level of term_data(), we'd have finished reading all the data we had, so it was still appropriate to return 0. That comment is still correct if you're thinking about the limiting factor on terminal data processing being the CPU usage in term_out(). But now that's no longer the whole story, because sometimes we leave data in term->inbuf without having processed it: during drag-selects in the terminal window, and (just introduced) while waiting for the response to a pending window resize request. For both those reasons, we _don't_ always have a buffer size of zero when we return from term_data(). So now that hole in our buffer size management is filled in: term_data() returns the true size of the remaining unprocessed terminal output, so that back-pressure will be exerted if the terminal is currently not consuming it. And when processing resumes and we start to clear our backlog, we call backend_unthrottle to let the backend know it can relax the back-pressure if necessary.
2021-12-12 10:57:23 +00:00
{
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
WinGuiSeat *wgs = container_of(tw, WinGuiSeat, termwin);
if (wgs->backend)
backend_unthrottle(wgs->backend, bufsize);
Proper buffer management between terminal and backend. The return value of term_data() is used as the return value from the GUI-terminal versions of the Seat output method, which means backends will take it to be the amount of standard-output data currently buffered, and exert back-pressure on the remote peer if it gets too big (e.g. by ceasing to extend the window in that particular SSH-2 channel). Historically, as a comment in term_data() explained, we always just returned 0 from that function, on the basis that we were processing all the terminal data through our terminal emulation code immediately, and never retained any of it in the buffer at all. If the terminal emulation code were to start running slowly, then it would slow down the _whole_ PuTTY system, due to single-threadedness, and back-pressure of a sort would be exerted on the remote by it simply failing to get round to reading from the network socket. But by the time we got back to the top level of term_data(), we'd have finished reading all the data we had, so it was still appropriate to return 0. That comment is still correct if you're thinking about the limiting factor on terminal data processing being the CPU usage in term_out(). But now that's no longer the whole story, because sometimes we leave data in term->inbuf without having processed it: during drag-selects in the terminal window, and (just introduced) while waiting for the response to a pending window resize request. For both those reasons, we _don't_ always have a buffer size of zero when we return from term_data(). So now that hole in our buffer size management is filled in: term_data() returns the true size of the remaining unprocessed terminal output, so that back-pressure will be exerted if the terminal is currently not consuming it. And when processing resumes and we start to clear our backlog, we call backend_unthrottle to let the backend know it can relax the back-pressure if necessary.
2021-12-12 10:57:23 +00:00
}
Convert a lot of 'int' variables to 'bool'. My normal habit these days, in new code, is to treat int and bool as _almost_ completely separate types. I'm still willing to use C's implicit test for zero on an integer (e.g. 'if (!blob.len)' is fine, no need to spell it out as blob.len != 0), but generally, if a variable is going to be conceptually a boolean, I like to declare it bool and assign to it using 'true' or 'false' rather than 0 or 1. PuTTY is an exception, because it predates the C99 bool, and I've stuck to its existing coding style even when adding new code to it. But it's been annoying me more and more, so now that I've decided C99 bool is an acceptable thing to require from our toolchain in the first place, here's a quite thorough trawl through the source doing 'boolification'. Many variables and function parameters are now typed as bool rather than int; many assignments of 0 or 1 to those variables are now spelled 'true' or 'false'. I managed this thorough conversion with the help of a custom clang plugin that I wrote to trawl the AST and apply heuristics to point out where things might want changing. So I've even managed to do a decent job on parts of the code I haven't looked at in years! To make the plugin's work easier, I pushed platform front ends generally in the direction of using standard 'bool' in preference to platform-specific boolean types like Windows BOOL or GTK's gboolean; I've left the platform booleans in places they _have_ to be for the platform APIs to work right, but variables only used by my own code have been converted wherever I found them. In a few places there are int values that look very like booleans in _most_ of the places they're used, but have a rarely-used third value, or a distinction between different nonzero values that most users don't care about. In these cases, I've _removed_ uses of 'true' and 'false' for the return values, to emphasise that there's something more subtle going on than a simple boolean answer: - the 'multisel' field in dialog.h's list box structure, for which the GTK front end in particular recognises a difference between 1 and 2 but nearly everything else treats as boolean - the 'urgent' parameter to plug_receive, where 1 vs 2 tells you something about the specific location of the urgent pointer, but most clients only care about 0 vs 'something nonzero' - the return value of wc_match, where -1 indicates a syntax error in the wildcard. - the return values from SSH-1 RSA-key loading functions, which use -1 for 'wrong passphrase' and 0 for all other failures (so any caller which already knows it's not loading an _encrypted private_ key can treat them as boolean) - term->esc_query, and the 'query' parameter in toggle_mode in terminal.c, which _usually_ hold 0 for ESC[123h or 1 for ESC[?123h, but can also hold -1 for some other intervening character that we don't support. In a few places there's an integer that I haven't turned into a bool even though it really _can_ only take values 0 or 1 (and, as above, tried to make the call sites consistent in not calling those values true and false), on the grounds that I thought it would make it more confusing to imply that the 0 value was in some sense 'negative' or bad and the 1 positive or good: - the return value of plug_accepting uses the POSIXish convention of 0=success and nonzero=error; I think if I made it bool then I'd also want to reverse its sense, and that's a job for a separate piece of work. - the 'screen' parameter to lineptr() in terminal.c, where 0 and 1 represent the default and alternate screens. There's no obvious reason why one of those should be considered 'true' or 'positive' or 'success' - they're just indices - so I've left it as int. ssh_scp_recv had particularly confusing semantics for its previous int return value: its call sites used '<= 0' to check for error, but it never actually returned a negative number, just 0 or 1. Now the function and its call sites agree that it's a bool. In a couple of places I've renamed variables called 'ret', because I don't like that name any more - it's unclear whether it means the return value (in preparation) for the _containing_ function or the return value received from a subroutine call, and occasionally I've accidentally used the same variable for both and introduced a bug. So where one of those got in my way, I've renamed it to 'toret' or 'retd' (the latter short for 'returned') in line with my usual modern practice, but I haven't done a thorough job of finding all of them. Finally, one amusing side effect of doing this is that I've had to separate quite a few chained assignments. It used to be perfectly fine to write 'a = b = c = TRUE' when a,b,c were int and TRUE was just a the 'true' defined by stdbool.h, that idiom provokes a warning from gcc: 'suggest parentheses around assignment used as truth value'!
2018-11-02 19:23:19 +00:00
static bool win_seat_eof(Seat *seat)
Revamp of EOF handling in all network connections, pipes and other data channels. Should comprehensively fix 'half-closed', in principle, though it's a big and complicated change and so there's a good chance I've made at least one mistake somewhere. All connections should now be rigorous about propagating end-of-file (or end-of-data-stream, or socket shutdown, or whatever) independently in both directions, except in frontends with no mechanism for sending explicit EOF (e.g. interactive terminal windows) or backends which are basically always used for interactive sessions so it's unlikely that an application would be depending on independent EOF (telnet, rlogin). EOF should now never accidentally be sent while there's still buffered data to go out before it. (May help fix 'portfwd-corrupt', and also I noticed recently that the ssh main session channel can accidentally have MSG_EOF sent before the output bufchain is clear, leading to embarrassment when it subsequently does send the output). [originally from svn r9279]
2011-09-13 11:44:03 +00:00
{
Adopt C99 <stdbool.h>'s true/false. This commit includes <stdbool.h> from defs.h and deletes my traditional definitions of TRUE and FALSE, but other than that, it's a 100% mechanical search-and-replace transforming all uses of TRUE and FALSE into the C99-standardised lowercase spellings. No actual types are changed in this commit; that will come next. This is just getting the noise out of the way, so that subsequent commits can have a higher proportion of signal.
2018-10-29 19:50:29 +00:00
return true; /* do respond to incoming EOF with outgoing */
Revamp of EOF handling in all network connections, pipes and other data channels. Should comprehensively fix 'half-closed', in principle, though it's a big and complicated change and so there's a good chance I've made at least one mistake somewhere. All connections should now be rigorous about propagating end-of-file (or end-of-data-stream, or socket shutdown, or whatever) independently in both directions, except in frontends with no mechanism for sending explicit EOF (e.g. interactive terminal windows) or backends which are basically always used for interactive sessions so it's unlikely that an application would be depending on independent EOF (telnet, rlogin). EOF should now never accidentally be sent while there's still buffered data to go out before it. (May help fix 'portfwd-corrupt', and also I noticed recently that the ssh main session channel can accidentally have MSG_EOF sent before the output bufchain is clear, leading to embarrassment when it subsequently does send the output). [originally from svn r9279]
2011-09-13 11:44:03 +00:00
}
Richer data type for interactive prompt results. All the seat functions that request an interactive prompt of some kind to the user - both the main seat_get_userpass_input and the various confirmation dialogs for things like host keys - were using a simple int return value, with the general semantics of 0 = "fail", 1 = "proceed" (and in the case of seat_get_userpass_input, answers to the prompts were provided), and -1 = "request in progress, wait for a callback". In this commit I change all those functions' return types to a new struct called SeatPromptResult, whose primary field is an enum replacing those simple integer values. The main purpose is that the enum has not three but _four_ values: the "fail" result has been split into 'user abort' and 'software abort'. The distinction is that a user abort occurs as a result of an interactive UI action, such as the user clicking 'cancel' in a dialog box or hitting ^D or ^C at a terminal password prompt - and therefore, there's no need to display an error message telling the user that the interactive operation has failed, because the user already knows, because they _did_ it. 'Software abort' is from any other cause, where PuTTY is the first to know there was a problem, and has to tell the user. We already had this 'user abort' vs 'software abort' distinction in other parts of the code - the SSH backend has separate termination functions which protocol layers can call. But we assumed that any failure from an interactive prompt request fell into the 'user abort' category, which is not true. A couple of examples: if you configure a host key fingerprint in your saved session via the SSH > Host keys pane, and the server presents a host key that doesn't match it, then verify_ssh_host_key would report that the user had aborted the connection, and feel no need to tell the user what had gone wrong! Similarly, if a password provided on the command line was not accepted, then (after I fixed the semantics of that in the previous commit) the same wrong handling would occur. So now, those Seat prompt functions too can communicate whether the user or the software originated a connection abort. And in the latter case, we also provide an error message to present to the user. Result: in those two example cases (and others), error messages should no longer go missing. Implementation note: to avoid the hassle of having the error message in a SeatPromptResult being a dynamically allocated string (and hence, every recipient of one must always check whether it's non-NULL and free it on every exit path, plus being careful about copying the struct around), I've instead arranged that the structure contains a function pointer and a couple of parameters, so that the string form of the message can be constructed on demand. That way, the only users who need to free it are the ones who actually _asked_ for it in the first place, which is a much smaller set. (This is one of the rare occasions that I regret not having C++'s extra features available in this code base - a unique_ptr or shared_ptr to a string would have been just the thing here, and the compiler would have done all the hard work for me of remembering where to insert the frees!)
2021-12-28 17:52:00 +00:00
static SeatPromptResult win_seat_get_userpass_input(Seat *seat, prompts_t *p)
Revamp SSH authentication code so that user interaction is more abstracted out; replace loops structured around a single interaction per loop with less tortuous code (fixes: `ki-multiprompt-crash', `ssh1-bad-passphrase-crash'; makes `ssh2-password-expiry' and `proxy-password-prompt' easier). The new interaction abstraction has a lot of fields that are unused in the current code (things like window captions); this is groundwork for `gui-auth'. However, ssh.c still writes directly to stderr; that may want to be fixed. In the GUI apps, user interaction is moved to terminal.c. This should make it easier to fix things like UTF-8 username entry, although I haven't attempted to do so. Also, control character filtering can be tailored to be appropriate for individual front-ends; so far I don't promise anything other than not having made it any worse. I've tried to test this fairly exhaustively (although Mac stuff is untested, as usual). It all seems to basically work, but I bet there are new bugs. (One I know about is that you can no longer make the PuTTY window go away with a ^D at the password prompt; this should be fixed.) [originally from svn r6437] [this svn revision also touched putty-wishlist]
2005-10-30 20:24:09 +00:00
{
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
WinGuiSeat *wgs = container_of(seat, WinGuiSeat, seat);
Richer data type for interactive prompt results. All the seat functions that request an interactive prompt of some kind to the user - both the main seat_get_userpass_input and the various confirmation dialogs for things like host keys - were using a simple int return value, with the general semantics of 0 = "fail", 1 = "proceed" (and in the case of seat_get_userpass_input, answers to the prompts were provided), and -1 = "request in progress, wait for a callback". In this commit I change all those functions' return types to a new struct called SeatPromptResult, whose primary field is an enum replacing those simple integer values. The main purpose is that the enum has not three but _four_ values: the "fail" result has been split into 'user abort' and 'software abort'. The distinction is that a user abort occurs as a result of an interactive UI action, such as the user clicking 'cancel' in a dialog box or hitting ^D or ^C at a terminal password prompt - and therefore, there's no need to display an error message telling the user that the interactive operation has failed, because the user already knows, because they _did_ it. 'Software abort' is from any other cause, where PuTTY is the first to know there was a problem, and has to tell the user. We already had this 'user abort' vs 'software abort' distinction in other parts of the code - the SSH backend has separate termination functions which protocol layers can call. But we assumed that any failure from an interactive prompt request fell into the 'user abort' category, which is not true. A couple of examples: if you configure a host key fingerprint in your saved session via the SSH > Host keys pane, and the server presents a host key that doesn't match it, then verify_ssh_host_key would report that the user had aborted the connection, and feel no need to tell the user what had gone wrong! Similarly, if a password provided on the command line was not accepted, then (after I fixed the semantics of that in the previous commit) the same wrong handling would occur. So now, those Seat prompt functions too can communicate whether the user or the software originated a connection abort. And in the latter case, we also provide an error message to present to the user. Result: in those two example cases (and others), error messages should no longer go missing. Implementation note: to avoid the hassle of having the error message in a SeatPromptResult being a dynamically allocated string (and hence, every recipient of one must always check whether it's non-NULL and free it on every exit path, plus being careful about copying the struct around), I've instead arranged that the structure contains a function pointer and a couple of parameters, so that the string form of the message can be constructed on demand. That way, the only users who need to free it are the ones who actually _asked_ for it in the first place, which is a much smaller set. (This is one of the rare occasions that I regret not having C++'s extra features available in this code base - a unique_ptr or shared_ptr to a string would have been just the thing here, and the compiler would have done all the hard work for me of remembering where to insert the frees!)
2021-12-28 17:52:00 +00:00
SeatPromptResult spr;
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
spr = cmdline_get_passwd_input(p, &wgs->cmdline_get_passwd_state, true);
Richer data type for interactive prompt results. All the seat functions that request an interactive prompt of some kind to the user - both the main seat_get_userpass_input and the various confirmation dialogs for things like host keys - were using a simple int return value, with the general semantics of 0 = "fail", 1 = "proceed" (and in the case of seat_get_userpass_input, answers to the prompts were provided), and -1 = "request in progress, wait for a callback". In this commit I change all those functions' return types to a new struct called SeatPromptResult, whose primary field is an enum replacing those simple integer values. The main purpose is that the enum has not three but _four_ values: the "fail" result has been split into 'user abort' and 'software abort'. The distinction is that a user abort occurs as a result of an interactive UI action, such as the user clicking 'cancel' in a dialog box or hitting ^D or ^C at a terminal password prompt - and therefore, there's no need to display an error message telling the user that the interactive operation has failed, because the user already knows, because they _did_ it. 'Software abort' is from any other cause, where PuTTY is the first to know there was a problem, and has to tell the user. We already had this 'user abort' vs 'software abort' distinction in other parts of the code - the SSH backend has separate termination functions which protocol layers can call. But we assumed that any failure from an interactive prompt request fell into the 'user abort' category, which is not true. A couple of examples: if you configure a host key fingerprint in your saved session via the SSH > Host keys pane, and the server presents a host key that doesn't match it, then verify_ssh_host_key would report that the user had aborted the connection, and feel no need to tell the user what had gone wrong! Similarly, if a password provided on the command line was not accepted, then (after I fixed the semantics of that in the previous commit) the same wrong handling would occur. So now, those Seat prompt functions too can communicate whether the user or the software originated a connection abort. And in the latter case, we also provide an error message to present to the user. Result: in those two example cases (and others), error messages should no longer go missing. Implementation note: to avoid the hassle of having the error message in a SeatPromptResult being a dynamically allocated string (and hence, every recipient of one must always check whether it's non-NULL and free it on every exit path, plus being careful about copying the struct around), I've instead arranged that the structure contains a function pointer and a couple of parameters, so that the string form of the message can be constructed on demand. That way, the only users who need to free it are the ones who actually _asked_ for it in the first place, which is a much smaller set. (This is one of the rare occasions that I regret not having C++'s extra features available in this code base - a unique_ptr or shared_ptr to a string would have been just the thing here, and the compiler would have done all the hard work for me of remembering where to insert the frees!)
2021-12-28 17:52:00 +00:00
if (spr.kind == SPRK_INCOMPLETE)
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
spr = term_get_userpass_input(wgs->term, p);
Richer data type for interactive prompt results. All the seat functions that request an interactive prompt of some kind to the user - both the main seat_get_userpass_input and the various confirmation dialogs for things like host keys - were using a simple int return value, with the general semantics of 0 = "fail", 1 = "proceed" (and in the case of seat_get_userpass_input, answers to the prompts were provided), and -1 = "request in progress, wait for a callback". In this commit I change all those functions' return types to a new struct called SeatPromptResult, whose primary field is an enum replacing those simple integer values. The main purpose is that the enum has not three but _four_ values: the "fail" result has been split into 'user abort' and 'software abort'. The distinction is that a user abort occurs as a result of an interactive UI action, such as the user clicking 'cancel' in a dialog box or hitting ^D or ^C at a terminal password prompt - and therefore, there's no need to display an error message telling the user that the interactive operation has failed, because the user already knows, because they _did_ it. 'Software abort' is from any other cause, where PuTTY is the first to know there was a problem, and has to tell the user. We already had this 'user abort' vs 'software abort' distinction in other parts of the code - the SSH backend has separate termination functions which protocol layers can call. But we assumed that any failure from an interactive prompt request fell into the 'user abort' category, which is not true. A couple of examples: if you configure a host key fingerprint in your saved session via the SSH > Host keys pane, and the server presents a host key that doesn't match it, then verify_ssh_host_key would report that the user had aborted the connection, and feel no need to tell the user what had gone wrong! Similarly, if a password provided on the command line was not accepted, then (after I fixed the semantics of that in the previous commit) the same wrong handling would occur. So now, those Seat prompt functions too can communicate whether the user or the software originated a connection abort. And in the latter case, we also provide an error message to present to the user. Result: in those two example cases (and others), error messages should no longer go missing. Implementation note: to avoid the hassle of having the error message in a SeatPromptResult being a dynamically allocated string (and hence, every recipient of one must always check whether it's non-NULL and free it on every exit path, plus being careful about copying the struct around), I've instead arranged that the structure contains a function pointer and a couple of parameters, so that the string form of the message can be constructed on demand. That way, the only users who need to free it are the ones who actually _asked_ for it in the first place, which is a much smaller set. (This is one of the rare occasions that I regret not having C++'s extra features available in this code base - a unique_ptr or shared_ptr to a string would have been just the thing here, and the compiler would have done all the hard work for me of remembering where to insert the frees!)
2021-12-28 17:52:00 +00:00
return spr;
Revamp SSH authentication code so that user interaction is more abstracted out; replace loops structured around a single interaction per loop with less tortuous code (fixes: `ki-multiprompt-crash', `ssh1-bad-passphrase-crash'; makes `ssh2-password-expiry' and `proxy-password-prompt' easier). The new interaction abstraction has a lot of fields that are unused in the current code (things like window captions); this is groundwork for `gui-auth'. However, ssh.c still writes directly to stderr; that may want to be fixed. In the GUI apps, user interaction is moved to terminal.c. This should make it easier to fix things like UTF-8 username entry, although I haven't attempted to do so. Also, control character filtering can be tailored to be appropriate for individual front-ends; so far I don't promise anything other than not having made it any worse. I've tried to test this fairly exhaustively (although Mac stuff is untested, as usual). It all seems to basically work, but I bet there are new bugs. (One I know about is that you can no longer make the PuTTY window go away with a ^D at the password prompt; this should be fixed.) [originally from svn r6437] [this svn revision also touched putty-wishlist]
2005-10-30 20:24:09 +00:00
}
Divide seat_set_trust_status into query and update. This complicates the API in one sense (more separate functions), but in another sense, simplifies it (each function does something simpler). When I start putting one Seat in front of another during SSH proxying, the latter will be more important - in particular, it means you can find out _whether_ a seat can support changing trust status without having to actually attempt a destructive modification.
2021-09-12 08:52:46 +00:00
static void win_seat_set_trust_status(Seat *seat, bool trusted)
Seat method to set the current trust status. In terminal-based GUI applications, this is passed through to term_set_trust_status, to toggle whether lines are prefixed with the new trust sigil. In console applications, the function returns false, indicating to the backend that it should employ some other technique for spoofing protection.
2019-03-10 14:42:11 +00:00
{
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
WinGuiSeat *wgs = container_of(seat, WinGuiSeat, seat);
term_set_trust_status(wgs->term, trusted);
Divide seat_set_trust_status into query and update. This complicates the API in one sense (more separate functions), but in another sense, simplifies it (each function does something simpler). When I start putting one Seat in front of another during SSH proxying, the latter will be more important - in particular, it means you can find out _whether_ a seat can support changing trust status without having to actually attempt a destructive modification.
2021-09-12 08:52:46 +00:00
}
static bool win_seat_can_set_trust_status(Seat *seat)
{
Seat method to set the current trust status. In terminal-based GUI applications, this is passed through to term_set_trust_status, to toggle whether lines are prefixed with the new trust sigil. In console applications, the function returns false, indicating to the backend that it should employ some other technique for spoofing protection.
2019-03-10 14:42:11 +00:00
return true;
}
Add a new seat method to return the cursor position. The motivation is for the SUPDUP protocol. The server may send a signal for the terminal to reset any input buffers. After this, the server will not know the state of the terminal, so it is required to send its cursor position back.
2019-04-04 19:17:24 +00:00
static bool win_seat_get_cursor_position(Seat *seat, int *x, int *y)
{
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
WinGuiSeat *wgs = container_of(seat, WinGuiSeat, seat);
term_get_cursor_position(wgs->term, x, y);
Add a new seat method to return the cursor position. The motivation is for the SUPDUP protocol. The server may send a signal for the terminal to reset any input buffers. After this, the server will not know the state of the terminal, so it is required to send its cursor position back.
2019-04-04 19:17:24 +00:00
return true;
}
Flip direction of window pos/size queries. Similarly to other recent changes, the frontend now proactively keeps Terminal up to date with the current position and size of the terminal window, so that escape-sequence queries can be answered immediately from the Terminal's own internal data structures without needing a call back to the frontend. Mostly this has let me remove explicit window-system API calls that retrieve the window position and size, in favour of having the front ends listen for WM_MOVE / WM_SIZE / ConfigureNotify events and track the position and size that way. One exception is that the window pixel size is still requested by Seat via a callback, to put in the wire-encoded termios settings. That won't be happening very much, so I'm leaving it this way round for the moment.
2021-02-07 19:59:21 +00:00
static bool win_seat_get_window_pixel_size(Seat *seat, int *x, int *y)
{
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
WinGuiSeat *wgs = container_of(seat, WinGuiSeat, seat);
Flip direction of window pos/size queries. Similarly to other recent changes, the frontend now proactively keeps Terminal up to date with the current position and size of the terminal window, so that escape-sequence queries can be answered immediately from the Terminal's own internal data structures without needing a call back to the frontend. Mostly this has let me remove explicit window-system API calls that retrieve the window position and size, in favour of having the front ends listen for WM_MOVE / WM_SIZE / ConfigureNotify events and track the position and size that way. One exception is that the window pixel size is still requested by Seat via a callback, to put in the wire-encoded termios settings. That won't be happening very much, so I'm leaving it this way round for the moment.
2021-02-07 19:59:21 +00:00
RECT r;
windows/window.c: move (most) static vars into WinGuiSeat. This is a piece of refactoring that's been overdue forever. In the Unix front end, all the variables specific to a particular SSH session live in a big 'inst' structure, and calls to any of the trait APIs like Seat or TermWin can recover the right 'inst' from their input context pointer. But the Windows frontend was written before that kind of thing became habitual to me, and all its variables have been just lying around at the top level of window.c, and most of those context pointers were just ignored. Now I've swept them all up and put them where they ought to be, in a big context structure. This was made immeasurably easier by the very nifty 'clang-rename' tool, which can rename a single variable in a C source file, and find just the right set of identifiers to change even if other variables in the file have the same name, even in sub-scopes. So I started by clang-renaming all the top-level variables in question to have names beginning with a prefix that didn't previously appear anywhere in the code; checked that still worked; and then moved all the declarations into the struct type and did a purely textual search-and-replace of the prefix with 'wgs->'. One potential benefit of this change is that it allows more than one instance of the WinGuiSeat structure to exist in the same process. I don't have any immediate plans to actually do that, but it's nice to know it wouldn't be ruled out if we ever did need it. But that's not the main reason I did it. The main reason is that I recently looked at the output of a Windows build using clang -Wall, and was horrified by the number of casual shadowings of generically-named global variables like 'term' and 'conf' with local variables of the same name. That seemed like a recipe for confusion, and I decided the best way to disambiguate them all was to do this refactoring that I'd wanted anyway for years. A few uses of the global variables occurred in functions that didn't have convenient access to the right WinGuiSeat via a callback parameter of some kind. Those had to be treated specially. Most were cleaned up in advance by the previous few commits; the remaining fixes in this commit itself were in functions like modalfatalbox(), nonfatal() and cleanup_exit(). The error reporting functions want the terminal HWND to use as a MessageBox parameter; they also have the side effect of un-hiding the mouse pointer in the terminal window, in case it's hidden; and cleanup_exit wanted to free some resources dangling off the WinGuiSeat. For most of those cases, I've made a linked list of all currently live WinGuiSeat structures, so that they can loop over _all_ live instances (whether there's one as usual, none, or maybe more than one in future). The parent window for non-connection-specific error messages is found by simply picking one arbitrarily off the linked list (if any); the cleanups are done by iterating over the _whole_ list. The mouse-pointer unhiding is dealt with by simply allowing show_mouseptr to take a _null_ WinGuiSeat pointer. The only thing it needs the context for at all is to check whether pointer-hiding is enabled in the session's Conf; so if we're _un_-hiding the pointer we don't need to check, and can unhide it unconditionally. The remaining global variables in window.c are the new linked list of all WinGuiSeat structures; 'wm_mousewheel' and 'trust_icon' which really should be global across all WinGuiSeats even if we were to have more than one; and there's a static variable 'cursor_visible' in show_mouseptr() which is likewise legitimately Seat-independent (since it records the last value we passed to the Win32 API ShowCursor function, and _that's_ global across the whole process state). All of this should cause no functional change whatsoever.
2022-09-13 08:00:19 +00:00
GetWindowRect(wgs->term_hwnd, &r);
Flip direction of window pos/size queries. Similarly to other recent changes, the frontend now proactively keeps Terminal up to date with the current position and size of the terminal window, so that escape-sequence queries can be answered immediately from the Terminal's own internal data structures without needing a call back to the frontend. Mostly this has let me remove explicit window-system API calls that retrieve the window position and size, in favour of having the front ends listen for WM_MOVE / WM_SIZE / ConfigureNotify events and track the position and size that way. One exception is that the window pixel size is still requested by Seat via a callback, to put in the wire-encoded termios settings. That won't be happening very much, so I'm leaving it this way round for the moment.
2021-02-07 19:59:21 +00:00
*x = r.right - r.left;
*y = r.bottom - r.top;
return true;
}
Reference in New Issue Copy Permalink