June 24, 2020News, OGG, Podcast

mintCast 337.5 – Managing the Managers

In our Innards section, we manage windows.

And finally, some feedback and a few suggestions

Window Managers

Types of Window Managers

Compositing

As the name implies, a compositor composes how the window looks and functions. It does this by using an off-screen buffer for each window. Each buffer is made into an image. The compositor uses those images for drawing and re-drawing of the windows, also for when it is moved or resized or closed. Windows can overlap or ‘stack over’ one another. Each window is drawn and redrawn individually, along with the desktop wallpaper image. Compositing also uses those buffer images to allow for 2D and 3D effects such as Blending, Fading, Scaling, Rotation, Bending, Contortion and Blurring, etc.

Examples would be the wobbly windows effect in the KWin Window Manager in KDE Plasma, or the ALT-TAB display of open windows (Flip Switch, Cover Switch, etc.), or the appearance of a window sliding in and out or slowly fading in and out when it is opened, closed or minimized.

One of my favorite effects is Shade, sometimes referred to as Roll Up. When that feature is used, the window is reduced to only the title bar being visible. This was very useful back in the 90’s and early 2000’s due to the small sizes of the monitors then; you could keep the application on the screen but it took up much less space. KWin among others support this feature.

Here is a brief list of Compositing Window Managers.

Compiz
KWin (used in KDE Plasma)
Metacity (Used in GNOME 2.2)
Mutter (Used in GNOME 3.x)
Xfwm (used in Xfce)
Enlightenment (aka E)

Some notable history of the above listed Window Managers:

Compiz – The first version of Compiz was released by Novell in 2006 who acquired SUSE 3 year prior to that. It is currently maintained by Canonical who also maintains the Ubuntu Linux Distribution.

Kwin – Compositing support was added in version 4.0.

Metacity – GNOME 2.2 used Metacity as the Window Manager.

Mutter – Mutter replaced Metacity in GNOME 3.0. Mutter added OpenGL rendering support instead of GTK+ Rendering that Matacity used. In January of 2012 Mutter was forked to create Muffin. Version 1.2 of Cinnamon used Muffin as its Window Manager.

Xfwm – It was forked from FVWM in 1997. In version 2 of Xfce in 1998 it became the default Window Manager. Adoption of Xfce into distributions was rocky until version 3. This was because of the XForms Toolkit that was used to create it, was proprietary software. Both Redhat and Debian rejected its use for that reason. Though Debian did allow version 2 in their Contrib Repository. Xforms is where Xfce gets its name from, “XForms Common Environment”. In order to remove Xforms, a complete rewrite using GTK in 1999. It was then licensed under the GPL allowing distributions to include it, and version 4.2 added support for compositing. The letters in Xfce no longer mean anything.

Enlightenment – Rasterman (Carsten Haitzler) Forked FVWM in 1996. He then based E on that source code in the same year. E started as a Compositing Window Manager. It was commonly used as the Compositor for GNOME 1.0 . Version 0.17 of E was in development for 12 years starting in December of 2000. It was a complete rewrite of E16. Once E17 was released. It was able to be considered a Desktop Environment using E as the Compositor and the new Enlightenment Foundation Libraries (EFL). Bodhi Linux used E17 as a base but forked it to create the Moksha Desktop. E16 is still in active development and is independent of E17.

As a side note. Microsoft Windows also uses a form of Compositing called Desktop Window Manager. It is used in Windows Vista through to Windows 10. Apple’s macOS also uses a compositor called Quartz. During the mid 1980’s Commodore’s Amiga OS used one called Intuition.

Stacking

Stacking Window Managers (aka Floating Window Managers) are very similar to Compositing Window Managers. The differences are in how the windows are drawn or re-drawn. The windows are drawn in a specific order allowing them to overlap or ‘stack’. It is done by starting with the desktop. Then proceeds to draw each window from back to front until the foreground window is drawn. When there are many windows open. The redrawing process can be slow. Background windows when brought to the foreground window. Will be redrawn and any windows that were covered will also be re-drawn. Other requests for being redrawn is when a window has new content to display. Some Window Managers are able to detect when a window needs redrawn or not. An example would be a background window that is covered by other windows will not be updated. Since it can not be seen anyway. Another example is when a window is selected. If nothing changed in the arrangement of the other windows. Only that window is redrawn.

