krfkeith / enough Goto Github PK

Some widgets perform calculations on their children. For example,
GraphWidget in Graphui re-sizes the text in node widgets so that all nodes
will have a uniform text size. For optimization, it would be good to know
if a node widget has changed in a way that changed it's text size.

I want to change Widget.py:

    def update(self):
        if self.cache_enabled:
            new_inputs = self.cache_inputs()
            if self._prev_cache_inputs == new_inputs:
                return
            self._prev_cache_inputs = new_inputs
        self._cached_surface = None
        self._update()

Instead of this, I want to define a method: 
def NeedsUpdate():
    if self.cache_enabled:
        new_inputs = self.cache_inputs()
        if self._prev_cache_inputs == new_inputs:
            return False
    return True

The repo is now >40MB and the working tree is >10MB

Almost all of that space is taken by large binary blobs like movies and fonts.
Remove them from working tree.

Try to remove them from repository retroactively somehow, too.

Currently its monkey-patched into loop, but that's retarded.

Find a better place to put globals, and put browser there.
loop should probably sit in browser (instead of vice versa).

Passing browser around everywhere is not an option because there's way too
much code around that will have self.browser = browser boilerplate because
of it.

OverlayWidget puts itself in the global loop.overlayed_widgets

Noam knows what to do

1. Color the completions somehow based on what puts them in there.
2. ?
3. Profit

Consider nf Animator design and alternatives.

Currently Box.py is a BoxWidget
Other stuff are named with Widget.
Find a consistent naming scheme and rename everything according to it.

Its not really a cache, it enables stuff like transparency/etc, but also
usable as a cache.

The current code is incorrect - nodes and edges know their own position.
The new design means that Mousemap is like Keymap, and you can chain them
where each one maps relative positions.

We need to discuss how this is going to be implemented, including how the
relative positions will be known (because they can change all the time, do
we pass a get_position func like the get_text in TextEdit?)

Currently lots of widgets use an empty spacer (Spacer((0, 0))) as a null
widget. Each of them typically creates his own instance as a class member.

Create a shared global enough.gui.null_widget.null_widget and have all
those that use spacer use it.

Graphui currently uses dot's "plain" output to know what dot wants.
If we will use the xdot we will be able to:
1. know the text size of node and edge labels - currently we guess the text
size for nodes according to the node size, and we have no idea about the
edge text size.
2. import/export dot files - because we are going to parse xdot we will be
able to import existing DOT files. Also we might as well generate it too
and we will be able to export to DOT files.

Summary says it all.
This does NOT include tests for livec/graphui which should be done seperately.

Currently there is no way to define multiple keymaps with priorities.

Maybe we want to have KeymapNode that only has children and KeymapLeaf that
only has registrations, or maybe we want to have pre/post children, or
whatever.

But we do want to be able to have multiple keymaps active at the same time
that do not necessarily form a "chain".

Requires some thought.

Use case:
CompletionWidget wants to have a normal text edit (with its normal keymap)
active, while allowing extra keymaps (that choose between completions and
disambiguations) to be active at the same time.

just write the page

Other Box attributes are stored in the class/subclass.

The idea is to tell the user that the key exists, just not enabled right
now, and why.

Maybe it should be used only in some places, and not others. For example,
Boxes should probably unregister and not disable as to allow other boxes to
take the key. In that case no disable explanation will help.

Maybe disable should still steal the key but not use it. Where disabling is
used to make keys behave consistently and not depend too much on mode,
while also have the reason a key is not working shown somewhere.

Code:

        new_target = self.next_keymap.next
        self.next_keymap = next_keymap

        if next_keymap is not None:
            if self.is_active:
                # Warning: May re-enter!
                next_keymap.activate()

        # Recursively re-try in case the new target was changed by a
        # re-entrant next_keymap.activate() call.
        self.set_next_keymap(new_target)


Why is self.set_next_keymap(new_target) used on new_target, rather than
whatever re-entrantly set by next_keymap.activate() ?

Source control exists for this purpose.
No redundant files should be held.

Keymap is the only obs_dict so far, and it has remove_item, add_item, and
replace_item.

It only contains a lot of WidgetMaker's now.

Perhaps it should also be split into the WidgetMaker base-class, and the
set of widget makers (Declaration, Normal, etc) for the current style we
use. If we do create a new style of presentation for C, it will be done via
an alternate WidgetMaker subclass.

Run test_completion.py
1. Enter the completion widget edit mode
2. Start typing a word that has completion, prefferably long word.
3. WHILE THE WORD IS STILL PARTIALLY COMPLETED (not fully) - press escape.

Expected:
the completion widget should show only the part of the word i have typed.

Encountered/Bug:
The letters I did not type yet still appear, probably because the
completion widget changed size and nobody is painting over those letters
anymore.

To avoid naming conflicts between imports, its recommended to use Python
abs imports (from enough.... import, rather than importing sibling modules).

Need to convert all of the relative imports to "from enough..." based ones.

Depends: Branch "enough-package".

Describe the main ideas associated with each of the BuzzWords