We Love Privacy Club

lyse.isobeef.org

↳ In-reply-to » The original twt is unavailable. It may have been edited or deleted, or is from an unknown or muted feed.

What have you been up to, @kiwu@twtxt.net? Already melted in this brutal heat?

In light of recent events, check out your mentions. :-)

⤋ Read More

slashdot

feeds.twtxt.net

Sat 1, 5:00AM (6d ago)

New Google Earth AI Tool Could Fuel Misinformation, Experts Say
Google has integrated its Nano Banana 2 image generator into Google Earth, allowing users to place AI-generated events and objects onto real satellite imagery. The company says its AI-generated images contain invisible watermarks detectable through Gemini or Lens, but the BBC found those safeguards and some third-party detection tools can be fooled … ⌘ Read more

⤋ Read More

slashdot

feeds.twtxt.net

Tue, Jul 28 5:00PM (1w ago)

Earth’s Biggest Disasters Strike In a Hidden Pattern Every 27 Million Years
A new analysis of 89 major geological events over the past 260 million years found evidence that mass extinctions, volcanic eruptions, ocean crises, and other upheavals may cluster around a roughly 27.5-million-year cycle. The cause remains unknown, with possibilities ranging from mantle activity and orbital changes to spe … ⌘ Read more

⤋ Read More

phoronix

feeds.twtxt.net

Sat, Jul 25 7:00AM (1w ago)

AMD ROCm Committed To Six Week Release Cycle Moving Forward
One of many interesting takeaways from this week’s AMD Advancing AI event in San Francisco was word that ROCm will be on a rigid six week release cycle moving forward… ⌘ Read more

⤋ Read More

phoronix

feeds.twtxt.net

Fri, Jul 24 10:14PM (2w ago)

AMD Advancing AI 2026: Open, Open-Source & More Open-Source
At this week’s AMD Advancing AI 2026 event, “AI” was mentioned thousands of times in talks and in demos. As expected. Beyond that, the other term likely most heard during the event was “open”… Not particularly new for AMD with their long history of open-source efforts but I’d wager at this year’s AMD Advancing AI 2026 event they were more acutely bringing up open-source, open ecosystems, and open standards. Certainly seemed like an uptick in “open” men … ⌘ Read more

⤋ Read More

phoronix

feeds.twtxt.net

Thu, Jul 23 9:58PM (2w ago)

Ryzen AI Software 1.8 Released With New Model Support, More Optimizations
Ahead of Lisa Su’s keynote this morning at the AMD Advancing AI event, tagged on GitHub just now was the Ryzen AI Software 1.8 release for helping to deploy AI models on Ryzen AI PCs… ⌘ Read more

⤋ Read More

phoronix

feeds.twtxt.net

Thu, Jul 23 8:35AM (2w ago)

Lemonade 11.5 Local AI Server Released With Completed Lemonade Router
Just one week after releasing Lemonade 11.0, the Lemonade 11.5 local AI server was released today for this open-source AMD backed project during their AMD Advancing AI event… ⌘ Read more

⤋ Read More

lyse

lyse.isobeef.org

Tue, Jul 14 7:00AM (3w ago)

Hurray, I can now press gg instead of g to go to the top in tt. Much better! :-) Other multi-key combinations are also easily possible now.

I should probably write a real article about this at some point, but here we go. The only downside with my new key binding system is that it breaks tview’s established pattern. You’ve got an InputHandler(), that is implemented using WrapInputHandler(…). It typically then directly implements the switching logic depending on the key press. Something like this:

func (w *Widget) InputHandler() func(event *tcell.EventKey, setFocus func(p tview.Primitive)) {
    // WrapInputHandler allows for intercepting key events with SetInputCapture(…)
    // from the outside for customization. This handles the default key bindings.
    return t.WrapInputHandler(func(event *tcell.EventKey, setFocus func(p tview.Primitive)) {
        switch event.Key() {
        case tcell.KeyRune:
            if event.Modifiers() == tcell.ModNone {
                switch event.Rune() {
                case 'k':
                    w.scrollUp()
                    return // we already handled the event, stop processing

                case 'j':
                    w.scrollDown()
                    return
                }
            }
        }

        // We didn't handle the key event. Maybe the parent
        // widget knows what to do with it.
        if handler := w.parent.InputHandler(); handler != nil {
            handler(event, setFocus)
        }
    })
}

From the outside, you can intercept and either stop or continue the widget’s original key handling with a potentially rewritten key event using SetInputCapture(…):

