GitLab

* migrating to Linux for debugging

Ivica Bukvic authored Sep 20, 2020 and Albert Gräf committed Sep 22, 2020

Broken implementation of grab focus improvement (to be migrated to linux because Windoze debugging is a joke)

Ivica Bukvic authored Sep 18, 2020 and Albert Gräf committed Sep 22, 2020

* Fun to know that canvas_key is called even when you are not inside a canvas...

Ivica Bukvic authored Sep 18, 2020 and Albert Gräf committed Sep 22, 2020

* This means an object has requested exclusive focus

Instead of casting a magic number to a pointer, which is a sure recipe
for disaster, provide a properly initialized dummy t_canvasenvironment*
pointing to static storage.

* This was caused by the improvement in the scrolling algorithm earlier this summer to throttle down getscroll calls invoked by arrays that resulted in CPU intensive redraws. As it turns out, the same also up until this patch prevented the following from working properly:

1. select text object and displace it by dragging using a mouse until it goes partially outside the canvas edge

2. the object is activated at a location before getscroll changes the viewport settings to ideally fit everything within the window

3. getscroll is called and everything is relocated except the activated box because its current implementation is oblivious to the changes in canvas positioning.

4. as a result the activated box does not match the actual object position.

* The new patch addresses this by introducing a synchronous scroll request that has no delays and executes immediately, thereby completing canvas relocation before the activated box is drawn. Due to its potential to be misused causing high CPU usage, this call is currently reserved only for this special case.

* LATER: consider ensuring that activated boxes are also relocated on getscroll, so that in the case of scripted changes to the viewport activated boxes remain in a correct place. Even so, this should not be seen as a workaround but as a feature that may prove useful in other contexts. So, the solution is to have both this patch and this other thing eventually implemented.

add an alert system that notifies the user of the existence of unsaved edited instances of the abstraction he is editing or about to edit

In one fell swoop, this solves all usability issues we have with the
Ctrl key we currently employ for that purpose, which interferes with all
our menu keybindings, and makes temporary run mode unusable on the Mac.

Make Ctrl+F work if the canvas is in edit mode. In this case,
canvas_key(), upon receiving the Ctrl keydown event from the Ctrl+F
shortcut, temporarily switches to run mode, but never gets the
corresponding keyup event which goes to the findbox, so temporary run
mode remains in effect when the findbox opens.

This shouldn't actually be much of a problem, but the real trouble is
that while canvas_key() informs the GUI about the change to run mode, it
doesn't update the state of the canvas-local gl_edit variable
accordingly. So when dofind() switches on edit mode later, the engine
still thinks that it's in edit mode and thus doesn't trigger the
necessary update.

The easy fix is to just update gl_edit in canvas_key() when edit mode is
temporarily disabled.

This gets rid of some race conditions in the find operation, by ensuring
that edit mode is only updated *after* mapping a subpatch window.

This bug manifested itself when searching for objects in subpatches
which are not visible at the time the find operation gets invoked. In
this case, on the GUI side we both have to create the subpatch window
and put it in edit mode. In the previous implementation these two
operations would be executed separately and asynchronously. The end
result was that usually the latter operation setting the edit mode in
the GUI would win out, and the edit mode would later get overwritten
again when the window was created.

We fixed that race condition by ensuring that the engine is queried for
its current edit mode status after creating a canvas window. The engine
replies with a call to gui_canvas_set_editmode() in the GUI and thus the
edit mode in the GUI now properly reflects the status in the engine
after a window is mapped.

TL;DR: This fix should now make sure that edit mode on the GUI side
reflects that of the engine at all times.

This makes Ctrl+F work again, by making sure that edit mode is set
correctly in the GUI even if glob_ctrl is set (because the Ctrl key up
event goes to the find box and is thus is never received by the canvas).

Albert Gräf authored Sep 01, 2020 and Albert Gräf committed Sep 09, 2020

This is useful, in particular, to print out pointer values with the
%zx specifier, since it prevents the annoying format warnings when
using %zx with t_int.

Ivica Bukvic authored Aug 31, 2020 and Albert Gräf committed Sep 06, 2020

* Created new and hopefully improved dialogs that should work on all
  three OSs. These include improved margins, optimal sizes that account
  for OS-specific idiosyncrasies, use of non-native toplevel window
  titlebars that cause bunch of issues (e.g. ability to maximize a
  dialog window since nw.js, at least in the earlier versions, has
  spotty support for disabling those), fixed window sizes with minimal
  scrollbars where appropriate, proper spacing between items, better
  positioning of the checkbox and radio buttons, etc.

* Enabled CTRL+W for the search dialog.

* Improved and consistent find bar appearance on all windows (console,
  patch, search).

* Refined activated box to match different zoom levels and font
  sizes. Small discrepancies still exist when using both custom fonts
  and zoom levels, but these are now no more than pixel off, whereas
  before it was all over the place.

* Made sure that patch windows on all OSs are exactly the same size,
  even when using custom zoom levels and fonts.

* Replaced the use of the legacy font menu with the native sub-menu and
  adjusted its behavior accordingly, including updating its values at
  patch open (the same method may prove useful in dealing with the
  undo/redo and other options not being registered properly because they
  may be running before the menu has been created).

* Refined the scrollbar behavior by providing a grab cursor when
  hovering and clicking on them. Also added dynamic updates to scrollbar
  colors (normal, hover, and click).

* Epic hack for making message boxes consistent size when activated.

* Made redrect on a GOP subpatch appear and disappear intelligently when
  dealing with subpatches populated exclusively with scalars. For
  instance, creating an empty object does not create a redrect yet
  because the user may be instantiating another instance of a
  scalar (e.g. a pony). However, once a non-data object has been created
  that wants to be displayed on the parent window inside GOP of the
  subpatch it is a part of, it toggles on. Similarly, once every
  non-scalar object has been deleted, the redrect disappears. There is
  still a lingering question why would one want to do this, but hey, who
  am I to judge?

* Fixed problem where a non-GOP text object got diagonal and y resize
  arrows that triggered consistency check.

* Fixed consistency check where resizing a GOP on the parent window
  using bottom-right corner cursor hotspots, triggered an error when the
  subpatch is also open. Now, everything resizes as it should
  concurrently, regardless of whether this is done on the subpatch or
  the parent window. As a bonus, the properties window reflects changed
  values regardless how they are being changed.

* Better iemgui number2 text offset across different font sizes and zoom
  levels.

* I think that is about it, although I may have missed something...

add mechanism that visually marks abstraction objects that are edited but unsaved, and all their ancestors

get rid of some compiler warnings introduced by the two new features (incompatible pointer type and implicit declaration)

add [abdefs] object (methods: get, instances, del, clean) with an interactive dialog, add new element type for dialog_external

add warning for when there are more than two instances of the same abstraction (file-based and [ab]) being edited, fix for dirty visual markings

return a dummy object when creating [ab] objects during ab definitions loading, to prevent creation errors from being displayed. show the cycle that is causing the dependency problem when an ab object cannot to create