Some negative effects to stacking is when an application crashes. If it can not be updated, that window becomes static and can cause a smearing effect to the other windows when they are moved. Even if an application has not crashed, moving a window in a fast motion can cause a blurring or smearing effect until the Window Manager can catch up and update the affected windows.

Other negative effects is that the Window Manager is limited to how much a graphics card can speed up the drawing function.

There have been some technical advancements to try to reduce these effects. Without going into detail. In some cases, if a window hasn’t needed updating but was moved, it would be required to be redrawn. A buffered image of what the other window looked like before the other window was moved will be used; that would only require one window to be re-drawn instead of two.

There are also some Hybrid Stacking Window Managers, which basically use a simple form of compositing using the graphics cards frame buffer.

Here is a brief list of Stacking Window Managers:

Blackbox
Fluxbox
IceWM
JWM
Openbox
Sawfish
FVWM
Window Maker
UWM
TWM

Some notable history of the above listed Window Managers:

Blackbox – It was created around 1997 by Bradley Hughes, who was a student in Amarillo, Texas. He just wanted to see if he could write his own. It was written in C++ using all orginal code though he was inspired by Window Maker.

Fluxbox – It is a fork of Blackbox version 0.61.1 in 2001. It added tabbed windows and a System Tray/Notification area, to name a few tools. It is used in the live cd of GParted. AntiX and Linux Mint also have used it. MX Linux has a MX-Fluxbox edition.

IceWM – IceWM was also created around 1997 by Marko Maček. It was created from scratch in C++. It can be themed to look like Windows 95, Windows XP, Windows 7 and OS/2, among others. It is used in Absolute Linux, AntiX and the light version of VectorLinux; openSUSE for Raspberry Pi also uses IceWM.

JWM – Joe’s Window Manager was created by Joe Wingbermuehle. He wrote JWM in C on his Silicon Graphics Octane desktop to replace the 4Dwm that was used as the default in Irix, which itself was created by Silicon Graphics and based on AT&T’s Unix System V.

Openbox – It is a fork of Blackbox 0.65 but was completely re-written in version 3.0 and is no longer based on any Blackbox code. It was released in 2002. It is used in LXDE, LXQt, Lubuntu and Manjaro Linux.

Sawfish – It was released in 2000. Sawfish, unlike the above Window Managers that used a standard config file, uses a Lisp-like scripting language for its code and configuration. It was originally called Sawmill but the name was changed due to another software program using that name. Sawfish was the Window Manager in GNOME 2 until the release of GNOME 2.2.

FVWM – In 1993 Robert Nation while working for the United States Department of Defense. He started a project to reduce the memory usage and adding support for virtual desktops to the Tab Window Manager. He is known for his terminal emulator, rxvt. In 1994 he handed over the maintenance of FVWM to Charles Hines. Robert’s last version was 1.24r. Charles completely overhauled the code. As a result, many distributions would offer each as a separate program due to peoples preferring one or the other. In 1997 FVWM became the Window Manager for Xfce.

Window Maker – Released in 1997, Window Maker contains code from FVWM and was created to emulate NeXTSTEP OS. It is said that using Window Maker is the closest you can come to using NeXSTEP OS without actually being on a NeXSTEP computer. As a side note, NeXTSTEP OS was created by NeXT Computer who was started by Steve Jobs (Co-Founder of Apple). He was forced out of Apple in 1985. In 1997 Apple bought NeXT and shortly thereafter named Jobs the interim CEO and eventually CEO of Apple once again. When Apple needed to replace the Classic Mac OS in 1999, they open sourced NeXTSTEP version 4 to create Darwin. With some code added from BSD and the Mach kernel, Darwin became OS X now known as MacOS.

UWM – In 1985 the Ultrix Window Manager was created by Digital Equipment Corporation (aka DEC) for its Ultrix Operating System. Ultrix was based on version 4.2 of BSD which, in turn, was a direct descendant of the original Unix created by AT&T’s Bell Labs Research Center. It was made the standard option in X10 Release 3 of the same year. In 1986 X version 11 was released. UWM was the only Window Manager that was ported to the new version.

TWM – Tab Window Manager was created by Tom LaStrange in 1987 and was his first X program. It was originally called Tom’s Window Manager; the name was changed when the X developers at MIT adopted it in 1989 for use in X11 Release 4. Thirty-three years later, TWM is still standard with X.org Server. It has added title bars to the windows, and also added shaped windows and icon management. By default the windows title bar only has the Resize button and the Iconify button. Iconify will reduce the window to an icon. There is no Close Window button, though one can be added via the .twmrc file. Oddly or not, the function is described as deleting a window. TWM was written on a monochrome Sun 3/50 using the vi text editor. The model 3 was a fast computer with an amazing 15.7 MHz Motorola 68020 processor and 4 MB of ram.