w := NewWidget()
// customized or additional key bindings
w.SetInputCapture(func(event *tcell.EventKey) *tcell.EventKey {
    switch event.Key() {
    case tcell.KeyUp:
        // Rewrite the event, so the "cursor up" key is an alias
        // for the vim key binding "k", that is handled by the
        // wrapped input handler above. (I know, I know, this is a
        // completely unrealistic example, why would anyone use
        // cursor keys when there are vim key bindings available?!)
        return tcell.NewEventKey(tcell.KeyRune, 'k', tcell.ModNone)

    case tcell.KeyRune:
        if event.Modifiers() == tcell.ModNone {
            switch event.Rune() {
                case 'q':
                    app.Stop()
                    // we already handled the event, do not pass it
                    // to the wrapped input handler above
                    return nil

                case 'r':
                    toggleMessageReadStatus()
                    return nil
            }
        }
    }

    // we didn't handle the event, pass it to the wrapped
    // input handler above
    return event
}

Since they all expect a single key, I’ve noticed that using multiple dedicated KeyBindings of mine on these different levels kinda breaks multi-key handling with common prefixes. The outer-most KeyBinding captures the prefix, but it can’t transfer it to the inner one if not handled by the outer one. At least not without some more (potentially ugly) changes. So, I now have to work with just a single KeyBindings object for the entire widget chain (if it consists of multiple other widgets or the regular input handler and input capture are in the game). The outside needs to register all its key bind customizations or extensions at the same level that the original widget handles its default ones. Doable by exposing the widget’s KeyBindings instance, but not pretty. You always have to keep this in mind.

With the KeyBindings, it will look like that:

type Widget struct {
    parent tview.Primitive

    // make it available to children or the outside either by
    // direct field access or by providing a getter method
    KeyBindings *bind.KeyBindings
}

func NewWidget() *Widget {
    w := &Widget{KeyBindings: &bind.KeyBindings{}}
    w.KeyBindings. // default key bindings
        Bind0(bind.KeySequence('k', w.scrollUp).
        Bind0(bind.KeySequence('j', w.scrollDown)
    return w
}

func (w *Widget) InputHandler() InputHandler() func(event *tcell.EventKey, setFocus func(p tview.Primitive)) {
    return t.WrapInputHandler(func(event *tcell.EventKey, setFocus func(p tview.Primitive)) {
        // also note the missing support for focus transfer at the moment
        event = w.KeyBindings.Capture(event)
        if event == nil {
            return
        }

        if handler := w.parent.InputHandler(); handler != nil {
            handler(event, setFocus)
        }
    }
}

And then from the outside, or in a child widget:

w := NewWidget()
w.KeyBindings. // additional or customized key bindings
    Bind1(bind.KeySequence(tcell.KeyUp), func(*tcell.EventKey) *tcell.EventKey {
        return tcell.NewEventKey(tcell.KeyRune, 'k', tcell.ModNone)
    }).
    Bind0(bind.KeySequence('q'), app.Stop).
    Bind0(bind.KeySequence('r'), toggleMessageReadStatus)

When directly working with tview primitives that are not part of custom widget implementations, the following works well so far:

textView := tview.NewTextView().
    SetWordWrap(true).
    SetText("…")
    SetScrollable(true)
textView.SetInputCapture((&bind.KeyBindings{}).
    Bind0(bind.KeySequence('q'), app.Stop).
    Bind1(bind.KeySequence('g', 'g'), func(*tcell.EventKey) *tcell.EventKey {
        return tcell.NewEventKey(tcell.KeyHome, 0, tcell.ModNone)
    }).
    Capture)

I need to sleep on this some more.

Also, writing very long messages like this one is really not all that fun in tt’s editor. I should absolutely provide a way to shell out to vim.

(Took me about one and a half hours to compose, holy crap. But not only because of not using vim. Although, that might have saved me a quarter hour or so for sure. Proof-reading this message also uncovered quite a few bugs in my real documentation. So, that’s a big win!) Good night!

⤋ Read More

lyse

lyse.isobeef.org

Sun, Jun 28 7:00AM (5w ago)

↳ In-reply-to » I went to check on the fireflies this season. But I didn't see any. Instead lots of moths. At first, I thought it might have been still too light, but it was already dark enough for me to miss and destroy a snail shell. Bummer. Maybe it was too wet tonight. Although, it's probably just another or two weeks until my glowing friends will finally show up.

The firefly season is ending. I only saw 200 of them or so. There was one female directly on the forest road. If only I brought my camera and tripod, that would have worked out I reckon. I had my torch with me and this looked really cool.

Dusk took forever today. It was really long light out there. Full moon is tomorrow.

On the way back, there was suddenly a load clatter and crashing sound 100 meters away from me. I didn’t see anything, but a tree fell over in the forest out of the blue. Fuck me dead, that was scary as hell. Luckily, I was already on the main road, only meadows around me. It’s the second time I witnessed a tree accidentally coming down. The first one was during the most expensive hail storm in our area so far in 2011 behind me when setting up a summer camp. The weather changed in less than 15 minutes.

Maybe not such a good idea to go out so late alone. :-? Any rustling in the forest immediately reminded me of the boar the other day. Luckily, always false alarm. Still a bit terrified from that event.

⤋ Read More

movq

www.uninformativ.de

Sat, Jun 27 7:52PM (5w ago)

↳ In-reply-to » I complain about this a lot:

Ah, with lazy loading, browsers only start loading images when the load event occurs. And that takes time. Hm. Not a fan, I might revert this. 🤔

⤋ Read More

slashdot

feeds.twtxt.net

Fri, Jun 26 5:00PM (6w ago)

‘Fingerprints’ of Black Hole’s Event Horizon Detected For First Time
Researchers say they detected the first gravitational-wave “fingerprints” of a black hole’s event horizon by analyzing the final moments of the powerful GW250114 merger. The findings support Einstein’s general relativity and may eventually help probe frame dragging and quantum fluctuations near black holes. Phys.org reports: For the new r … ⌘ Read more

⤋ Read More

phoronix

feeds.twtxt.net

Mon, Jun 22 10:37AM (6w ago)

Early AMD GCN GPUs Seeing Improved GPU Recovery - Another Valve-Led Linux Improvement
Early AMD Radeon Graphics Core Next “GCN” GPUs are seeing work to improve the GPU recovery process in the event of hangs. This work is yet another improvement for older AMD GPUs being led by Valve’s open-source Linux graphics driver team… ⌘ Read more

⤋ Read More

lyse

lyse.isobeef.org

Thu, Jun 18 1:15AM (7w ago)

In the light of current events, I will first consult my pillow and only then write an article about readable code.

⤋ Read More

slashdot

feeds.twtxt.net

Wed, Jun 17 1:30PM (7w ago)

HPE Tempts VMware Users, Partners With Year of Free Virtualization Software
An anonymous reader quotes a report from Ars Technica: Hewlett Packard Enterprise’s (HPE) new virtualization software promotion will likely pique the interest of end users and resellers who are unhappy with Broadcom’s pricing of VMware. During its HPE Discover event in Las Vegas this week, HPE announced that customers could u … ⌘ Read more

⤋ Read More

movq

www.uninformativ.de

Sun, Jun 14 4:06AM (7w ago)

↳ In-reply-to » Every now and then, I think that I have carefully proof-read my message enough times and hit the "Add message" button in tt. But then, in the message tree, I spot another missed typo. My process is then to go to my twtxt.txt and fix it by hand. However, I still have to clean up tt's cache. This is rather tidious:

@lyse@lyse.isobeef.org

Now I’m curious how movwin deals with that. ;-)

Focus handling? I hardly remember, lol. 😅 Did that 6 months ago and haven’t touched it since. Let’s see.

The core main loop gets keyboard/mouse events from curses. At this level, the main loop only knows about exactly one widget, so it passes the event to that widget (whatever that is, doesn’t matter – they all inherit from the Widget base class, it could be a Window, a WindowManager, or an Edit box directly).

The outermost widget is usually a WindowManager. It implements a few hotkeys of its own, like switching to another window. If none of those hotkeys match, it passes the event to the currently focused window.

Same story here: Window implements some hotkeys (like opening the menu bar). If none of those match, then … the magic happens.

Each Window acts as a focus manager. It can descend into its child widget hierarchy and collect all child widgets in a depth-first search. They are collected into a flat list. Each Window then has an attribute _focus_position, which is an index into that list. Pressing Tab or Shift+Tab increases or decreases that index and that allows you to select the next/previous focusable widget in the current window.

Eventually, Window passes the input event to the currently focused widget.

Usually on initialization, the application can ask a Window object to focus a certain widget. The file selection dialog does that, for example, because the “natural” focus order would be to focus the Edit box at the top of the window first – but that’s not what the user wants, the Table showing the list of files should be focused.

If no widget ever feels responsible for handling a certain input event, then there’s a global unhandled_input callback that the application can provide (same as in urwid).

I think that’s it.

Hm, that’s more complicated than I remembered, but apparently it works fine, because I completely forgot about this. 😅 All I did in the last few months was make new classes that inherit from Widget, like the new Table class or Edit or HexEdit or whatever, and if they want to get input events, then they must implement the methods input_key() or input_mouse().

Does this answer your question? 😅 (I admit that I didn’t exactly understand your scenario, so I just went ahead and rambled about my implementation. 😅)

⤋ Read More

Searching We Love Privacy Club