I see that another user requested this in 2005.


I use PhpED primarily for debugging, since I'm most familiar
with vi. The ability to automatically suppress this message would
be invaluable.

Thanks.

PhpED -> Tools -> Settings -> IDE Settings -> Check for externally modified files (uncheck)

Based on the fact that he's using the IDE for debugging, however, my guess is that he *does* want the IDE to check for modified files--and use the newer versions--but simply not yap about it. Turning off that setting will kill the yapping, but it will also kill the checking.

I this would welcome it as an option, as it's what I'm used to in BBEdit. Related, I'd also like it if the IDE had external editor support, so if one wanted, one could use another text editor that was more powerful than PhpED's (like vim), but still easily use the IDE for non-editing tasks.

Bob is correct; I want PhpED to check for externally modified files, just
not make me click OK in acknowledgment for each one when I switch back.
Just an additional option to suppress the messages is all I need.

I think it's quite a dangerous thing like any editing witout user intervention.

With respect, I acknowledge you consider this to be dangerous, but by the same token,
running PhpED (or any user app) with Administrator or root privledges is too. PhpED still
runs under a these circumstances... My point is, as programmers, it's nice to
have the flexibility... even to do dangerous things.

Furthermore, for programming/text editors, this is not an uncommon feature. Visual Studio has
had it, Slickedit, Multiedit, Textpad, etc.

Despite your personal objections to this request, would you still please consider it,
if for no other reason than to support loyal customers?

Why? Assuming appropriate OS security measures, and that you don't have some sort of virus or something (in which case, all bets are off, warnings or not), how will a file get modified if I don't do it? I do this sort of thing all the time, and it's particularly handy with text files, which are universal and so can be edited with the tool that makes the job at hand easiest. On my Mac, for instance, I'm always mixing use of BBEdit, TextMate, AppleScript scripts, and various Unix utils and scripts to get the job done, and it's wonderful to have my main text editor (BBEdit) recognize changes without bugging me. It lets me focus on tasks without worrying about administrative details.

In PhpED's case, its search-and-replace features are somewhat weak and cumbersome to use, so my preference would be to use something else for big jobs, like say, a complicated regex replacement across hundreds of files in a project. Since my machines are networked, I might even use BBEdit over on my Mac, since it's search-and-replace function is in a league of its own. What happens if I do this and then go back to the IDE? Potentially, lots of warnings. It'd be great to instead just pop back to the IDE and continue working as though nothing happened.

And, as already pointed out, your market is developers! While I think it's as important to maintain usability for developers as for anyone else, I think the fact that you're catering to developers means you can open up additional power-user features that normal users might get themselves into trouble with. If there's any group that you can assume should be able to take responsibility with an IDE, it's developers . Besides, if you just default to issuing a warning, no one can blame anyone but themselves if they turn it off and get into trouble with it.

it's not what I meant.
Suppose you have a file opened in the IDE. IDE checks for its modifications ~ once per 30 seconds. Just checks datetime stamp and size. If for example you modify the disk copy using external tools, you'll have to wait for these 30 seconds or all modifications you've done within this period will be lost.

That's a problem, but the alerts don't address it - except, perhaps, when the user doesn't see an alert before making changes when they're expecting to. But this is protection through lack-of-action, which isn't very reliable.

As to the actual problem, I'm surprised that Windows doesn't have a way for an app to request notification when a file changes. Anyway, a couple of additions would help mitigate the problem somewhat:

- Check every time the user switches back to the IDE from another program, as well as after operations the IDE initiates that may change files, like running scripts or external programs.

- Add a command to explicitly check for changes that can easily be assigned to a toolbar button or to a keyboard shortcut. This would be useful when files are being changed from another computer.

The second one handles what I admit is more of an edge case. The first one would handle the problem 99% of the time, and clearly documenting the check interval would let the user handle the other 1%.

Windows supports notifications, but we do not use them for this feature.
It's done for many reasons: each notification eats system resorces and slowdown every Windows Explorer instance you open.
Such notications can't be performed main thread or it will be lagging, therefore we'll have to run thread. One thread can't wait for more than 64objects and therefore we'll need to have an opportunity to run multiple threads and so forth.
Finally, notifications do never guarantee that you'll get them intime. Therefore it is not a reliable solution.
But I have no doubts, this approach may be somewhat better than polling each 30sec


it's already done long time ago. But it will not help you if you run external tool using Shell menus in for example Workspace window. As I know many people either integrate tools using Tools->Settings->Integrations or invoke them via Shell menu. In some cases, IDE remains active and no task switching occurs.


it looks like an additional action while all this discussion is about to remove extra actions like clicking [Ok] or [Cancel] in the warning.

You missed part of my statement: "- Check every time the user switches back to the IDE from another program, as well as after operations the IDE initiates that may change files, like running scripts or external programs." Running of external tools via the Workspace window was specifically one of the things I had in mind as I wrote that .

From the sound of it, it seems that a workable quick-and-dirty short-term solution might be to offer an option such that when the IDE detects a changed file, not throw up a warning, but just play a sound and note the file in the log.

I wonder if Vista's notifications are any better. As I understand, MS has added a global search feature; when Apple added the same feature to OS X a couple of years ago, they added a really nice change notification API as part of the implementation. And being part of the kernel itself, it's very reliable. I would guess MS would need something similar to support their search feature.

We'll not hurry up with this approach.
Filesystem notifications under Win32 aren't that bad and we need just time to implement our stuff working with them.