Other bits of trivia are:

The Xerox Alto created by Xerox PARC in 1973 was the first computer that was specifically designed to use a graphical user interface (aka GUI). The Alto used a Stacking Window Manager.

Both Microsoft and Apple used Stacking Window Managers. For Apple it was the Classic Mac OS in 1984 using the QuickDraw 2D Graphics Library; Microsoft used one in Windows 2 through Windows XP which spanned from 1987 till 2001.

GEM (Graphics Environment Engine) was created by Digital Research in 1985; it was a stacking style GUI for use on their DR DOS (similar to MS DOS) and for Atari to use on their ST series of computers. Incidentally, Digital Research also created the CP/M OS in 1974 which was similar to MS DOS. Apple sued Digital Research due to it being too similar to Mac OS. The terms of the settlement included having DRI remove the stacking capabilities.

Tiling and Dynamic

I am combining the two because Dynamic can use both Stacking and Tiling features. In some cases the stacking needs to be enabled; in other cases it is the window management features of stacking that are used.

Tiling Window Managers are completely different from the Stacking and Compositing Window Managers. The windows are mutually non-overlapping frames. It is very common to only have the frame visible, with no title bar or buttons to click. Actually, a mouse is not even used in most traditional Tiling Window Managers. By that I mean you don’t use the mouse to interact with the Window Manager, but you still use the mouse in applications. The first window is opened full screen, then the second is half of the screen. The third is one half size frame lengthwise on one side of the screen, with the two other frames splitting the other half of the screen. Once a fourth window is opened, you have 4 equally sized windows. The process of halving the screen continues.

The operation is heavily into keyboard commands. In some Tiling Window Managers, the keyboard is the only way to interact with the windows. This presents an obvious hurdle for people switching to a Tiling Window Manager. The first time you use a Tiling Window Manager is reminiscent of the Vi/VIM meme where you can’t quit Vi or VIM. If you are not familiar with that, Vi is a terminal based text editor, and Vim is an updated version of Vi. It has two modes: Command Mode (to save, cut, paste, exit, etc) and Insert Mode (to type text into the file). Unless you know how to change modes and then know the command to exit, you will be stuck in Vi/VIM forever! How is that reminiscent? You are basically presented with a similar black screen and all you have is the keyboard commands to interact with.

Like Stacking Window Managers, Tiling Window Managers date back to the early days of the original Unix OS. Xerox PARC released CEDAR in 1982, the first windowing system using a Tiled Window Manager.

Here is a brief list of Tiling and Dynamic Window Managers:

dwm
xmonad
awesome
i3
ratpoison

Some notable history of the above listed Window Managers:

dwm – Created in 2006. In order to change configuration options. You must edit the source code and re-compile. Unlike other Tiling Window Managers, dwm allows moving and resizing the windows with a mouse. It is a keyboard-driven interface. Using dmenu, you would type in an executable name, which will show matching names thus allowing you to launch that program. Its source code has been forked to create many other Tiling Window Managers, such as the Awesome Window Manager and xmonad.

xmonad – Created in 2007. It is written in Haskell, which is a functional programming language. Since it was forked from dwm, it adds per-workspace layouts, tiling reflection, state preservation, layout mirroring and per-screen status bars. xmonad also has support for GNOME: one big change is in the configuration. You modify a configuration file and reload it while the Window Manager is running.

Awesome – It was created in 2007. It would be considered a Dynamic Window Manager, as it allows for stacking windows (overlapping windows). Awesome uses the Lua Scripting Language. You can edit the config file, save changes and restart Awesome, with no need to recompile as you would with dwm. Awesome can be fully operated by way of keyboard commands. By default, a menu panel is available for you to click on with your mouse. This panel can be removed as desired. There is a keyboard command superkey + s which will show all of your commands. The superkey is the key on the left side of the keyboard between the ctrl and alt keys. Awesome is generally suggested as a person’s first dive into Tiling Window Managers.

i3 – It was created in 2009 completely from scratch. i3 supports Tiling, Stacking and Tabbed Window layouts. You configure i3 with a plain text file. Window management is controlled by the user. You can resize, split vertically or horizontally the windows. It also can use dmenu which is also used in dwm.

