What fast and reliable ways are there to know whether I activated everything I changed in the ABAP workbench?
Reason for asking: if I forgot something, I'm the reason that a (test) transport can't be exported (easily).
My closest approach to an answer is
change some arbitrary code
activate that code
If there was something left to activate, I'm offered to activate that, too.
But is there a fast and reliable way to do that without changing some arbitrary code?
SE80 -> Environment -> Inactive Object will give you the list you are looking for.
Related
When it comes to implementing "quick fixes" there are two separate class hierarchies you can use, QuickFix (and LocalQuickFix) and IntentionAction. There also seems to be ways of implementing both (as in LocalQuickFixAndIntentionActionOnPsiElement).
I'd like to know the difference between those two base classes. When would I use one but not the other? Is one of those hierarchies obsolete and superseded by the other?
A QuickFix usually belongs to an Inspection, and should be implemented as an automated fix to the warning issued by the inspection.
Try, for example, using list.size() == 0 in Java. IntelliJ will suggest to replace this with list.isEmpty().
Note the highlighting (in IntelliJ).
The action that you can trigger with Alt + Enter is called the quick fix, and it will execute this replacement for you.
An intention is similar in the sense that it is an action specific to a piece of code that can be triggered by Alt + Enter. The main difference is that IntelliJ doesn't complain if you don't use the intention; there is no highlighting to indicate that something is or could be wrong here, because there probably isn't.
Intentions are meant to make the life of the user easier, but they don't get as in your face as inspections do.
To give an example, this could be used in LaTeX to replace any brace pair by their \left\right equivalent; it's not something to trigger an inspection for because often the simple brace pair is preferred, but it's nice to be able to do this replacement with a simple shortcut.
You'll regularly encounter loops in intentions as well, and even intentions that go in the opposite direction as a quick fix, but you won't see loops in quick fixes (unless you've explicitly enabled both directions of an inspection).
To summarise: use a quick fix when implementing an automated fix to an inspection, and use an intention action otherwise.
Yes, as You can see, I use those two modules in exactly the right order, disable the tree on the left side and I am quite happy, that this works so easily.
But when we come to variants, it dumps. Ok, until now I do not react to that click, because I have not assigned any callbacks....
But I was already googling, and most of the stuff I found, stated, that I cannot use variants for this dynamic selection screens.
However, it does make sense in a way, to disable the functions.... but what, if
I still want to have them ?
(Especially, because some jobs should be run at some, uncertain, dates )... using those variants...
In every IDE I've tried so far, if I'm partway through writing a message and need to look at the code of another, the browser asks me if I want to save. But if I say I do want to save, it actually tries to compile/syntax check the code, and refuses to perform the save if it does not pass. The only way to view the source of another message seems to be to say "no" to save and have everything wiped. How can I look at another class incidentally, or save code I am partway through working on that might not build right now?
Smalltalk is a multi-browser system. You'll need to have lots of different browsers open. Smalltalk is opinionated. The system browser (Nautilus) doesn't make it easy to view long methods, steering you towards writing short ones. It doesn't make it easy to have non-compiling code in a method, to steer you towards making small changes.
Experimental/prototypical code you might want to have in a Workspace/Playground. That can save to disk.
We are aware that it is an issue for people new to Smalltalk. We tried some fixes, they were a lot worse.
For now there is no easy way to do that. The two easiest opting are
Make the current method syntactically correct and save it.
Open another browser. If you want to see a class or method that is in your current code, you can cmd+click it or use "browse it", "implementors of", shortcuts that will open another window.
Also in pharo you can use GTSpotter to quickly find what you are looking for and preview its source code
When you say "this seems like a pretty huge thing to be missing,
and it could be gotten around by just having the option to use
a regular editor" I'm afraid you've entirely missed the point.
Understandable, though -- happens to us all.
Or did. Perhaps it was long ago, but we
were all there.
You might be thinking about the task in terms of
scrolling a giant text up and down to find what
you want. Scroll up -- read a little -- scroll back --
and continue making your changes.
And when you say " I can't imagine any circumstance
where it is OK, in pursuit of any agenda, to throw away
the coder's work against their will "
you are spot on correct, of course.
Imagine -- scrolling around, making dozens of little changes,
and before you've saved them -- poof -- they're all thrown away --
a mistake, perhaps, but completely against your will.
That would be awful. We're agreed.
(In fact, the editor I'm using to type this
is like that -- I can scroll around the whole thing,
making little improvements, all over, but it could
all go --poof-- and disappear, All of it.
Fairly common occurrence, when editing the web.
)
So let's try another run through that same task.
You get one little teensy, DUMB AS A POST editor,
where you can only see one thing at a time.
And now you just want to scroll somewhere else,
for a moment, and come right back.
Which actually means that
you are attempting to look up a second method,
while already changing a first method
(which would require the browser toforget the
context of the first method, and move to the second).
The browser does not know how long you will be away
from this context. You might go chaining along from
place to place, stop and read an email, take a call,
and go to lunch.
So, the browser cautions
"Hey - want to save this first?"
as if to say:
"
Hey - I can't imagine any circumstance where it is OK,
in pursuit of any agenda, to throw away the coder's work
against their will.
So listen up, coder.
You want to save this first?
"
But you can't save it.
You must first look something up.
Conundrum.
Ah-ha! There is a list of methods in that other pane.
One of them is highlighted.
Not those -- that one.
Double click that one.
The one you're already in.
As if to say
" Thanks. Good catch.
Yes, I know - can't though.
I need to change contexts.
You stay right here.
And give me another context
to go wandering about in.
please.
"
Soon, I expect, they'll start actually talking.
I'm currently trying to write a program in VB.NET which fluidly changes the DWM window colorization colors in Windows 7.
I first tried to edit Registry values directly, but I had to restart the UXSMS service. This solution was unsatisfying, because of the toggle of the taskbar.
I'm now searching for a function in a DLL such as user32.dll or themecpl.dll which can reproduce the behaviour of control panel when setting the window color.
I'm now on IDA, searching for the adquate function (CColorCplPage::SetDwmColorizationColor seems good!). If anyone has one, please share it!
(If anyone need screens or code, please ask. Sorry for my poor English.)
Your first attempt failed because manually editing the Registry is never the correct way to change system settings. As you found out, lots of Windows components (and other applications!) read those configuration values once and cache them, preventing your changes from being propagated. Another problem (and you'd be surprised how often I see this) is applications that attempt to muck around in the Registry generally end up corrupting things.
Instead, you should call the documented API to change the settings. There's almost always a documented way of doing this, and if there isn't, well then you shouldn't be doing it.
This appears to be one of those cases. There's a documented DwmGetColorizationColor function, but there's no corresponding DwmSetColorizationColor function, as one might expect.
The reason is that the user is supposed to be the only one who can change their colorization settings, not other applications. You might promise not to abuse this, and to only make such changes at the user's explicit request, but not all applications can be trusted to do this. Lots of people would use it maliciously, so these functions have not been documented and exposed.
But as usual, if you press on, you can usually find an undocumented way of doing things. The problem with using undocumented functions is that there's no guarantee they'll work or continue to work. They've been intentionally left undocumented because they're liable to change on new versions of Windows. You should only use them at your own risk.
In this case, if you use a program like DumpBin to obtain a list of all the exported functions from the DWM DLL (dwmapi.dll), you'll see a number of undocumented exported functions.
The ones you're interested in are DwmGetColorizationParameters and DwmSetColorizationParameters. Both of these functions take a COLORIZATIONPARAMS structure as an argument that contains the values they need.
So, you need to reverse engineer these functions and obtain the appropriate definitions. Then, you can call the DwmGetColorizationParameters function, passing in a COLORIZATIONPARAMS structure to obtain the current configuration settings; modify the member of the structure that contains the current colorization color; and then pass that modified version of the structure to the DwmSetColorizationParameters function.
Did I mention that I don't recommend doing this?
I want to have a button which allows the user to pick a global hotkey. I stumbled upon stackoverflow and found some ways to register a hotkey, but none which allows me to let the user pick one. Is there maybe a library for it? Or how you guys handle this?
It should look like this:
If you would like to use an already existing framework, Shortcut Recorder is a good one that is used often. It's pretty easy to use, and might suit your needs. You can also do this manually, as alfred has mentioned, but it's quite a bit more work this way.
You may just create an Event Tap and register keys pressed by the user. When the callback function gets called you'll have enough information to know exactly what keys has been pressed. Then you should just update the string value.
Or, at least, that's the way I'd do it.