Developers 

After thinking some days about how to tackle the 4.x => 5.x transition in Kate (KTextEditor/Part/Application) and the nice “what we should do” blog by Dominik, I think the time for fun is there.

Therefore I started to port our stuff to KF5 in the “frameworks” branch.

The basic idea would be: get it compiling and running.

Then we can decide if the frameworks branch is a mere “hack to see if it works” experiment which can be later used to port master without a lot of work or if we say “ok, works kind of well” and we just switch development over for new features from master to frameworks and with that from 4.x to 5.x.

Kate in 4.13 will have a new features: Animated bracket matching!

Since the feature might be visually distracting, it is turned off by default. To enable this feature, you have to go into the “Appearance” config page and check “[x] Animate bracket matching.” Due to feature and message freeze, this feature will be available in 4.13 and not in 4.12.

Kate has this nifty little plugin called “XML Completion.” This plugin loads a Meta DTD file and uses this information for context sensitive completion. To use it, you first have to load it in the settings dialog, and then assign a Meta DTD through the XML menu:

In our example, we work on a Kate XML highlighting definition file and therefore loaded the file “language.dtd.xml” which is shipped with Kate. Having assigned a Meta DTD file, we now have these nice code hints:

Right after the vim blog and the ‘what’s new in 4.11‘ blog we have another feature that was long requested and finally is available in 4.12: Multi-line editing in block selection mode.

Needless to say that it also supports undo/redo and pasting text. Kudos go to Andrey Matveyakin for implementing it!

Hi,

if you ever use the TBB (Intel Threading Building Blocks) allocator to overwrite malloc/free/* and want to use Valgrind for leak checking and fail, here is the simple trick to get it working:

valgrind --soname-synonyms=somalloc=\*tbbmalloc\* <your-application-here>

I missed that hint in the Valgrind documentation for my first tries ;)

Btw., the scalable allocator from TBB is a really BIG improvement over the normal system allocator on current Linux & Windows machines if you allocate mostly fixed size small object, like what happens if you heavily use STL data structures like std::map/set that are implemented as trees and you have other stuff like DOM/AST like data structures (even in the single threaded case, for which it just saves a LOT of memory).

In my job I work on binary and source level analysis software running on Linux and Windows. One of my tasks is to maintain the build farm and compile environment, therefore I am responsible for keeping care of the compilers and libraries we use (like the beloved Qt, congratulations for the nice 5.1 release, btw.).

For Linux, we normally use the GNU C/C++ compiler. That works out very well since years. We have hit compiler bugs only a few times and there was always already some patch-release out in the wild that fixed our issues. In addition the GCC developers brought a constant stream of improvements in the area of C and C++ standard compliance. I am more than happy with the GCC quality.

I’m currently using QUndoStack in a project of mine. A QUndoStack contains a list of QUndoCommands which then can be executed with QUndoStack::undo() and QUndoStack:.redo().

Now I thought when deleting an instance of the class Node, I can just hock the creation of the respective UndoDeleteNode class (derived from QUndoCommand) into the destructor, like this:

class Node {
public:
  // ...
  ~Node() {
    undoStack()->push(new UndoDeleteNode(this));
  }
};
class UndoDeleteNode : public QUndoCommand {
public:
// ...
void undo() {
// create node again
}
void redo() {
// delete node again
}
};</pr

                
                
                  Read More