ratpoison – Created in 2000 by Shawn Betts. The name reflects the goal of not using the mouse; in fact you can’t use a mouse at all. It is 100% keyboard driven and has a very minimalist design, with no fancy graphics and no window decorations. All you have is a frame around the window. The thinking is, why have something to click on when you don’t use a mouse?

Most of these are good examples that show the Open Source spirit. One person creates something: other people modify it in their vision.

Questions
- For those that are unfamiliar, what is the function of a window manager? Why would someone want to use an alternate window manager in Linux Desktop?
Windows Manager vs Desktop Environment
- Window Manager – controls placement and appearance of “windows” on top of X.org (more widely used in Linux compared to XFree86) X-windows implementation. Can be very barebones or more featureful.
- Desktop Environment – Builds on top of a Window Manager and includes a more robust user experience from setup, tuning, hardware management/integration, file and network utilities, etc.
Display Managers – What controls the login to your choice of Window Manager or Desktop Environment. Handles the transition from startup to account login, executing X.org and launching Window Manager or Desktop Environment.
Window Manager Examples:
- Twm – tab window manager – very very basic, used to be default in most distributions when you fired up X for the first time without any further configuration.
  - Used to be packaged with X.org and probably is an optional xorg package
- Blackbox, Openbox, Fluxbox – Both openbox and fluxbox forked from blackbox.
  - Blackbox: This fork is most up to date https://github.com/bbidulock/blackboxwm
  - Fluxbox: http://fluxbox.org
  - Openbox is used in LXDE and LXQt – http://openbox.org/wiki/Main_Page
- Icewm – Ice Window Manager – https://ice-wm.org/
- WindowMaker – Derived from GNUStep https://www.windowmaker.org/
- FVWM – https://github.com/fvwmorg/fvwm3
- Compiz – http://www.compiz.org/ hit the heights of popularity for it’s OpenGL effects.
- Awesome – tiling window manager https://awesomewm.org/
- Ratpoison – tiling window manager https://www.nongnu.org/ratpoison/
- SawFish – Used to be Gnome’s Windowmanager
- KWin – KDE Plasma window manager https://userbase.kde.org/KWin
- GnomeShell – Gnome’s window manager maybe https://wiki.gnome.org/Projects/GnomeShell
Desktop Environment
- Gnome – https://www.gnome.org/
- KDE Plasma – https://kde.org/plasma-desktop
- XFCE – http://xfce.org
- Cinnamon – https://github.com/linuxmint/Cinnamon Gnome 2 inspired but forked from Gnome 3.
- Enlightenment – Straddles the line http://www.enlightenment.org/
- Mate – Another Gnome 2 inspired DE https://mate-desktop.org/
- Unity – Ubuntu’s default DE until replaced by Gnome.
Leo
- Seems to me the biggest difference between full desktop managers, floating window managers and tiling window managers is the amount the user is willing to interact with the mouse.
  - Thoughts?
- I’ve been getting the hang of using the tiling WM i3 by way of Regolith.
- There is a steep learning curve at the beginning. Once you have the important hotkeys memorized, things get way better. Cheat sheets help, but the speed doesn’t come till you have them down.

Removing i3-gaps gaps to give yourself more screen real estate. Especially handy for laptops with lower resolutions.

VIBRATIONS FROM THE ETHER:

Jack

https://www.ostechnix.com/how-to-rename-multiple-files-at-once-in-linux/

Michael
Caramale on Twitter

CHECK THIS OUT!

Dale

Eye strain can be very painful and irritating. What I use is Redshift. It is available for most Linux distributions. Some DE’s have it built-in to the DE. I believe Windows 10 also has a similar feature. What it does is change the color temperature of the monitor. By default most monitors use 6500k. The k is for Kelvin, a scientific way of measuring light among others.

5000k – 6500k is Daylight. 3000k is Fluorescent. 2700k is a Incandescent Light Bulb. 2200k is early Sun rise or a lantern. Just to name a few.

During the evening hours and overnight. You can set Redshift to use 2700k at sunset and 5000k or 6500k after sunrise. It can automate this as well. You have the option of setting your sunrise and sunset times manually. The other option is for it to detect your location or manually entering your zip code. Everyone I have shown this to complained about their monitor having a red hue. The problem always is the light they are using in the room. If your light is at 5000k or there is sunlight coming through a window. So yes your monitor will have a red hue. If your light was using 2700k and your monitor is using 2700k. You will not notice the difference.

