blobject / goose Goto Github PK

Implement a full cycle of key input -> behavior.

Implement key mapping.

Define representations of:

• windows
• frames
• tags
• marks
• rules: new, snapping
• selection: what to focus (and to occlude), where to move, to what to adhere
• adhesion: tab, pile, concat
• occlusion: overlapping, hiding, visibility transition
• focus: changes in look, showing of name, index, position, order, input, output, frame, view
• transition: focus, visibility

Decouple the data to be represented and the representation itself, so that other gui clients (eg. tk) can jump in and consume the data. But some representations will have to be drawn by the server natively, eg. borders around windows/frames and indications of adhesion.

• Write a minimal config in tcl (maybe with stub external functions and api)
  • Decide on what to include in the config
• Start writing goose
  • Decide whether to adopt another project as a template
  • Decide what language to use
  • Try to include logging, init'ing, config'ing
• Start writing a layer that goes between tcl and goose proper/core/base/server

Need a basic architectural plan of the large components of goose.

Implement a window object, frame object, all-containing object.

Implement structures and mechanisms that allow logical manipulation of window objects.

Per window: global index, frame index, name, abs/rel position, focus, etc.

Per frame: index, abs/rel position, focus, tags, marks, etc.

Root: structuring as binary tree, as spatial tree, as stack, as graph

Rules:

• create, modify, delete
• position, order
• of windows, of frames, of root

Window-frame correspondence and switching logic

Brainstorm various and expected workflows.

• single tag, single frame, single window
• single tag, many frames, many windows
• many tags, many frames, many windows
• devel: one or two tags; one, two, or several frames; many potential windows
• single main window; many potential tags, frames, windows
• gaming/media: single tag, fullscreen window
• dialogs, popups, notifications

Define overall feel/theme of usage.

• keyboard and/or mouse oriented
  • keymap definition, mouse combos and gestures, key/mouse combos
• functionalities are builtin configurables and/or scripted appendages
• fixed layouts with presets and rules and/or dynamically set layouts and/or free do-whatever-tf layouts
• how configuring, customising, executing are done
• how new windows are open (processes are forked)
• tcl scripting, support arbitrary languages

Define elements of control and viewing.

Implement graphical rendering of state via wayland/opengl.

I can't build goose from source because of the obsolete dependency on wlr/backend/noop.h

./include/goose.h:7:10: fatal error: 'wlr/backend/noop.h' file not found
    7 | #include <wlr/backend/noop.h>
      |          ^~~~~~~~~~~~~~~~~~~~
1 error generated.
make: *** [makefile:56: goose] Error 1

Define the communication protocol.

List configurables, doables, gets, sets.

Implement tcl namespace and commands.

Implement a component that spits out info, warning, and/or debug messages produced by the server.

Implement a configuration object aware of different sources (hardcoded default, commandline option, file, ipc)