The solution is to use SceneSwitch light bulbs. They are LED light bulbs that can change from 5000k to 2700k to 2200k. They are available from the various Home Improvement Stores for about $7 per bulb. Amazon also has them but in packs of 4 or more. I personally use the Phillips brand. They use 9.5w of electricity.

How it works is very simple. It uses a standard Incandescent Light Bulb socket. It even is in the same shape so you can continue using a lamp shade that attaches to the bulb. You turn the lamp on. If you want to change the color temperature. Just turn the lamp on. Once it turns on, turn it off again. Do that until you see the color temperature you want to use. Once you have the color temperature you want. Just leave the light on for a few seconds to let it save that setting. You are now done. It will remember this setting the next time it is turned on.

Everyone that I have shown these SceneSwitch light bulbs to has loved them. Especially in the morning. You can set the light to 2200k the night before. When you wake up. You will not be blinded by a bright harsh light. Personally I have noticed a positive change in my eyes after using these lights for a couple years.

http://jonls.dk/redshift/

https://www.lighting.philips.com/main/prof/led-lamps-and-tubes/led-bulbs/led-sceneswitch/929001263204_EU/product

Moss

Ventoy, Ventoy, Ventoy

You know that I love checking out various distros, and that I keep a box of USB sticks with various distros ready to go in case I need to change something or someone I know would like to try Linux. There are 10 color-coded USB sticks and 5 other sticks in my box.

I have been looking for a way to use one large USB stick to install several distros. Either due to my lack of skill, bad software, or my hardware, I have failed to be able use at least 3 different multiboot apps I’ve tried.

I mentioned that in the Linux Mint Telegram group, which is nice in that it includes a lot of users in India. My friends there told me about Ventoy, of which I had not heard a whisper among my American/UK friends. (Of course, since that time, 2 or 3 other podcasts have covered it.) So I looked into it.

There is a GUI version for Windows, but there is a version for Linux. You install it by downloading and extracting a .tar.gz file and following instructions. Not all sets of instructions are complete, so we’re going to try to help here.

You’ll probably want to create a Ventoy directory and extract the files there to keep things easy. You then open a Terminal and CD to the Ventoy directory. And then you run this command for a simple Ventoy stick:

sudo sh Ventoy2Disk.sh -I /dev/sdx

…where “sdx” needs to be changed to the address of your USB stick, probably sdc. The complete command, with switches, is:

sudo sh Ventoy2Disk.sh { -i | -I | -u } /dev/sdx

(from https://www.ventoy.net/en/doc_start.html )

I got lucky; I got Ventoy loaded to my Memorex USB 3.1 64Gb stick on the first try. And there is nothing but fun from here on in. You don’t have to extract ISOs, just copy the whole ISO to the stick. When you go to use it, you get a graphical menu for Ventoy with all available distros listed. Select which one to load, and Ventoy does the extraction itself.

Installing Ventoy formats the stick as exFAT, so you can’t add Ventoy to a stick you’re already using without losing the files on it; however, after installing Ventoy to the stick, you can use the stick to store other files and access them.

Not every ISO has been approved for Ventoy. I found I cannot use Feren OS. But I can use the latest BionicPup64, Pearl, any Ubuntu or Mint, SuSE… Calculate Linux can be installed using Ventoy but cannot be run as a live disk (also true of a few other distros, determined by the distro, not Ventoy). But here’s an extra thing: You can also install Windows ISO from the same Ventoy stick as your Linux ISOs. (Don’t tell anyone, but I have Win 7, 8.1 and 10 ISOs downloaded…)

For some distros, you can even set them up, add and delete programs, and the ISO gets saved with those changes — this is called “persistence”, and you can check the Ventoy site for more information on what has been tested, as well as for lots more information on this app. Caution: the devs of Ventoy are not well-versed in English, so checking other sites may be helpful as well, such as https://www.ostechnix.com/how-to-create-multiboot-usb-drives-with-ventoy-in-linux/

My current feeling is that I should have 3 sticks — one for Live ISOs, one for Install-only ISOs, and one for Persistent ISOs which I have modified.

I heartily recommend Ventoy with no reservation.

Announcements:

The next show will be Sunday, the 28th of June at 7PM UTC, 2PM US Central Time, 8PM British Summer Time

Wrap-up: