RubyGems - gtk_paradise - Versions diffs - 0.12.25 → 0.13.33 - Mend

gtk_paradise 0.12.25 → 0.13.33

Files changed (393) hide show

data/doc/README.gen CHANGED Viewed

@@ -26,7 +26,7 @@ gem and eventually replace ruby-gtk3 - although that remains to be seen.
 As of <b>April 2023</b>, the primary target and focus for the
 <b>gtk_paradise</b> lies on ruby-gtk3, though.
-What is <b>GTK</b>?
+## What is <b>GTK</b>?
 **GTK** itself is a toolkit for classical "oldschool" desktop applications
 first and foremost. These may not be <em>en vogue</em> anymore, but for
@@ -40,518 +40,297 @@ everywhere. Write once, run everywhere! \o/
 ## Deprecation notice
 ruby-gtk2 appears to be barely maintained actively anymore. As I can no
-longer compile it from source, since as of October 2023 support for
-ruby-gtk2 via the gtk_paradise project is semi-deprecated. I will retain
-the old code as-is, as well as the documentation; and I may fix bugs
-and improve things otherwise. But other than that, consider moving to
-ruby-gtk3 or ruby-gtk4. The primary focus as of 2023 is ruby-gtk3,
-with ruby-gtk4 one day being available too.
+longer compile it from source, since as of <b>October 2023</b>, support
+for ruby-gtk2 via the gtk_paradise project is semi-deprecated. I will
+retain the old code in examples/gtk2/ as-is, as well as the documentation;
+and I may fix bugs and improve things otherwise. But other than that,
+consider moving to ruby-gtk3 or ruby-gtk4. The primary focus as of 2023
+is ruby-gtk3, with ruby-gtk4 one day being fully supported as well.
-## A brief history of the gtk_paradise project
-The **gtk_paradise project** itself was created many years ago, and
-then eventually published on **rubygems.org** in **March 2015**,
-under its old name **gtk_module**
-Due to various reasons, including a seemingly necessary clean-up of the
-old code base that was part of the **gtk_module** project, the project
-was eventually <b>renamed</b> (and subsequently restructured) into the
-newly named **gtk_paradise** gem, in **January 2020**.
-The new structure for the project should be more logical, and thus make
-more sense as well, at the least compared to the older project called
-**gtk_module**. Furthermore, one focus was on being able to support
-both ruby-gtk2 and ruby-gtk3 (and eventually ruby-gtk4) - although,
-as previously mentioned, support for ruby-gtk2 is no longer as strong
-and some old code may no longer work either.
-## Use cases and goals for the gtk_paradise project
-Over the years, the **gtk_paradise** project has had **different primary
-use cases**. These will be listed now, starting with the more important
-goals:
-(1) provide **a set of convenience bindings/code** that may enhance the
-whole gtk-stack in ruby.
-I did not want to be limited solely by the official upstream bindings
-to GTK alone. Instead, I wanted to use ruby more naturally when writing
-ruby-gtk applications. Certain DSL-like commands appeared to make sense
-to me in the widget sets, such as **.on_clicked {}**.
-For instance, rather than use this variant:
-    button.signal_connect(:clicked) {
-      puts 'The button was clicked.'
-    }
-I wanted to use this variant instead:
-    button.on_clicked {
-      puts 'The button was clicked.'
-    }
-This seemed more natural and logical to me, but this was not possible
-because the official ruby-gtk bindings are more closely trying to match
-the official C API that governs GTK - and stop right at that point.
-This is largely due to gobject-introspection these days, and in part
-to simplify maintaining these upstream bindings. Either way I wanted
-to have more freedom in how to write ruby-code for ruby-gtk. See also
-the glimmer-project by Andy - you can find it on rubygems.org. Perhaps
-one day glimmer may unify all of desktop, web-related widgets and
-so forth. One codebase to rule them all. \o/
-(2) distribute a common code base for different gtk-applications,
-to allow **re-use of the code**, as a **secondary goal**.
-For example, **Gtk::BaseModule** is a convenience module that can
-be included into subclasses, like in the following manner:
+## CSS Handling in GTK and the gtk_paradise gem
-    require 'gtk_paradise/requires/require_the_base_module.rb'
-    include ::Gtk::BaseModule
-Or, even simpler than that, to just use this:
-    require 'gtk_paradise/require_gtk3'
-    class Foobar < Gtk::BaseModuleFrame # This automatically has include ::Gtk::BaseModule
-    end
-Then, once that was done, certain methods, such as **gtk_text()**, or
-just **text()**, can be used, rather than the slightly longer variant
-called **Gtk::Text.new()**, or **gtk_label()** or just **label()**
-rather than **Gtk::Label.new()**.
-So really, this was mostly done due reasons of my laziness or simply
-convenience, but additionally to avoid or reduce on **code
-duplication**. Other users of this gem can then also rely that these
-methods are supported by the gtk_paradise project in future versions -
-at the least once version 1.0 is released. (Right now this gem is
-still in a beta release state, so things may change. I will try to
-not break things unless absolutely necessary, though.)
-If we use a single method, such as text(), then we can easily change
-this at a later time, even if the upstream names change. This is
-one additional use case for the project: to allow working with
-ruby-gtk2, ruby-gtk3 and ruby-gtk4 (and ruby-gtk5 eventually, and
-so forth): one code base to rule-them-all.
-Take note that in regards to **::Gtk::BaseModule**, I use the leading
-**::** here because I want this all to be part of **module Gtk**. The
-reason for this is mostly due to <b>long-term convenience</b> when
-making use of this project. Of course typing a leading :: is a bit
-annoying, so this is a downside, but it is better to modify the
-toplevel namespace Gtk directly, in my opinion: keep everything
-coordinated in one namespace. (This was different in the older
-gtk_module gem, which is another reason why that was changed for
-the gtk_paradise gem.)
-(3) to **distribute some smaller classes** and even games written
-in ruby-gtk.
-Before the gtk_paradise project existed, I collected these different
-classes into local .rb files mostly (naturally), and put them into
-different projects - but in hindsight I think it may be better if
-there is a dedicated project that bundles together code, in regards to
-GTK, and publishes that code as well, ideally in an improved manner.
-Here a hope is that if you or anyone else creates some ruby-gtk
-application, say a small game or something like that, to send it to
-my email address (if you would like to), and if you deem the licence in
-the gtk_paradise to be an acceptable one; then I could integrate
-this game. (Please also add some documentation if you can; not everything
-has to be documented and commented fully, mind you, but at the least
-an introduction, the basic usage, and perhaps some comments within
-the .rb files.)
-Note that since as of **2021** I bundle games-related code into another
-gem called **games_paradise** - this one will include some ruby-gtk
-based games as well, so games are no longer distributed in the
-gtk_paradise project. Nonetheless, the gtk_paradise project retains its
-use case of trying to distribute a shared code base, for other projects
-to operate from, and re-use (and share) different new gtk-widgets and
-new gtk-based applications.
-(4) last, but not least, provide stellar documentation and explanations.
-This is still ongoing, but hopefully this may be useful to you even
-if you do not use this project. I benefitted from tutorials based on
-python-gtk3, so I found this to be a useful and laudable goal for ruby
-too: teach people, explain things, document stuff.
-These are the four major goals for this gem. There are some minor
-goals as well, but they are not that important to mention them here;
-if you are interested in more minor goals, have a look at the
-todo/ subdirectory of this gem - these minor goals are, to some
-extent, mentioned there. As a todo-list.
-## The licence of the gtk_paradise project
-Since as of the **19th July 2021** (**19.07.2021**) the **gtk_paradise**
-project now uses the **MIT licence**. Before that the **gtk_paradise** project
-used the **LGPL-2.1 licence** (GNU LESSER GENERAL PUBLIC LICENSE Version 2.1),
-without the later clause though.
-I am perfectly fine with both **GPL** and **LGPL** licences - they are good
-licences. But they also tend to cause more hassle than what often seems necessary
-when it comes to <b>enforcement</b> of the licence part. The project here is a
-hobby project, so I am not even paying that much attention as to what others
-do with this code to begin with really - it's not a "key project" for me at all
-whatsoever, in this regard.
-The MIT licence is much, much simpler than the GPL - other than the <b>no-warranty
-clause</b> (aka "you are on your own when using this project"), there isn't really
-that much else to worry about it. Whereas the **LGPL licence** is like really
-huge compared to the MIT licence ... and we haven't even gotten to the **GPL**
-yet, forcing all downstream code to have the same licence (and permissions,
-granted upon other users, too).
-Anyway - here is a good summary for the MIT licence:
-https://opensource.org/licenses/MIT
-I don't even 'care' about the copyright statement as such, per se, but in some
-jurisdictions there is no way to forego the copyright notice (I think in
-Germany), so simply substitute as appropriate in such jurisdictions. How courts
-evaluate anything is not up to me - for this project, the MIT licence is
-used. That's it.
-## Towards a version 1.0 for this gem
-Right now (in 2021, but also in April 2023, when this document was again
-updated massively) the gtk_paradise gem is not yet ready for a 1.0 release.
-I am still experimenting **a lot** in 2021 - as well as in 2023.
-At some later time I will decide which features will be retained, and
-which ones will be removed. Then the documentation and examples will
-be improved, everything will be significantly polished, and a "final" 1.0
-release will be published. This one will be made available for a significantly
-longer time, so that people can begin to use it for more serious projects.
+### CSS files distributed in the gtk_paradise gem
-Final here means that this will be the final 1.0 release. Of course later
-releases may follow past 1.0, but 1.0 will remain hosted on rubygems.org
-for a longer time than subsequent releases.
+All <b>.css</b> files that are distributed in the gtk_paradise gem
+will reside at the following location:
-But this will probably take a few years, so stay tuned in this regard.
+    gtk_paradise/cascading_style_sheets/
-## Documentation for the gtk-paradise project
+This has to be documented, as previous releases of the gtk_paradise
+gem used another path for .css files.
-The <b>documentation</b> for the gtk-paradise project is currently lacking,
-admittedly so. This is not good and should be remedied in the long run.
-There are several personal reasons as to why documentation is lacking
-currently: laziness, lack of time and lack of motivation. But another,
-somewhat trivial additional reason is that I am experimenting a **LOT**
-right now.
+### Using Gtk::BaseModule to handle CSS rules
-I have no real idea what happens with the **gtk_paradise project** in its
-current form in the long run, in regards to future changes. I want to
-simplify the project, which means that old code may be removed every now
-and then. Retaining the ability to change a project is very important,
-unless it becomes stable. Sometimes you may find better ways to express an
-idea in code - or in less code. So the gtk_paradise project is not very
-stable right now, and probably will not be for a long time, until I
-feel sufficiently pleased with its present form.
+The <b>gtk_paradise gem</b> includes a few .css files which cater to my use
+case. If you want to make use of these CSS rules then, after including
+<b>Gtk::BaseModule</b>, call the following method:
-I once had that crazy idea that it would be nice to have a **GUI-like
-DSL-layer** over the terminal interface, the www, as well as classical
-desktop elements, as pointed out above. To **use one unified code base
-for all GUI-elements**.
+    apply_the_default_css_rules
-While this is probably too ambitious a goal, I still want to try
-at the least some of those ideas that can help us write more desktop-GUIs
-in ruby-gtk, at a much faster "implementation speed" than before (I refer
-to our human life time that we invest in creating this, NOT to the speed
-of code-execution once an application is run). So ideas in this regard are
-very welcome - and I am experimenting with these as well.
+This will read in the file content of the two files **project.css**
+and **colours.css**. The latter is for colours; and the former is
+for everything else. This will actually append the default
+CSS rules, so if you want to add CSS manually while also using
+this method, it is recommend to append these custom CSS rules
+<b>before</b> calling **.apply_the_default_css_rules()**.
-Nonetheless, whenever possible I will try to **slowly** improve
-on the existing documentation distributed as part of the **gtk_paradise**
-project - but ultimately I think for the time being, it may often be
-better to simply peek at the source code itself for the different
-widgets used in the gtk_paradise project. Some errors and mistakes
-may exist as well, so have a look at the official gtk-documentation
-aside from the project here.
+If you want to quickly verify the CSS in use for the widget
+at hand, as a <b>String</b>, then you can simply use this
+method:
-The whole **gtk_paradise project** is definitely more geared towards
-people already knowing ruby quite well, not necessarily aimed for
-beginners. Beginners should start with the upstream ruby-gtk bindings
-instead, and work through the examples and demo, until they have a
-sufficient grasp of the underlying concepts used by upstream GTK. Of
-course nothing prevents you from giving the gtk_paradise project a
-try as-it-is; beginners are, however had, not necessarily the main,
-primary target audience for this gem.
+    display_the_CSS_rules
-I, on the other hand, wanted to write widgets in a more ruby-centric
-manner, including some **DSL-like elements**, such as simply using
-**gtk_button** or even just **button** in order to create a button,
-or add methods such as **.on_clicked** to capture on-click events
-to such a button. If we are using code such as **button {}** then,
-in theory, we could eventually expand this to different toolkits,
-such as **tk** or **qt**, but also make such applications usable on the
-www if we map this to a functional interface - but these are mostly
-hypothetical thoughts for now. In practice, this project really just
-focuses on **polishing ruby-gtk widgets** directly.
+You can still append CSS lateron, such as:
-## How to benefit from the gtk_paradise project?
+    append_these_CSS_rules '.bblack20 { border: 20px solid black; }'
-How to make use of this project in a way that may be useful to you
-or other people?
+### CSS - how to add a CSS class to a gtk-widget in general
-The **gtk_paradise** project tries to support different styles and
-remain flexible overall, so I can not tell **you** how you "should"
-use it - it all depends on various factors. It also depends on the
-way how you decide how to lay out the code.
+Say that your use case is to add a CSS class to a specific
+gtk-widget.
-So, rather than try to answer this fairly large and complex question,
-I will try to explain how I tend to use the project, which may
-serve as a general introduction into the gtk_paradise project
-as well.
+The default <b>upstream API</b> for achieving this, goes as follows:
-First, I typically add code to a **standalone** widget; then
-I instantiate this widget into **Gtk::Runner**, via **Gtk.run**.
-In other words, that widget is put into a Gtk::Runner
-instance.
+    widget.style_context.add_class('your_css_name_goes_in_here')
+    widget.style_context.add_class('bblack1') # For example, use the CSS class called bblack1. On my system this is equivalent to "border: 1px solid black"
-That way - and one advantage of doing this - I can <b>avoid</b>
-having to work with Gtk::Window directly, which I find to be a
-somewhat annoying widget. I find it more convenient to operate
-via **Gtk::Runner**. I can also modify <b>Gtk::Runner</b>
-easily and, for instance, automatically add all custom CSS
-rules that I use onto it. So you can see that it is more
-flexible than subclassing from Gtk::Window directly.
+More specifically with a real gtk-widget as example:
-In the past, I used another approach, at the least for
-ruby-gtk3. Here I was subclassing from Gtk::Window directly,
-but since as of **March 2021** I simplified this old
-approach - now I use the very same approach for both
-ruby-gtk2 and ruby-gtk3 in this regard. That was one reason
-for the rewrite from gtk_module to gtk_paradise, by the
-way.
+    label = Gtk::Label.new('Hello world!!!')
+    label.style_context.add_class('bblack5')
-Note that because of gtk3 changing things quite a bit, I
-created the directory called **base_module_and_runner_module/**,
-specifically for **ruby-gtk3**. I needed to improve support
-on the toplevel-instance directly.
+Let's show yet another example, this time with the CSS rules coming first,
+and the widget that uses this CSS rule coming second:
-The simplest way for me is to <b>then</b> use **Gtk::BaseModule**
-via the following code in custom widgets:
+    # First the CSS rule is defined:
+    .fancy_styling {
+      font-size:     50px;
+      border:         8px solid darkgreen;
+      border-radius: 32px;
+    }
+    button = Gtk::Button.new('Hello world!!!')
+    button_context = button.style_context
+    # Next, we add that CSS class to the button:
+    button_context.add_class('fancy_styling') # This will add the CSS class.
-    require 'gtk_paradise/requires/require_the_base_module.rb'
-    include ::Gtk::BaseModule
+Note that <b>Gtk::BaseModule</b>, distributed via the gtk_paradise gem,
+simplifies this a lot. See other subsections in this document to
+showcase how this has been simplified.
-Note that this is put in **requires/** - this should be guaranteed
-to work for a long time, even if I may change the code
-internally.
+Adding a new class goes via .add_class():
-It should never become any more complicated than these two
-lines.
+    button_context.add_class('white')
-These two **prior** requires should then suffice, depending on
-whether you want to use gtk2 or gtk3:
+And removing it goes via .remove_class():
-    require 'gtk_paradise/require_gtk2'
+    button_context.remove_class('white')
-or
+You may have to remove an old CSS class before you can add a new
+CSS class.
-    require 'gtk_paradise/require_gtk3' # This one should be more common these days.
+Note that you can give a widget a name, similar to an ID in HTML,
+via .set_name():
-So, put any (either, rather) of these two require lines on
-top of the .rb file at hand. If you are still unsure about
-the layout, simply look at the files that come distributed
-via the gtk_paradise gem. You will typically see them
-begin with this as the first line of ruby code.
+    widget.set_name("red_label")
+    label.set_name("red_label")
-I recommend to use gtk3 these days; the CSS rules are making
-it much more convenient to work with gtk3.
+This allows you to use specific CSS classes too.
-## Structure of the gtk_paradise project
+To create a hover effect, you could tweak the following CSS:
-This subsection will include some information about the overall
-structure of the gtk_paradise project. This will **NOT** be
-complete; instead it merely provides some pointers. Note that
-this may become slightly deprecated over time, so consider it
-to be more of something that may have been correct at one point
-in time, but may have changed since then.
+    .button { border-radius: 15; border-width: 2; border-style: outset; }
+    .button:hover { background: #dff; border-color: #8bb; }
-All files that are part of Gtk::BaseModule will reside under
-the subdirectory called **base_module/**.
+If you would like to see a longer explanation then have a look at the
+following URL:
-The file **app.rb**, which can be found at **gtk_paradise/app/app.rb**,
-contains the code for the toplevel method call **Gtk.app()** -
-this one is aliased to **Gtk.run()**, which used to be the original
-name at one point in time.
+https://shallowsky.com/blog/programming/styling-gtk3-with-css-python.html
-This code can be used to **quickly start a gtk-widget**, and embed
-it into **Gtk::Window.new()** essentially. It reduces a bit of
-the necessary boilerplate code.
+### Gtk::CssProvider
-Some of the default gtk-classes are modified by the gtk_paradise
-project. These modifications will be stored under the **gtk_classes/**
-subdirectory. The rule for entries in that directory is very simple:
-the name of the class will become the corresponding .rb file name.
+This subsection contains some information about class **Gtk::CssProvider**.
-So class **Gtk::SourceBuffer** would reside at **gtk_classes/source_buffer.rb**.
-Note that not all modifications can be applied, for various reasons, but
-many of the default classes are modified. Remember this when using the
-gtk_paradise project: it is NOT a project for the 'default', assumed usage. For
-that you are recommended to use **vanilla** ruby-gtk instead, without
-the custom modifications done by the gtk-paradise project. The primary
-focus for the gtk_paradise project is to try to be of help when it
-comes to efficiency, when writing code - thus, the gtk_paradise
-project is more of an applied toolset project that tries to enhance
-the current status quo. (The ruby-gtk bindings are, unfortunately,
-mostly just a wrapper over the C API itself. This limits the way
-how users can think about application code.)
+This class can be used to make CSS rules available for gtk-widgets. It is
+available by default if you require 'gtk3'.
-## Demo
+If you have a local <b>.css</b> file and want to load it, consider using
+the following API (and adjust accordingly to your use case):
-The **gtk_paradise** gem comes with many example files, collected from
-different sources.
+    require 'gtk3'
-If you want to use a controller-widget to show some of them, consider
-looking at the subdirectory examples/controller/, the controller.rb
-file there. This defaults to ruby-gtk3. One day it should work
-for both ruby-gtk2 and ruby-gtk3, but I prioritise on ruby-gtk3
-these days, so support for ruby-gtk2 may lag behind.
+    css_provider = Gtk::CssProvider.new
+    css_provider.load_from_path('/home/x/programming/ruby/src/gtk_paradise/lib/gtk_paradise/css/default.css') # ← Provide the path to the .css file here.
-At any rate, run the controller.rb file to see what is available
-as demo. The basic idea is that the demo showcases all standalone
-examples, similar to main.rb of the official ruby-gnome / ruby-gtk
-bindings.
+### CSS rules - various examples
-## How to determine the version of ruby-gtk?
+This subsection will contain a few CSS rules as examples.
-First, use either:
+This is mostly just a <b>quickref</b> (quick reference), in the event that
+people want to refresh their knowledge about how GTK handles CSS rules.
-    require 'gtk2'
-    require 'gtk3' # or this one here for ruby-gtk3.
+Showing specific examples that work is best, because it is very simple and
+straightforward, in my opinion.
-Next, you can query some constants:
+<b>First</b>: keep all widget names **lowercase**. There are old examples on
+the www available where the widget-names in use for CSS start with "Gtk",
+such as <b>GtkEntry</b>. Such examples no longer work and are deprecated.
+Instead, simply use, for instance, <b>entry</b> instead these days.
-    pp ::Gtk::Version::MAJOR
-    pp ::Gtk::Version::MICRO
-    pp ::Gtk::Version::MINOR
-    pp ::Gtk::Version::STRING # => "2.24.32"
+At any rate and without further ado, next come a multitude of different,
+specific examples.
-## Querying the GTK theme in use
+Picking a proper font via CSS:
-You can issue the following command in order to query the theme GTK is
-using:
+    font-family: Monospace;
+    font-family: Cantarell; # Or use this family.
-    gtk-query-settings theme
+<b>Set the size of the font</b> at hand, via CSS:
-## CSS Handling in GTK
+    font-size: 25px; # don't forget to put this inside the {}, of course.
-### CSS files distributed in the gtk_paradise gem
+Set the background colour of <b>every window</b> to a particular
+colour:
-All .css files that are distributed in the gtk_paradise gem will reside at:
+    window {
+      background-color: white; # replace this here with a colour of your choice; and use 'color' rather than 'colour'
+    }
-    gtk_paradise/css_files/
+To make a button show a <b>hover-effect</b> (when the mouse is "above"
+the button), try the <b>:hover</b> directive, such as the following
+example shows:
-I wanted to document this, because this was different in the 0.7.x release
-saga of the gtk_paradise gem.
+    .button:hover {
+      padding:          12px 48px;
+      background-color: #4870bc;
+    }
-### CSS - how to add a CSS class to a gtk-widget
+(An alternative to the above CSS rule may be to make use of the method
+.override_background_color(), but here we focus primarily on CSS rules.)
-The default **upstream API** is this:
+It is possible to target specific children in a gtk-widget. For example,
+in order to specifically <b>style the first child of a gtk-widget</b>,
+such as for a <b>button</b>, try the following CSS rule:
-    widget.style_context.add_class('your_css_name_goes_in_here')
-    widget.style_context.add_class('bblack1') # For example, use the CSS class called bblack1. On my system this is equivalent to "border: 1px solid black"
+    .button:first-child {
+      border-radius: 5px 0 0 5px;
+    }
-More specifically with a real gtk-widget as example:
+Modifying <b>two widgets at the same time</b> via the same CSS style - in
+this case a gtk-button and a gtk-entry:
-    label = Gtk::Label.new('Hello world!!!')
-    label.style_context.add_class('bblack5')
+    button, entry { /* Keep in mind that this would modify ALL buttons and entries at the same time.
+      color: #ff00ea;
+      font:  12px "Comic Sans";
+    }
-Let's show yet another example, this time with the CSS rules coming first:
+You can also style / theme <b>insensitive widgets</b> in general, via:
-    .fancy_styling {
-      font-size:     50px;
-      border:         8px solid darkgreen;
-      border-radius: 32px;
+    *:disabled {
+      background-color: #320a91;
     }
-    button = Gtk::Button.new('Hello world!!!')
-    button_context = button.style_context
-    button_context.add_class('fancy_styling') # This will add the CSS class.
-Note that **Gtk::BaseModule**, distributed via the gtk_paradise gem,
-simplifies this a lot. See other subsections in this document to
-find out how this has been simplified.
+Theme all <b>labels</b> in the <b>first notebook tab</b>:
-If you would like to see a longer explanation then have a look at
-the following URL:
+    notebook tab:first-child label {
+      color: #89d012;
+    }
-https://shallowsky.com/blog/programming/styling-gtk3-with-css-python.html
+Theme the entry of a <b>Gtk::SpinButton</b> specifically:
-### Gtk::Calendar
+    spinbutton entry {
+      color: #900185;
+    }
-<b>Gtk::Calendar</b> can be used to show a calendar in your application.
+Apply the green colour to every gtk-widget, via <b>*</b>:
-A new calendar can be instantiated in the following way:
+    * {
+      color: green;
+    }
-    calendar = Gtk::Calendar.new
+If you want to style a <b>Gtk::TextView widget</b>, use a CSS
+rule such as the following:
-Setting a different month can be done via the method
-<b>.select_month()</b>.
-### Gtk::CheckMenuItem
+    textview.view {
+      margin: 10px;
+      padding: 10px;
+      border: 2px solid rgba(0, 255, 255, 0.3);
+    }
-Let's first show a small image, to indicate how this widget looks like
-in general:
+To make a <b>rounded border effect</b> you can use CSS rules such as the
+following, via <b>border-radius</b>:
-<img src="https://i.imgur.com/pkipGZF.png" style="margin: 1em">
+    button {
+      border:        6px solid steelblue;
+      border-radius: 8px;
+    }
-The Gtk::CheckMenuItem widget is that small arrow-icon, associated
-with a label-widget on the right side, such as can be seen by the
-'Toolbar' text or the 'Statusbar' text.
+Or, via an ID, use the following:
-<b>Gtk::CheckMenuItem</b> is a subclass of Gtk::MenuItem.
+    #button1 {
+      border:        6px solid steelblue;
+      border-radius: 8px;
+    }
-This widget can be used to add a menu item that the user can select and
-deselect again. That way this menu element can be used as <b>a boolean
-toggle</b>, between <b>true</b> and <b>false</b>.
+You can also give each coordinate a different value, such as via:
-Every time the user clicks on this item the value is changed, so it
-really acts like a <b>flip-switch</b>.
+    .rounded_corner {
+      border-radius: 0px 0px 6px 6px;
+    }
-### Gtk::CssProvider
+This would lead to rounded borders on the bottom, but not on the top.
+In general, though, I think each of these four values being the same
+looks a <b>lot</b> better.
-This subsection contains some information about class **Gtk::CssProvider**.
+Either way, adjust the values to your preferences.
-This class can be used to make CSS rules available for gtk-widgets.
+Make <b>all selections</b> appear in <b>steelblue</b> colour can be
+done via:
-If you have a local .css file and want to load it, consider using
-the following API (and adjust accordingly to your use case):
+    selection {
+      color: steelblue;
+    }
-    require 'gtk3'
+Use an unequal border-width (e. g. empty on one area):
-    css_provider = Gtk::CssProvider.new
-    css_provider.load_from_path('/home/x/programming/ruby/src/gtk_paradise/lib/gtk_paradise/css/default.css') # ← Provide the path to the .css file here.
+    border-width: 2px 0 2px 2px; # This setting would factually omit the right border.
+    .small_border { border-width: 2px 0 2px 2px; } # Ready for copy-paste. \o/
-### Using Gtk::BaseModule to handle CSS rules
+If you have a need or use case to change the colour of the pulsing cursor in
+a gtk-entry or gtk-textview, also called a <b>caret</b>, then you could use
+something like this:
-The gtk_paradise gem includes a few .css files which cater to my use
-case. If you want to make use of these CSS rules then, after
-including Gtk::BaseModule, call the following method:
+    * {
+      caret-color: gold;
+    }
-    apply_the_default_css_rules
+This would change the colour of the caret to <b>gold</b>. This may be useful if
+your gtk-entry has a black background colour and you want to change this to a
+more visible caret - hence gold. The example
+at <b>gtk_paradise/examples/advanced/025_showing_a_gold_caret_on_black_background.rb</b>
+shows this via a simple entry.
-This will read in the file content of the two files **project.css**
-and **colours.css**. The latter is for colours; and the former is
-for everything else. This will actually append the default
-CSS rules, so if you want to add CSS manually while also using
-this method, it is recommend to append these custom CSS rules
-before calling **.apply_the_default_css_rules()**.
+You can also associate this with a specific CSS class or make
+the caret transparent, such as in:
-If you want to quickly verify the CSS in use for the widget
-at hand, as String, then use this method:
+    .my_label { caret-color: transparent; }
+    .foobar   { caret-color: green; }
-    display_the_CSS_rules
+To give the whole window a fancy background, use a CSS rule such as
+the following (for <b>Gtk::Window</b>):
-You can still append CSS lateron, such as:
+    window {
+      background: linear-gradient(153deg, #151515, #151515 5px, transparent 5px) 0 0,
+                  linear-gradient(333deg, #151515, #151515 5px, transparent 5px) 10px 5px,
+                  linear-gradient(153deg, #222, #222 5px, transparent 5px) 0 5px,
+                  linear-gradient(333deg, #222, #222 5px, transparent 5px) 10px 10px,
+                  linear-gradient(90deg, #1b1b1b, #1b1b1b 10px, transparent 10px),
+                  linear-gradient(#1d1d1d, #1d1d1d 25%, #1a1a1a 25%, #1a1a1a 50%, transparent 50%, transparent 75%, #242424 75%, #242424);
+      background-color: #131313;
+      background-size: 20px 20px;
+    }
-    append_these_CSS_rules '.bblack20 { border: 20px solid black; }'
+So you can use <b>linear-gradient</b> too.
 ### CSS Support in gtk3: using CSS in ruby-gtk3 and using CSS via the gtk_paradise gem
@@ -584,7 +363,7 @@ Next, ruby code is shown to benefit from these CSS rules:
     )
 I am not sure how much of CSS is supported in GTK+, but sticking to
-the commonly used CSS rules, such as **color**, **background-color**
+the commonly used CSS rules, such as <b>color</b>, **background-color**
 and so forth, appears to be working fairly well. Since I keep on
 forgetting which rules may work and which ones may not, I intend
 to keep this subsection here as a **quick reference**; expect
@@ -768,11 +547,18 @@ in ruby-gtk3 and CSS, like the following example demonstrates:
     background-color: rgb(241, 135, 135);
-Or, if you also want to provide the **transparence value** at
+Or, if you also want to provide the <b>transparence value</b> at
 the end:
     background-color: rgba (0, 0, 0, 0);
+The four parameters stand for:
+      red:   value
+      green: value
+      blue:  value
+      alpha: value
 You can use <b>custom images</b>, such as .png files, to replace the
 default check button and radio button.
@@ -978,7 +764,7 @@ Styling an entry of a **spin button**  via CSS:
       color: #900185;
     }
-To style a **Gtk::Grid** via CSS, you can use something like this:
+To style a <b>Gtk::Grid</b> via CSS, you can use something like this:
     grid {
       border: 1px solid steelblue;
@@ -1056,7 +842,7 @@ use the **CSS-provider**):
     label = Gtk::Label.new('Test!')
     label.set_name('foo-bar')
-To modify all **Gtk::ScrolledWindow** instances you can use the
+To modify all <b>Gtk::ScrolledWindow</b> instances you can use the
 following CSS rule:
     /* Style our main scrolled-window a little bit. */
@@ -1280,169 +1066,434 @@ You can also work with IDs similar to HTML/CSS. For instance:
     label.set_name("red_label")
     css = '#red_label { background-color: #f00; }'
-But I find it often better to simply use CSS classes and attach
-them as-is, depending on what you'd like to see instead.
+But I find it often better to simply use CSS classes and attach
+them as-is, depending on what you'd like to see instead.
+## A brief history of the gtk_paradise project
+The **gtk_paradise project** itself was created many years ago, and
+then eventually published on **rubygems.org** in **March 2015**,
+under its old name **gtk_module**
+Due to various reasons, including a seemingly necessary clean-up of the
+old code base that was part of the **gtk_module** project, the project
+was eventually <b>renamed</b> (and subsequently restructured) into the
+newly named **gtk_paradise** gem, in **January 2020**.
+The new structure for the project should be more logical, and thus make
+more sense as well, at the least compared to the older project called
+**gtk_module**. Furthermore, one focus was on being able to support
+both ruby-gtk2 and ruby-gtk3 (and eventually ruby-gtk4) - although,
+as previously mentioned, support for ruby-gtk2 is no longer as strong
+and some old code may no longer work either.
+## Use cases and goals for the gtk_paradise project
+Over the years, the **gtk_paradise** project has had **different primary
+use cases**. These will be listed now, starting with the more important
+goals:
+(1) provide **a set of convenience bindings/code** that may enhance the
+whole gtk-stack in ruby.
+I did not want to be limited solely by the official upstream bindings
+to GTK alone. Instead, I wanted to use ruby more naturally when writing
+ruby-gtk applications. Certain DSL-like commands appeared to make sense
+to me in the widget sets, such as **.on_clicked {}**.
+For instance, rather than use this variant:
+    button.signal_connect(:clicked) {
+      puts 'The button was clicked.'
+    }
+I wanted to use this variant instead:
+    button.on_clicked {
+      puts 'The button was clicked.'
+    }
+This seemed more natural and logical to me, but this was not possible
+because the official ruby-gtk bindings are more closely trying to match
+the official C API that governs GTK - and stop right at that point.
+This is largely due to gobject-introspection these days, and in part
+to simplify maintaining these upstream bindings. Either way I wanted
+to have more freedom in how to write ruby-code for ruby-gtk. See also
+the glimmer-project by Andy - you can find it on rubygems.org. Perhaps
+one day glimmer may unify all of desktop, web-related widgets and
+so forth. One codebase to rule them all. \o/
+(2) distribute a common code base for different gtk-applications,
+to allow **re-use of the code**, as a **secondary goal**.
+For example, **Gtk::BaseModule** is a convenience module that can
+be included into subclasses, like in the following manner:
+    require 'gtk_paradise/requires/require_the_base_module.rb'
+    include ::Gtk::BaseModule
+Or, even simpler than that, to just use this:
+    require 'gtk_paradise/require_gtk3'
+    class Foobar < Gtk::BaseModuleFrame # This automatically has include ::Gtk::BaseModule
+    end
+Then, once that was done, certain methods, such as **gtk_text()**, or
+just **text()**, can be used, rather than the slightly longer variant
+called **Gtk::Text.new()**, or **gtk_label()** or just **label()**
+rather than **Gtk::Label.new()**.
+So really, this was mostly done due reasons of my laziness or simply
+convenience, but additionally to avoid or reduce on **code
+duplication**. Other users of this gem can then also rely that these
+methods are supported by the gtk_paradise project in future versions -
+at the least once version 1.0 is released. (Right now this gem is
+still in a beta release state, so things may change. I will try to
+not break things unless absolutely necessary, though.)
+If we use a single method, such as text(), then we can easily change
+this at a later time, even if the upstream names change. This is
+one additional use case for the project: to allow working with
+ruby-gtk2, ruby-gtk3 and ruby-gtk4 (and ruby-gtk5 eventually, and
+so forth): one code base to rule-them-all.
+Take note that in regards to **::Gtk::BaseModule**, I use the leading
+**::** here because I want this all to be part of **module Gtk**. The
+reason for this is mostly due to <b>long-term convenience</b> when
+making use of this project. Of course typing a leading :: is a bit
+annoying, so this is a downside, but it is better to modify the
+toplevel namespace Gtk directly, in my opinion: keep everything
+coordinated in one namespace. (This was different in the older
+gtk_module gem, which is another reason why that was changed for
+the gtk_paradise gem.)
+(3) to **distribute some smaller classes** and even games written
+in ruby-gtk.
+Before the gtk_paradise project existed, I collected these different
+classes into local .rb files mostly (naturally), and put them into
+different projects - but in hindsight I think it may be better if
+there is a dedicated project that bundles together code, in regards to
+GTK, and publishes that code as well, ideally in an improved manner.
+Here a hope is that if you or anyone else creates some ruby-gtk
+application, say a small game or something like that, to send it to
+my email address (if you would like to), and if you deem the licence in
+the gtk_paradise to be an acceptable one; then I could integrate
+this game. (Please also add some documentation if you can; not everything
+has to be documented and commented fully, mind you, but at the least
+an introduction, the basic usage, and perhaps some comments within
+the .rb files.)
+Note that since as of **2021** I bundle games-related code into another
+gem called **games_paradise** - this one will include some ruby-gtk
+based games as well, so games are no longer distributed in the
+gtk_paradise project. Nonetheless, the gtk_paradise project retains its
+use case of trying to distribute a shared code base, for other projects
+to operate from, and re-use (and share) different new gtk-widgets and
+new gtk-based applications.
+(4) last, but not least, provide stellar documentation and explanations.
+This is still ongoing, but hopefully this may be useful to you even
+if you do not use this project. I benefitted from tutorials based on
+python-gtk3, so I found this to be a useful and laudable goal for ruby
+too: teach people, explain things, document stuff.
+These are the four major goals for this gem. There are some minor
+goals as well, but they are not that important to mention them here;
+if you are interested in more minor goals, have a look at the
+todo/ subdirectory of this gem - these minor goals are, to some
+extent, mentioned there. As a todo-list.
+## The licence of the gtk_paradise project
+Since as of the **19th July 2021** (**19.07.2021**) the **gtk_paradise**
+project now uses the **MIT licence**. Before that the **gtk_paradise** project
+used the **LGPL-2.1 licence** (GNU LESSER GENERAL PUBLIC LICENSE Version 2.1),
+without the later clause though.
+I am perfectly fine with both **GPL** and **LGPL** licences - they are good
+licences. But they also tend to cause more hassle than what often seems necessary
+when it comes to <b>enforcement</b> of the licence part. The project here is a
+hobby project, so I am not even paying that much attention as to what others
+do with this code to begin with really - it's not a "key project" for me at all
+whatsoever, in this regard.
+The MIT licence is much, much simpler than the GPL - other than the <b>no-warranty
+clause</b> (aka "you are on your own when using this project"), there isn't really
+that much else to worry about it. Whereas the **LGPL licence** is like really
+huge compared to the MIT licence ... and we haven't even gotten to the **GPL**
+yet, forcing all downstream code to have the same licence (and permissions,
+granted upon other users, too).
+Anyway - here is a good summary for the MIT licence:
+https://opensource.org/licenses/MIT
+I don't even 'care' about the copyright statement as such, per se, but in some
+jurisdictions there is no way to forego the copyright notice (I think in
+Germany), so simply substitute as appropriate in such jurisdictions. How courts
+evaluate anything is not up to me - for this project, the MIT licence is
+used. That's it.
+## Towards a version 1.0 for this gem
+Right now (in 2021, but also in April 2023, when this document was again
+updated massively, and again in November 2023) the gtk_paradise gem is
+not yet ready for a 1.0 release. I am still experimenting <b>a lot</b>
+in 2021 - as well as in 2023.
+At some later time I will decide which features will be retained, and
+which ones will be removed. Then the documentation and examples will
+be improved, everything will be significantly polished, and a "final" 1.0
+release will be published. This one will be made available for a significantly
+longer time, so that people can begin to use it for more serious projects.
+Final here means that this will be the final 1.0 release. Of course later
+releases may follow past 1.0, but 1.0 will remain hosted on rubygems.org
+for a longer time than subsequent releases.
+But this will probably take a few years, so stay tuned in this regard.
+## Documentation for the gtk-paradise project
+The <b>documentation</b> for the gtk-paradise project is currently lacking,
+admittedly so. This is not good and should be remedied in the long run.
+There are several personal reasons as to why documentation is lacking
+currently: laziness, lack of time and lack of motivation. But another,
+somewhat trivial additional reason is that I am experimenting a **LOT**
+right now.
+I have no real idea what happens with the **gtk_paradise project** in its
+current form in the long run, in regards to future changes. I want to
+simplify the project, which means that old code may be removed every now
+and then. Retaining the ability to change a project is very important,
+unless it becomes stable. Sometimes you may find better ways to express an
+idea in code - or in less code. So the gtk_paradise project is not very
+stable right now, and probably will not be for a long time, until I
+feel sufficiently pleased with its present form.
+I once had that crazy idea that it would be nice to have a **GUI-like
+DSL-layer** over the terminal interface, the www, as well as classical
+desktop elements, as pointed out above. To **use one unified code base
+for all GUI-elements**.
+While this is probably too ambitious a goal, I still want to try
+at the least some of those ideas that can help us write more desktop-GUIs
+in ruby-gtk, at a much faster "implementation speed" than before (I refer
+to our human life time that we invest in creating this, NOT to the speed
+of code-execution once an application is run). So ideas in this regard are
+very welcome - and I am experimenting with these as well.
+Nonetheless, whenever possible I will try to **slowly** improve
+on the existing documentation distributed as part of the **gtk_paradise**
+project - but ultimately I think for the time being, it may often be
+better to simply peek at the source code itself for the different
+widgets used in the gtk_paradise project. Some errors and mistakes
+may exist as well, so have a look at the official gtk-documentation
+aside from the project here.
+The whole **gtk_paradise project** is definitely more geared towards
+people already knowing ruby quite well, not necessarily aimed for
+beginners. Beginners should start with the upstream ruby-gtk bindings
+instead, and work through the examples and demo, until they have a
+sufficient grasp of the underlying concepts used by upstream GTK. Of
+course nothing prevents you from giving the gtk_paradise project a
+try as-it-is; beginners are, however had, not necessarily the main,
+primary target audience for this gem.
+I, on the other hand, wanted to write widgets in a more ruby-centric
+manner, including some **DSL-like elements**, such as simply using
+**gtk_button** or even just **button** in order to create a button,
+or add methods such as **.on_clicked** to capture on-click events
+to such a button. If we are using code such as **button {}** then,
+in theory, we could eventually expand this to different toolkits,
+such as **tk** or **qt**, but also make such applications usable on the
+www if we map this to a functional interface - but these are mostly
+hypothetical thoughts for now. In practice, this project really just
+focuses on **polishing ruby-gtk widgets** directly.
+## How to benefit from the gtk_paradise project?
+How to make use of this project in a way that may be useful to you
+or other people?
+The **gtk_paradise** project tries to support different styles and
+remain flexible overall, so I can not tell **you** how you "should"
+use it - it all depends on various factors. It also depends on the
+way how you decide how to lay out the code.
-### CSS rules - various examples
+So, rather than try to answer this fairly large and complex question,
+I will try to explain how I tend to use the project, which may
+serve as a general introduction into the gtk_paradise project
+as well.
-This subsection will contain a few CSS rules as examples. This is mostly just
-a quickref (quick reference), in the event that people want to refresh their
-knowledge. Showing specific examples that work is best, in my opinion.
+First, I typically add code to a **standalone** widget; then
+I instantiate this widget into **Gtk::Runner**, via **Gtk.run**.
+In other words, that widget is put into a Gtk::Runner
+instance.
-**First**: keep all widget names **lowercase**. There are old examples on
-the www available where the widget-names in use for CSS start with "Gtk",
-such as **GtkEntry**. This should be simply **entry** instead these days.
+That way - and one advantage of doing this - I can <b>avoid</b>
+having to work with Gtk::Window directly, which I find to be a
+somewhat annoying widget. I find it more convenient to operate
+via **Gtk::Runner**. I can also modify <b>Gtk::Runner</b>
+easily and, for instance, automatically add all custom CSS
+rules that I use onto it. So you can see that it is more
+flexible than subclassing from Gtk::Window directly.
-At any rate and without further ado, here come some specific examples.
+In the past, I used another approach, at the least for
+ruby-gtk3. Here I was subclassing from Gtk::Window directly,
+but since as of **March 2021** I simplified this old
+approach - now I use the very same approach for both
+ruby-gtk2 and ruby-gtk3 in this regard. That was one reason
+for the rewrite from gtk_module to gtk_paradise, by the
+way.
-Picking a proper font:
+Note that because of gtk3 changing things quite a bit, I
+created the directory called **base_module_and_runner_module/**,
+specifically for **ruby-gtk3**. I needed to improve support
+on the toplevel-instance directly.
-    font-family: Monospace;
-    font-family: Cantarell; # Or use this family.
+The simplest way for me is to <b>then</b> use **Gtk::BaseModule**
+via the following code in custom widgets:
-**Set the size of the font** at hand via CSS:
+    require 'gtk_paradise/requires/require_the_base_module.rb'
+    include ::Gtk::BaseModule
-    font-size: 20px; # don't forget to put this inside the {}
+Note that this is put in **requires/** - this should be guaranteed
+to work for a long time, even if I may change the code
+internally.
-Set the background colour of every window to a particular colour:
+It should never become any more complicated than these two
+lines.
-    window {
-      background-color: white; # replace with a colour of your choice; and use 'color' rather than 'colour'
-    }
+These two **prior** requires should then suffice, depending on
+whether you want to use gtk2 or gtk3:
-To make a button show a <b>hover-effect</b> (when the mouse is "above"
-the button), try:
+    require 'gtk_paradise/require_gtk2'
-    .button:hover {
-      padding: 12px 48px;
-      background-color: #4870bc;
-    }
+or
-(An alternative to the above CSS rule may be to make use of the method
-.override_background_color(), but here we focus primarily on CSS rules.)
+    require 'gtk_paradise/require_gtk3' # This one should be more common these days.
-It is possible to target specific children in a gtk-widget. For example,
-in order to specifically **style the first child of a gtk-widget**, such
-as a button, try the following CSS rule:
+So, put any (either, rather) of these two require lines on
+top of the .rb file at hand. If you are still unsure about
+the layout, simply look at the files that come distributed
+via the gtk_paradise gem. You will typically see them
+begin with this as the first line of ruby code.
-    .button:first-child {
-      border-radius: 5px 0 0 5px;
-    }
+I recommend to use gtk3 these days; the CSS rules are making
+it much more convenient to work with gtk3.
-Modify two widgets at the same time via the same CSS style - in this
-case a gtk-button and a gtk-entry:
+## Structure of the gtk_paradise project
-    button, entry {
-      color: #ff00ea;
-      font: 12px "Comic Sans";
-    }
+This subsection will include some information about the overall
+structure of the gtk_paradise project. This will **NOT** be
+complete; instead it merely provides some pointers. Note that
+this may become slightly deprecated over time, so consider it
+to be more of something that may have been correct at one point
+in time, but may have changed since then.
-You can also style / theme <b>insensitive widgets</b> in general,
-via:
+All files that are part of Gtk::BaseModule will reside under
+the subdirectory called **base_module/**.
-    *:disabled {
-      background-color: #320a91;
-    }
+The file **app.rb**, which can be found at **gtk_paradise/app/app.rb**,
+contains the code for the toplevel method call **Gtk.app()** -
+this one is aliased to **Gtk.run()**, which used to be the original
+name at one point in time.
-Theme the <b>labels</b> in the first notebook tab:
+This code can be used to **quickly start a gtk-widget**, and embed
+it into **Gtk::Window.new()** essentially. It reduces a bit of
+the necessary boilerplate code.
-    notebook tab:first-child label {
-      color: #89d012;
-    }
+Some of the default gtk-classes are modified by the gtk_paradise
+project. These modifications will be stored under the **gtk_classes/**
+subdirectory. The rule for entries in that directory is very simple:
+the name of the class will become the corresponding .rb file name.
-Theme the entry of a <b>Gtk::SpinButton</b> specifically:
+So class **Gtk::SourceBuffer** would reside at **gtk_classes/source_buffer.rb**.
+Note that not all modifications can be applied, for various reasons, but
+many of the default classes are modified. Remember this when using the
+gtk_paradise project: it is NOT a project for the 'default', assumed usage. For
+that you are recommended to use **vanilla** ruby-gtk instead, without
+the custom modifications done by the gtk-paradise project. The primary
+focus for the gtk_paradise project is to try to be of help when it
+comes to efficiency, when writing code - thus, the gtk_paradise
+project is more of an applied toolset project that tries to enhance
+the current status quo. (The ruby-gtk bindings are, unfortunately,
+mostly just a wrapper over the C API itself. This limits the way
+how users can think about application code.)
-    spinbutton entry {
-      color: #900185;
-    }
+## Demo
-Apply the green colour to every gtk-widget:
+The **gtk_paradise** gem comes with many example files, collected from
+different sources.
-    * {
-      color: green;
-    }
+If you want to use a controller-widget to show some of them, consider
+looking at the subdirectory examples/controller/, the controller.rb
+file there. This defaults to ruby-gtk3. One day it should work
+for both ruby-gtk2 and ruby-gtk3, but I prioritise on ruby-gtk3
+these days, so support for ruby-gtk2 may lag behind.
-If you want to style a Gtk::TextView widget, use a CSC rule like
-this:
+At any rate, run the controller.rb file to see what is available
+as demo. The basic idea is that the demo showcases all standalone
+examples, similar to main.rb of the official ruby-gnome / ruby-gtk
+bindings.
-    textview.view {
-      margin: 10px;
-      padding: 10px;
-      border: 2px solid rgba(0, 255, 255, 0.3);
-    }
+## How to determine the version of ruby-gtk?
-To make a <b>rounded border effect</b> you can use CSS rules such as the
-following
+First, use either:
-    button {
-      border: 6px solid steelblue;
-      border-radius: 8px;
-    }
+    require 'gtk2'
+    require 'gtk3' # or this one here for ruby-gtk3.
-Or, via an ID, use:
+Next, you can query some constants:
-    #button1 {
-      border: 6px solid steelblue;
-      border-radius: 8px;
-    }
+    pp ::Gtk::Version::MAJOR
+    pp ::Gtk::Version::MICRO
+    pp ::Gtk::Version::MINOR
+    pp ::Gtk::Version::STRING # => "2.24.32"
-You can also give each coordinate a different value, such as via.
+## Querying the GTK theme in use
-    .rounded_corner {
-      border-radius: 0px 0px 6px 6px;
-    }
+You can issue the following command in order to query the theme GTK is
+using:
-This would lead to rounded borders on the bottom, but not on the
-top. In general, though, I think each of these four values being
-the same looks a <b>lot</b> better.
+    gtk-query-settings theme
-Either way, adjust the values to your liking.
+### Gtk::Calendar
-Make <b>all selections</b> appear in <b>steelblue</b> colour can be
-done via:
+<b>Gtk::Calendar</b> can be used to show a calendar in your application.
-    selection {
-      color: steelblue;
-    }
+A new calendar can be instantiated in the following way:
-Use an unequal border-width (e. g. empty on one area):
+    calendar = Gtk::Calendar.new
-    border-width: 2px 0 2px 2px; # This setting would factually omit the right border.
-    .small_border { border-width: 2px 0 2px 2px; } # Ready for copy-paste. \o/
+Setting a different month can be done via the method
+<b>.select_month()</b>.
-If you have a need or use case to change the colour of the pulsing
-cursor in a gtk-entry or gtk-textview, also called a <b>caret</b>,
-then you could use something like this:
+### Gtk::CheckMenuItem
-    * {
-      caret-color: gold;
-    }
+Let's first show a small image, to indicate how this widget looks like
+in general:
-This would change the colour of the caret to gold. This may be useful
-if your gtk-entry has a black background colour and you want to
-change this to a more visible caret - hence gold. The example
-at <b>gtk_paradise/examples/advanced/025_showing_a_gold_caret_on_black_background.rb</b>
-shows this via a simple entry.
+<img src="https://i.imgur.com/pkipGZF.png" style="margin: 1em">
-You can also associate this with a specific CSS class or make
-the caret transparent, such as in:
+The Gtk::CheckMenuItem widget is that small arrow-icon, associated
+with a label-widget on the right side, such as can be seen by the
+'Toolbar' text or the 'Statusbar' text.
-    .my_label { caret-color: transparent; }
-    .foobar   { caret-color: green; }
+<b>Gtk::CheckMenuItem</b> is a subclass of Gtk::MenuItem.
-To give the whole window a fancy background, use a CSS rule such as
-the following (for <b>Gtk::Window</b>):
+This widget can be used to add a menu item that the user can select and
+deselect again. That way this menu element can be used as <b>a boolean
+toggle</b>, between <b>true</b> and <b>false</b>.
-    window {
-      background: linear-gradient(153deg, #151515, #151515 5px, transparent 5px) 0 0,
-                  linear-gradient(333deg, #151515, #151515 5px, transparent 5px) 10px 5px,
-                  linear-gradient(153deg, #222, #222 5px, transparent 5px) 0 5px,
-                  linear-gradient(333deg, #222, #222 5px, transparent 5px) 10px 10px,
-                  linear-gradient(90deg, #1b1b1b, #1b1b1b 10px, transparent 10px),
-                  linear-gradient(#1d1d1d, #1d1d1d 25%, #1a1a1a 25%, #1a1a1a 50%, transparent 50%, transparent 75%, #242424 75%, #242424);
-      background-color: #131313;
-      background-size: 20px 20px;
-    }
+Every time the user clicks on this item the value is changed, so it
+really acts like a <b>flip-switch</b>.
 ## Signals in GTK - showing the available signals and how to emit signals in ruby-gtk
@@ -1474,7 +1525,7 @@ attempt to be a complete API reference. But for now, only one entry is here. :)
     .signal_connect(:insert_text) # This is emitted in a Gtk::Entry when text is entered
 **GTK+** will emit the **"destroy"** signal when widget.destroy()
-is called.
+is called explicitely.
 Whenever a mouse button is pressed, a **button-press-event**
 signal is emitted.
@@ -1646,6 +1697,16 @@ added.
 <b>Gdk::Drawable</b> can be used for drawing. For instance, one
 can draw a rectangle of a pixbuf onto a <b>Gdk::Drawable</b>.
+Basically <b class="BOLD">Gdk::Drawable</b> is the base
+class for all objects that respond to <i>drawing commands</i>.
+The API is a bit complicated, such as:
+    .draw_drawable(@bgc, @buffer, rec.x, rec.y, rec.x, rec.y, rec.width, rec.height)
+The Gdk::Drawable interface enables one to draw lines, points,
+elliptical arcs, rectangles, text, or images.
 ## Gdk::GC
 <b>Gdk::GC</b> is the graphics context library, tasked with
@@ -2311,7 +2372,7 @@ in the desired colour.
 ## Gdk::Screen
-You can use **Gdk::Screen** to obtain the screen size, respectively the
+You can use <b>Gdk::Screen</b> to obtain the screen size, respectively the
 resolution.
 Example for this:
@@ -2320,23 +2381,24 @@ Example for this:
     x.width  # => 1920
     x.height # => 1080
+So, in other words, to obtain the default (current) screen you can use
+<b>screen = Gdk::Screen.default</b>.
 Getting the resolution right is quite important - in the past I used
 hardcoded values for my main monitor, which is quite large. But this
-does not work well on smaller laptop screens, so since as of **September
-2021** I am slowly transitioning all my ruby-gtk applications to use
+does not work well on smaller laptop screens, so since as of <b>September
+2021</b> I am slowly transitioning all my ruby-gtk applications to use
 a percentage value instead. So, rather than:
     set_width(1920)
-I may use:
+I may use this instead:
     set_width('80%')
-Note that in ruby-gtk4 <b>Gdk::Screen</b> is no longer available.
-The **upstream API documentation** for **Gdk::Screen** can be found here:
-https://ruby-gnome2.osdn.jp/hiki.cgi?Gdk%3A%3AScreen
+Note that in ruby-gtk4 <b>Gdk::Screen</b> is no longer available,
+which is rather unfortunate. I have not yet found a good replacement
+here.
 ## Gdk::PixbufLoader
@@ -2408,16 +2470,26 @@ The possible ColorSpaces are::
 ## GdkPixbuf::PixbufSimpleAnim
-You can instantiate a new **PixbufSimpleAnim** object via:
+If you wish to animate an image you could use class <b>GdkPixbuf::PixbufSimpleAnim</b>.
+You can instantiate a new <b>PixbufSimpleAnim</b> object via:
     pixbuf_simple_anim = Gdk::PixbufSimpleAnim.new(64, 64, 24)
-Individual frames can be added via .add_frame():
+The arguments to this class would be as follows:
+    * width:  the width of the animation (Fixnum)
+    * height: the height of the animation (Fixnum)
+    * rate: the speed of the animation, in frames per second (Float)
+    * Returns: a newly-created Gdk::PixbufSimpleAnim
+Individual frames can be added via <b>.add_frame()</b>:
     pixbuf_simple_anim.add_frame(pixbuf)
-This used to work for ruby-gtk2; I am not certain it still works
-in ruby-gtk3 though.
+This used to work for ruby-gtk2; I am not certain wheter it
+still works in ruby-gtk3 and ruby-gtk4, though - probably
+it does not.
 ## GdkPixbuf::PixbufAnimation
@@ -2592,6 +2664,10 @@ To set the name of a program in an about-dialog you can do this:
     about_dialog.set_program_name "Battery"
+To set the copyright use <b>.set_copyright()</b>:
+    about.set_copyright "(c) Jan Bodnar"
 You can assign a particular <b>logo</b> to be used via the following
 method:
@@ -2897,10 +2973,12 @@ This may then look like this:
 <img src="https://i.imgur.com/dXX8YVr.png" style="margin-left: 2em">
-The upstream API documentation in ruby-gtk for Gtk::Label can be found
-here:
+You can also use <b>colourized text</b> via the method called
+<b>set_markup</b>.
+The upstream API documentation for Labels in GTK4 can be found here:
-https://ruby-gnome2.osdn.jp/hiki.cgi?cmd=view&p=Gtk%3A%3ALabel
+https://docs.gtk.org/gtk4/class.Label.html
 ## Gtk::AccelLabel
@@ -3676,9 +3754,25 @@ Not all colours wered added in the .css file (project.css)
 yet. At some later time I may investigate this again, or
 simply autogenerate all these colours for use in CSS.
+## Gtk::ComboBox
+First, let's show a picture how a Gtk::ComboBox looked like
+in the days of ruby-gtk2:
+<img src="https://i.imgur.com/V81daiu.png" style="margin: 1em">
+If you need to set the active element of a <b>Gtk::ComboBox</b>
+then you can use the following API to achieve that:
+    combo_box.active = 0
 ## Gtk::ComboBoxText
-**Gtk::ComboBoxText** can be used in ruby-gtk3 to create a simple
+First, for a generic image of a combo-box-text, see the following image:
+<img src="https://i.imgur.com/MbTzdei.png" style="margin-left: 2em">
+<b>Gtk::ComboBoxText</b> can be used in ruby-gtk3 to create a simple
 combo-dropdown-box.
 The default listing is to show one entry per line. If you rather want
@@ -3688,11 +3782,12 @@ call:
     combo_box = Gtk::ComboBoxText.new # create a new instance of a combo box here
     combo_box.wrap_width = 7 # Use this here to set to 7 entries per row.
-To remove text do:
+To remove text do make use of the <b>.remove_text()</b> API:
     combo_box.remove_text(position)
-If you  ever have a use case to obtain the model used in a combo-box, try this:
+If you ever have a use case to obtain the model used in a combo-box, try the
+following API:
     model = combobox.model
     active = combobox.active # This will return e. g. -1
@@ -3701,7 +3796,7 @@ If you  ever have a use case to obtain the model used in a combo-box, try this:
     end
     return model[active][0]
-To respond to changes, modify the following code:
+To respond to changes of the combo-box, modify the following code:
     combo_box.signal_connect(:changed) { |widget, event|
       on_changed(widget, event, label)
@@ -3715,15 +3810,12 @@ This may look like this:
 <img src="https://i.imgur.com/ng9OH92.png" style="margin-left: 2em">
-For a generic image of a combo-box-text, see the following image:
-<img src="https://i.imgur.com/MbTzdei.png" style="margin-left: 2em">
 The official API documentation for ComboBoxText can be found here:
 https://docs.gtk.org/gtk3/class.ComboBoxText.html
-If you prefer the pygobject documentation, see here:
+If you prefer the pygobject documentation for a combo-box-text
+widget, see here the following documentation:
 https://lazka.github.io/pgi-docs/Gtk-3.0/classes/ComboBoxText.html
@@ -3916,7 +4008,7 @@ distributed in the gtk_paradise gem.
 ## Gtk::ErrorWidget - the error-widget (a custom add-on widget)
 This widget is just a gtk-entry really. I wanted something as an alternative
-to **Gtk::StatusBar**, though, with a nicer, more flexible API.
+to <b>Gtk::StatusBar</b>, though, with a nicer, more flexible API.
 Example:
@@ -4371,16 +4463,17 @@ field.
 ## Gtk::Frame
-A **Gtk::Frame** is a <b>Gtk::Bin</b> (a container) that adorns its
-child-widget via a frame, and an (optional) label.
+A <b>Gtk::Frame</b> is a <b>Gtk::Bin</b> (a container) that adorns
+its child-widget via a <b>frame</b>, and an (optional) label.
-Let's have a look at two examples, how a Gtk::Frame may look like:
+Let's have a look at two (visual) examples, how a Gtk::Frame may
+look like:
 <img src="https://i.imgur.com/qH7eErb.png" style="margin: 1em">
 <img src="https://i.imgur.com/SiqK7ou.png" style="margin: 1em">
-The syntax example for creating a <b>Gtk::Frame</b> in ruby-gtk
-is as follows:
+The vanilla syntax example for creating a <b>Gtk::Frame</b> in
+ruby-gtk is as follows:
     frame = Gtk::Frame.new('ID3 Tag')
     frame.label = label
@@ -4448,10 +4541,10 @@ To set it you could do:
     set_shadow_type(::Gtk::SHADOW_ETCHED_IN)
-The API documentation for <b>Gtk::Frame</b> in ruby-gtk
+The API documentation for <b>Gtk::Frame</b> in gtk4
 can be seen here:
-https://ruby-gnome2.osdn.jp/hiki.cgi?Gtk%3A%3AFrame
+https://docs.gtk.org/gtk4/class.Frame.html
 ## Gtk::HandleBox
@@ -4602,6 +4695,19 @@ class **Gtk::HtmlView** can be used to view HTML in a gtk-widget.
 It has been required via <b>require 'gtkhtml2'</b>, but has been
 unmaintained - and subsequently abandoned - many years ago.
+## Gtk::IconSize
+The allowed Gtk::IconSize values, at the least in ruby-gtk3,
+are:
+    IconSize::BUTTON
+    IconSize::DND
+    IconSize::DIALOG
+    IconSize::INVALID
+    IconSize::LARGE_TOOLBAR
+    IconSize::MENU
+    IconSize::SMALL_TOOLBAR
 ## Gtk::IconTheme
 **Icon themes** are available in ruby-gtk, via:
@@ -4667,7 +4773,7 @@ https://ruby-gnome2.osdn.jp/hiki.cgi?Gtk%3A%3AIconView
 ## Gtk::Image
-**Gtk::Image** can be used to display an image in the gtk application at
+<b>Gtk::Image</b> can be used to display an image in the gtk application at
 hand.
 Let's first show how to load an existing image:
@@ -4733,7 +4839,7 @@ such as this one here:
     widget = gdk_pixbuf
     widget.set_pixbuf(icon)
-To clear (== **remove**) an image again use this method call:
+To clear (== <b>remove</b>) an image again use this method call:
     image.clear
@@ -4771,16 +4877,27 @@ There are three possible values for a relief:
     Gtk::RELIEF_HALF
     Gtk::RELIEF_NONE
-For **rescaling an image** you may have to modify the pixbuf, before
+For <b>rescaling an image</b> you may have to modify the pixbuf, before
 then calling **Gtk::Image.new(pixbuf:)**. (In python this would look
 like this: <b>image = Gtk.Image.new_from_pixbuf(pixbuf)</b>.)
 If you <b>resize</b> a widget - thus a gtk-image - then the <b>"size-allocate"</b>
 signal is emitted.
-For the **upstream API documentation**, have a look at:
+It is possible to use some <b>padding</b> (x-Achse, y-Achse), via .set_padding():
+    @image.set_padding(10,40)
+    @image.clear # Or to clear the image again.
-https://ruby-gnome2.osdn.jp/hiki.cgi?Gtk%3A%3AImage
+You can also use stock-icons - examples for this follow:
+    Gtk::Image.new(stock_id, size)
+    Gtk::Image.new(Gtk::Stock::CONVERT, Gtk::IconSize::SMALL_TOOLBAR)
+For the **upstream API documentation** of GTK3, have a look at:
+https://docs.gtk.org/gtk3/class.Image.html
 ## Gtk::ImageViewer (a custom add-on widget)
@@ -5353,7 +5470,7 @@ An example for styling the separator is shown next:
       margin:  20px;
     }
-Modifying the inner **padding** can be done, as usual, via:
+Modifying the inner <b>padding</b> can be done, as usual, via:
     vpaned.set_border_width(5)
     # or this variant:
@@ -5510,18 +5627,36 @@ https://stackoverflow.com/questions/38907362/how-i-create-a-headermenu-with-a-po
 The **official upstream API documentation** for **Gtk::Popover**
 can be seen here:
-https://docs.gtk.org/gtk3/class.Popover.html
+https://docs.gtk.org/gtk3/class.Popover.html
+## Gtk::PrintOperation
+class <b>Gtk::PrintOperation</b> appears to be relevant for printing
+documents. I have not yet had a use case for using this class,
+though.
+## Gtk::Toolbar
+Gtk::Toolbar is deprecated, I believe, since as of GTK3.
+It used to look like this:
+<img src="https://i.imgur.com/vkGqpqd.png" style="margin: 1em">
-## Gtk::PrintOperation
+## Gtk::Tooltip
-class <b>Gtk::PrintOperation</b> appears to be relevant for printing
-documents. I have not yet had a use case for using this class,
-though.
+Via <b>tooltips</b> it is possible to use small, helpful <b>popups</b>.
+These will appear next to a widget - helpful hover elements.
+It is also possible to use markup, via .tooltip_markup=, such as
+via:
+    button.tooltip_markup = 'And this appears in <b>bold</b>.'
 ## Gtk::Tooltips (deprecated)
 Note that Gtk::Tooltips is deprecated; it could only be used in
-gtk2.
+<b>gtk2</b>.
 It used to look similar to this:
@@ -5769,27 +5904,27 @@ And then:
 ## Gtk::ScrolledWindow
-This represents **a window with a scrollbar**. It will attach <i>scrollbars</i>
-to the child-widget, and create a <b>Frame</b> surrounding this
-<b>child-widget</b>.
+A <b>Gtk::ScrolledWindow</b> represents <b>a window with a scrollbar</b>. It
+will attach <i>scrollbars</i> to the child-widget, and create a <b>Frame</b>
+surrounding this <b>child-widget</b>.
-The associated gdk-event for the scroll event is called <b>GDK_SCROLL</b>.
+The associated <b>gdk-event</b> for the scroll event is called <b>GDK_SCROLL</b>.
-Let's first have a look at how this may look - note that this was the default
-variant for ruby-gtk2; nowadays it looks a bit diffferent to ruby-gtk3:
+Let's next have a look at how this may look - note that the following image
+shows the old, the default variant for <b>ruby-gtk2</b>; nowadays it looks a
+bit diffferent, in <b>ruby-gtk3</b>:
 <img src="https://i.imgur.com/dlPHPDr.png" style="border: 1px solid black; margin-left: 4em;" id="drag_gtk_scrolled_window">
-Let's next show an example how to instantiate a new scrolled window then:
+Let's next show an example <b>how to instantiate a new scrolled window</b> then:
     scrolled_window = Gtk::ScrolledWindow.new
     scrolled_window = Gtk::ScrolledWindow.new(hadjustment = nil, vadjustment = nil)
 So-called "policies" determine whether the scrollbars are present. For
-instance, **Gtk::POLICY_ALWAYS** means that the scrollbars are always
+instance, <b>Gtk::POLICY_ALWAYS</b> means that the scrollbars are always
 present. **Gtk::POLICY_AUTOMATIC** on the other hand only shows the
 scrollbars when they are necessary.
 So, via <b>.set_policy()</b> one can designate whether horizontal and/or
 vertical scrollbars should be shown.
@@ -5814,7 +5949,7 @@ To determine a specific height or size, use:
     scrolled_window.set_size_request(175, 20)
 You can add a child-widget to a gtk-scrolled-window via
-**add_with_viewport()**.
+<b>add_with_viewport()</b>.
 Example:
@@ -5837,13 +5972,26 @@ be visible.
 <b>Gtk::POLICY_AUTOMATIC</b>: means that the scrollbars are only
 there when they are necessary.
+Note that you can determine <b>where</b> the <b>scrollbar</b>
+should appear, via the following constants:
+    CORNER_TOP_LEFT
+    CORNER_BOTTOM_LEFT
+    CORNER_TOP_RIGHT
+    CORNER_BOTTOM_RIGHT
+Specific example:
+    scrolled_window.window_placement = Gtk::CORNER_BOTTOM_LEFT
+    scrolled_window.window_placement = Gtk::CORNER_BOTTOM_RIGHT
 You can read more about this here:
 https://ruby-gnome2.osdn.jp/hiki.cgi?Gtk%3A%3AScrolledWindow#set_policy
-The **upstream API documentation** for **Gtk::ScrolledWindow** can be found here:
+Lazka also contains information about <b>Gtk::ScrolledWindow</b> here:
-https://ruby-gnome2.osdn.jp/hiki.cgi?Gtk%3A%3AScrolledWindow
+https://lazka.github.io/pgi-docs/Gtk-3.0/classes/ScrolledWindow.html
 ## Gtk::SearchBar
@@ -5955,7 +6103,15 @@ A specific line can be obtained via:
 ## Gtk::Sourceview
-You can install the sourceview bindings via **gem install**.
+Let's first look at an image of Gtk::Sourceview:
+<img src="https://i.imgur.com/9c3Ultx.png" style="margin: 1em">
+And another image of <b>Gtk::Sourceview</b>:
+<img src="https://i.imgur.com/TUmopVd.png" style="margin: 1em">
+You can install the sourceview bindings via <b>gem install</b>.
 After you did so, you can use it specifically, depending on the
 version at hand:
@@ -6005,10 +6161,10 @@ To show the margin, do:
     source_view.show_margin = true
-To specify a border width, use this:
+To specify a <b>border width</b>, use this:
     source_view.border_width = 4
 ## Gtk::Socket
 <b>Gtk::Socket</b> allows the user to make use of widgets from another
@@ -6172,7 +6328,11 @@ Other transition types are:
 ## Gtk::Statusbar
-**Gtk::Statusbar** can be used to provide a statusbar that is usually
+Let's first have a look at how the Gtk::Statusbar widget looks like:
+<img src="https://i.imgur.com/Fq3rdYO.png" style="margin: 1em">
+<b>Gtk::Statusbar</b> can be used to provide a statusbar that is usually
 on the bottom of the application.
 I am not sure if it is still recommended to use Gtk::Statusbar
@@ -6203,10 +6363,29 @@ If you want to remove a message you can use <b>.pop()</b>:
     status_bar.pop "Foobar" # Remove message here
     status_bar.pop @status_bar.get_context_id('main')
-Upstream documentation can be found here:
-https://ruby-gnome2.osdn.jp/hiki.cgi?Gtk%3A%3AStatusbar
+Note that the ID has to be unique. It can be obtained via
+the method <b>get_context_id</b>.
+    status_bar = Gtk::Statusbar.new','Statusbar
+    status_bar.has_resize_grip = true
+    status_bar_context_id = status_bar.get_context_id("A unique ID here")
+To add another message one can use <b>.push()</b>, as in:
+    status_bar.push(status_bar_context_id, "DSA4 Simulator") # Add the message here.
+To automatically change a given status-bar, threads can be used. Example:
+    x = Thread.new {
+      sleep 10
+      status_bar.push(status_bar_context_id, which_message)
+    }
+Upstream documentation for gtk3 in regards to <b>Statusbar</b> can
+be found here:
+https://docs.gtk.org/gtk3/class.Statusbar.html
 ## Gtk::StatusIcon
@@ -6255,7 +6434,11 @@ Let's look at an example of this first:
 <img src="https://i.imgur.com/1CGjOlx.png" style="margin: 1em; margin-left: 2em">
 This was an old implementation in ruby-gtk2 of the game called
-**mastermind**.
+<b>mastermind</b>.
+Let's look at another example:
+<img src="https://i.imgur.com/FZ9et3W.png" style="margin: 1em; margin-left: 2em">
 The basic syntax to create a new table in GTK goes like this:
@@ -6321,7 +6504,19 @@ More complex example:
 ## Gtk::TreeIter
-**Gtk::TreeIter** is a <b>reference</b> to a node in a given tree-model.
+<b>Gtk::TreeIter</b> is a <b>reference</b> to a node in a given tree-model.
+We thus can access the data in the model via such a TreeIter.
+To obtain the value of a TreeIter you can use the method .get_value(),
+as in:
+    .get_value(column)
+<b>Gtk::TreeIter</b> populates a <b>Gtk::ListStore</b>.
+The API documentation for TreeIter in gtk3 can be found here:
+https://docs.gtk.org/gtk3/struct.TreeIter.html
 ## Gtk::TimerWindow::TimerWindow
@@ -6636,7 +6831,7 @@ can use:
     tree_view.collapse_all
-The **upstream API documentation** for **Gtk::TreeView** in ruby-gtk
+The <b>upstream API documentation</b> for **Gtk::TreeView** in ruby-gtk
 can be found here (at the least before 2022):
 https://ruby-gnome2.osdn.jp/hiki.cgi?Gtk%3A%3ATreeView
@@ -6677,6 +6872,9 @@ To append a column to a Gtk::TreeViewColumn do:
     tree_view.append_column(column1)
     tree_view.append_column(column2)
+Rather than <b class="BOLD">.insert_column</b> one can use the simpler
+<b>append_column</b>, as the above example showed.
 To obtain the maximum width for a column, in pixels of the given
 tree column, use:
@@ -6745,6 +6943,16 @@ The typical syntax in a **Gtk::TreeStore** goes like this:
     Gtk::TreeStore.new(type1, type2, type3, ...)
+A more specific example of this follows:
+    tree_store = Gtk::TreeStore.new(
+      String,
+      String,
+      Gdk::Color,
+      Float,
+      GdkPixbuf::Pixbuf
+    )
 ## Gtk::TextTag
 Gtk::TextTag has various different properties.
@@ -6845,7 +7053,7 @@ value of the argument given to the method
 The vte-terminal can respond to a :child_exited event via:
     vte_terminal.signal_connect(:child_exited) { |widget|
-      exit_application
+      exit_application # Or call destroy() here.
     }
 You can send commands to Vte, via <b>.feed_child()</b>, such as
@@ -6897,7 +7105,7 @@ Pasting the clipboard content onto the terminal is possible via:
     vte_terminal.paste_clipboard
-The method **.span_sync** in python has this signature:
+The method <b>.span_sync</b> in python has the following signature:
     .spawn_sync(
       pty_flags,
@@ -6973,7 +7181,8 @@ and code:
 ## Gtk::Widget
-This is the base class for all gtk-widgets.
+This is the base class for all gtk-widgets. It is somewhat similar to
+the div-tag in HTML.
 It contains convenience methods such as:
@@ -7121,6 +7330,10 @@ then you can simply query this via:
     pp text_view.wrap_mode
+To obtain the buffer one can use .buffer:
+    buffer = @text_view.buffer
 The official API documentation for <b>Gtk::TextView</b> in ruby-gtk can
 be seen here:
@@ -7196,18 +7409,15 @@ to the values of the scale-button.
 For scaling an image values such as **Gdk.InterpType.Hyper** are
 important. Make sure to read up on them.
-**HYPER** is the slowest but highest quality reconstruction
-function. It is derived from the hyperbolic filters in Wolberg's
-"Digital Image Warping", and is formally defined as the
-hyperbolic-filter sampling the ideal hyperbolic-filter
-interpolated image. The filter is designed to be idempotent
-for 1:1 pixel mapping. Note that this interpolation filter
-is deprecated, as in reality it has a lower quality than the
-**GDK_INTERP_BILINEAR** filter since as of gtk 2.38. So
-for ruby-gtk3 this means **:bilinear**. Other values are
-**:nearest**. Note that **::nearest** is the fastest, so if
-you go for speed, consider using this variant. Be aware
-that **scaling down** will lead to a bad quality though.
+<b>HYPER</b> is the slowest but highest quality reconstruction function. It is
+derived from the hyperbolic filters in Wolberg's "Digital Image Warping", and
+is formally defined as the hyperbolic-filter sampling the ideal hyperbolic-filter
+interpolated image. The filter is designed to be idempotent for 1:1 pixel mapping.
+Note that this interpolation filter is deprecated, as in reality it has a lower
+quality than the **GDK_INTERP_BILINEAR** filter since as of gtk 2.38. So for
+ruby-gtk3 this means **:bilinear**. Other values are **:nearest**. Note that
+<b>::nearest</b> is the fastest, so if you go for speed, consider using this
+variant. Be aware that <b>scaling down</b> will lead to a bad quality though.
 More documentation about these InterpType values can be
 read here:
@@ -7220,7 +7430,7 @@ https://ruby-gnome2.osdn.jp/hiki.cgi?Gtk%3A%3AScale
 ## Gtk::IconFactory
-Gtk::IconFactory can be used to handle different Gtk::IconSet instances.
+<b>Gtk::IconFactory</b> can be used to handle different Gtk::IconSet instances.
 Usage example:
@@ -7263,7 +7473,7 @@ next example for the 'raw' ruby-gtk variant to use:
     }
 As the example above shows, you can in general connect to the
-event when a button is clicked via **.signal_connect(:clicked)**.
+event when a button is clicked via <b>.signal_connect(:clicked)</b>.
 Make the window resizable (which is the default, anyway):
@@ -7273,9 +7483,12 @@ Specify a width and height value for the window:
     window.set_size_request(250, 250)
-Use inner **padding** via:
+To set the border-width - in HTML and CSS this may be
+similar to <b>border-width: 1px</b>, use inner
+<b>padding</b> via:
     window.border_width = 10
+    window.border_width =  1
 If you do not need decoration in the window, such as the top bar
 that contains the minimize or quit application button, nor
@@ -7327,6 +7540,22 @@ queried for a confirmation dialogue, such as:
 <b>Are you really certain that you wish to close the window?</b>
+To destroy the Gtk::Window you can use the following code:
+    window.signal_connect(:destroy) { Gtk.main_quit }
+To set the width of the border (aka the margin), you can use this
+code:
+    window.set_border_width(2)
+Or the alias called .border_width =:
+    window.border_width = 12
+This also works on <b>Buttons</b> and many other widgets, of
+course.
 ## Gtk::Dialog and dialog-response in ruby-gtk3
 Let's show a few images to show how this may look:
@@ -7357,7 +7586,7 @@ You can combine them like so:
     Gtk::Dialog::MODAL|Gtk::Dialog::NO_SEPARATOR
-**Buttons** can be added like so, via
+<b>Buttons</b> can be added like so, via
 **Gtk::Dialog#add_button(button_text, response_id)**:
     add_button('OK', :ok)
@@ -7557,7 +7786,7 @@ to the focus_vadjustment of another widget.
 ## Gtk::ListStore and filtering on Gtk::ListStore
 Let's begin this subsection with a few syntax-examples, to get you
-to understand how **Gtk::ListStore** is properly used.
+to understand how <b>Gtk::ListStore</b> is properly used.
     list_store = Gtk::ListStore.new(type1, type2, type3, type4, ...)','ListStore
     list_store = Gtk::ListStore.new(String, String)
@@ -7607,11 +7836,16 @@ can be used, like this:
 ## Gtk::TextBuffer and Gtk::TextBufferTags - selections in a TextBuffer widget and how to make use of Gtk::TextBuffer
-You can **style text** in gtk by tapping into the corresponding <b>Iter</b>
+First, let's look at an image of using colours in a Gtk::TextBuffer -
+this may simplify reasoning about as to what this widget does:
+<img src="https://i.imgur.com/rjmB1Nb.png" style="margin: 1em">
+You can <b>style text</b> in gtk by tapping into the corresponding <b>Iter</b>
 in the buffer. An Iter will point to a particular place in a buffer,
 and associates that area with a particular tag.
-The **module Gtk::TextBufferTags** was once used to create
+The <b>module Gtk::TextBufferTags</b> was once used to create
 several tags, for use in a gtk-buffer.
 I have not updated this in many years, so I am not sure how useful
@@ -7646,9 +7880,9 @@ follows:
     start_position, end_position = buffer.selection_bounds # Returns: [start, end, selected]
     text = buffer.get_text(start_position, end_position, false)
-This is now stored in the variable **text**.
+This is now stored in the variable <b>text</b>.
-If you want to make use of **markup** in a **Gtk::TextBuffer** then
+If you want to make use of **markup** in a <b>Gtk::TextBuffer</b> then
 you can try something like this:
     buffer = @view.buffer
@@ -7676,7 +7910,7 @@ For a gray background, consider using this:
     grey_background = text_buffer.create_tag(nil, { background: 'gray' })
-See also the example file at **text_iterator_example.rb**.
+See also the example file at <b>text_iterator_example.rb</b>.
 To **paste the clipboard** into the buffer, do:
@@ -7762,7 +7996,7 @@ The method will delete the range between the "insert" and
 text. If interactive is True, the editability of the selection
 will be considered (users can not delete uneditable text).
-Interestingly **Gtk::TextBuffer** does not have **Gtk::Widget**
+Interestingly <b>Gtk::TextBuffer</b> does not have **Gtk::Widget**
 as a superclass. Its direct superclass is **GLib::Object**.
 This surprised me because the custom <b>.on_changed method</b>
 defined in Gtk::Widget, as part of the gtk_paradise gem, was not
@@ -7775,7 +8009,7 @@ https://ruby-gnome2.osdn.jp/hiki.cgi?Gtk%3A%3ATextBuffer
 ## Gtk::Button and other buttons in ruby-gtk3, including the method gtk_button()
-A **button** is a basic element for any **GUI** (graphical user interface).
+A <b>button</b> is a basic element for any **GUI** (graphical user interface).
 It typically responds to different events, most importantly the
 "clicked" event, which is triggered when the user clicks on the
@@ -7881,9 +8115,17 @@ surroundung area of a button via the **border** property. You
 can also embed the button into a gtk-container, which can then
 be styled additionally too.
-The **upstream API documentation** for **Gtk::Button** can be found here:
+Buttons in GTK also have certain flags, such as <b>CAN_FOCUS</b>,
+which can be set via .set_flags().
+Example for this:
+    button_quit.set_flags(Gtk::Widget::CAN_FOCUS)
+The **upstream API documentation** for **Gtk::Button** can be found here,
+for GTK4:
-https://ruby-gnome2.osdn.jp/hiki.cgi?Gtk%3A%3AButton
+https://docs.gtk.org/gtk4/class.Button.html
 ## Gtk::Entry, including use cases such as a password widget
@@ -8075,7 +8317,7 @@ https://ruby-gnome2.osdn.jp/hiki.cgi?Gtk%3A%3AEntry
 ## Gtk::Grid and gtk_grid()
-**class Gtk::Grid** can be used to position widgets in a grid-like
+<b>class Gtk::Grid</b> can be used to position widgets in a grid-like
 layout. It is available since as of **GTK version 3**.
 First: here is the upstream API for **.attach()**. I added this because
@@ -8089,7 +8331,7 @@ I keep on forgetting what the individual entries mean.
       int height = 1
     )
-So this is - **left**, **top**, **width**, **height**.
+So this is - **left**, **top**, **width**, <b>height</b>.
 The method .attach() will add a widget to the grid. It requires
 5 parameters in total.
@@ -8136,7 +8378,7 @@ Example for this:
     @grid = gtk_grid
     @grid.set_column_spacing(6) # To specify the spacing (distance) between the individual columns.
     @grid.set_row_spacing(6)
-    left_entry = gtk_entry('LEFT ENTRY')
+    left_entry = create_entry('LEFT ENTRY')
     left_entry.set_size_request(600, 42)
     @grid.attach(left_entry, 0, 0, 2, 1)
@@ -8196,6 +8438,10 @@ Row-spacing and column-spacing can be set as well via:
     grid.set_row_spacing(12)
     grid.set_column_spacing(12)
+The API documentation for gtk-grid in gtk3 can be seen here:
+https://docs.gtk.org/gtk3/class.Grid.html
 For more documentation pertaining to <b>Gtk::Grid</b>, at the
 least for GTK4, you can read up more here:
@@ -8438,6 +8684,13 @@ An example is shown next:
     rgba_object.parse(:silver)
     button.override_background_color(:normal, rgba_object)
+So via override_background_color() we can set other colours.
+Here is a specific example where all four values are
+provided to Gdk::RGBA:
+    gtk_widget.override_background_color(:normal,Gdk::RGBA.new(0.02, 0.02, 0.02, 1))
 ## Which Gtk::Stock icons are available?
 Well, I am not sure how to dynamically query this, but here is just
@@ -8796,9 +9049,8 @@ The default size of Gtk.Window should be set via:
     window.set_default_size()
     window.set_default_size(width, height)
-This should work if you desire to specify the width
-and height that window should occupy. The values
-will be in n pixel.
+This should work if you desire to specify the width and height that
+window should occupy. The values will be in n pixel.
 ## Pending events
@@ -9041,13 +9293,13 @@ This will use the **right-pointing arrow emoji**.
 I found that this can be useful if you do not want to make
 use of an image.
-Not all emojis can be accessed like this so far; stay tuned
-for more emojis to be added at a later time. These will be
-stored in the file at **gtk_paradise/emojis/emojis.rb**.
+Not all emojis can be accessed like this so far; stay tuned for more emojis to
+be added at a later time. These will be stored in the file at
+<b>gtk_paradise/emojis/emojis.rb</b>.
 (Internally this will all be handled by the custom modification
 within **Gtk::Emojis**, which is part of the **gtk_paradise**
-project. The submodule is called **Gtk::Emojis**, unsurprisingly
+project. The submodule is called <b>Gtk::Emojis</b>, unsurprisingly
 so.)
 Note that there is also a widget called **EmojiWidget**, as
@@ -9191,7 +9443,7 @@ project.
 ## How to add widgets into Gtk::Runner
-**Gtk::Runner** offers a simplified way to quickly run other
+<b>Gtk::Runner</b> offers a simplified way to quickly run other
 gtk-widgets.
 It was created primarily so that we can reduce the amount of
@@ -9313,7 +9565,7 @@ Or you can use this toplevel method:
 If you wish to quickly show the content of a file,
 have a look at:
-    require 'gtk_paradise/gtk_classes/text_view.rb'
+    require 'gtk_paradise/core_classes/text_view.rb'
     Gtk.display_this_file(ARGV)
     Gtk.display_this_file('/foo/bar.md')
@@ -9529,7 +9781,7 @@ the gtk_paradise project, via:
 The first variable is the widget; the second one is the array that
 keeps track of the gtk-radio-buttons. You can use the method
-**.active?** on them to find out which entry is selected.
+<b>.active?</b> on them to find out which entry is selected.
 Example for this, using the code above:
@@ -9661,9 +9913,8 @@ just an attempt at a little helpful information.
 ## Key events (keyboard button pressed)
-To find out whether the user used the down-arrow key,
-on an instance of Gtk::Runner, you could use this
-code:
+To find out whether the user used the down-arrow key, on an instance
+of <b>Gtk::Runner</b>, you could use this code:
     r.signal_connect(:key_press_event) {|widget, event|
       if event.is_key?(:down)
@@ -10320,6 +10571,15 @@ and start from scratch in this regard. The gtk_paradise CSS files can
 be used as a substitute for now, as well as .more_css() on an
 ad-hoc basis for now.
+## Gstreamer
+Working with gstreamer can be a little bit complicated.
+To make use of the Gst-framework, such as by finding the MAD
+audio codec, the following API can be used:
+    element_factory = Gst::ElementFactory.find("mad")
 ## Cairo
 This subsection may contain some semi-random information about **cairo**.
@@ -10535,7 +10795,7 @@ Examples how to do this:
 **gtk_paradise --tabble** will now default to ruby-gtk3. Make sure
 you have the ruby-gtk bindings installed and work properly!
-In **August 2021** the tabble-specific code that was part of
+In <b>August 2021</b> the tabble-specific code that was part of
 **gtk_paradise** has been rewritten. During the rewrite support
 for ruby-gtk2 has been dropped, unfortunately. Perhaps at a
 later time I may re-enable this, but gtk3 is really so much
@@ -10554,13 +10814,13 @@ again one day.
 These are as follows - at the least for ruby-gtk2:
-    <b>STATE_ACTIVE</b>: State of a currently active widget, such as a de-pressed button.
+    <b>STATE_ACTIVE</b>:      State of a currently active widget, such as a de-pressed button.
-    <b>STATE_NORMAL</b>: State during normal operation
+    <b>STATE_NORMAL</b>:      State during normal operation
-    <b>STATE_PRELIGHT</b>: State indicating that the mouse pointer is over the widget and the widget will respond to mouse clicks.
+    <b>STATE_PRELIGHT</b>:    State indicating that the mouse pointer is over the widget and the widget will respond to mouse clicks.
-    <b>STATE_SELECTED</b>: State of a selected item, such the selected row in a list.
+    <b>STATE_SELECTED</b>:    State of a selected item, such the selected row in a list.
     <b>STATE_INSENSITIVE</b>: State indicating that the widget is unresponsive to user actions.'
@@ -10647,7 +10907,7 @@ you could use this code - at the least in ruby-gtk2:
 The following should work if you use the Gtk::BaseModule:
-    entry = gtk_entry('Some text here')
+    entry = create_entry('Some text here')
     entry.on_mouse_double_click_event {|widget, event|
       do_call_a_method_here
     }
@@ -10659,6 +10919,22 @@ in the event that it presently does not work correctly.
 In my limited findings and tests it did work already, so - who
 knows.
+The general way to let a Gtk::Window to a double-click event,
+at the least in ruby-gtk2 and possibly in ruby-gtk3,
+was this way:
+    window.add_events(:button_press_mask)
+    window.signal_connect(:button_press_event) { |widget, event|
+      if event.event_type == Gdk::Event::BUTTON2_PRESS
+        p "double click" #
+      elsif event.event_type == Gdk::Event::BUTTON3_PRESS
+        p "triple click"
+      elseif event.event_type == Gdk::Event::BUTTON_PRESS
+        p "(should be) one click"
+      end
+    }
 ## Border-related settings and supported CSS properties related to borders in GTK
 This subsection may become outdated as time passes by, so I add the information
@@ -11001,6 +11277,14 @@ bases. Thus, as of past December 2021, support for ruby-gtk2 is very
 **slightly** deprecated, at the least in regards to **new** code. Old
 code should be supported for a much longer time.
+## Gtk.gtk_runner_factory
+Typical usage example for this is:
+    ::Gtk.gtk_runner_factory(
+      ::Bioroebe::GUI::Gtk::ThreeToOne.new(i)
+    )
 ## Setting the title, width, height and font of a gtk-widget
 If you use the integrated **Gtk::BaseModule** then you can use
@@ -11029,9 +11313,9 @@ to memorize.
 Usage example follows, via **Gtk::BaseModule**:
-    hbox = gtk_hbox
+    hbox = create_hbox
     # Or if you want to use it via spacing:
-    hbox = gtk_hbox {{ spacing: 10 }}
+    hbox = create_hbox {{ spacing: 10 }}
     # Now you can add other widgets into this hbox:
     hbox << bold_text('!!! OK !!!')
     hbox.rounded_border('12px', :default, '25px solid royalblue')
@@ -11461,11 +11745,10 @@ Another interesting gem is **nyle**, see here:
 https://rubygems.org/gems/nyle
-This one is specifically for gtk3 and has a few games,
-too. Unfortunately the code is a bit ... peculiar, so
-it is hard to benefit from it. This is a problem I see
-with many ruby gems out there - they are not easily
-compatible to one another.
+This one is specifically for gtk3 and has a few games, too. Unfortunately the
+code is a bit ... peculiar, so it is hard to benefit from it. This is a problem
+I see with many ruby gems out there - they are not easily compatible to one
+another.
 Here is a hint in how to resize a gtk-image:
@@ -11838,13 +12121,9 @@ bg: the background color(Gdk::Color), used for the bits in
   when 'KP_Home'
   when 'KP_Page_Up'")
-# ======================================================================= #
-# === Gtk::TreeStore TAG. tree store tag.
-#
-# ======================================================================= #
-div(css_class: 'default extra_css', css_style: 'padding: 1em', id: 'gtk_tree_store') {
-  @tree_store = Gtk::TreeStore.new(
-  String, String, Gdk::Color, Float, GdkPixbuf::Pixbuf)
+# === Gtk::TreeStore
   Wobei die Argumente für die columns stehen,
   und bestimmte Typen haben, zb Integer oder String.
@@ -11890,19 +12169,6 @@ div(css_class: 'default extra_css', css_style: 'padding: 1em', id: 'gtk_tree_sto
     @root_iter[2] = Gdk::Color.new(0, 65535, 0)
     @root_iter[3] = 5.0
-# ======================================================================= #
-# === Gtk::TreeIter GTK TREEITER tag.
-# ======================================================================= #
-  Mittels Iter erhält man somit eine Schnittstelle zu einem
-  bestimmten Model.', '','gtk_tree_iter
-  Seinen Wert erhält man so:
-    .get_value(column)
-  <b>TreeIter</b> populiert Gtk::ListStore.
 # ======================================================================= #
 # === Erweitern von GTK
 # ======================================================================= #
@@ -12075,26 +12341,12 @@ div(css_class: 'default extra_css', css_style: 'padding: 1em', id: 'gtk_tree_vie
   Über cell braucht man sich nicht viel Gedanken zu machen, da
   reicht folgendes:', id: 'gtk_renderer
-  # ===================================================================== #
-  # === Gtk::CellRendererText
-  # ===================================================================== #
-    @renderer = Gtk::CellRendererText.new
-  s2('Mehr über <b>CellRendererText</b> siehe an anderer Stelle und
-  zwar (<i>intern</i>)
-  a('#gtk_cell_renderer_text',
-    content: 'hier',
-    css_class: 'BO'
   e("Und erstellt danach eine neue <b>Gtk::TreeViewColumn</b>,
   mit inseriertem Gtk::TreeView's an der angegebenen
   <b>position</b>.
-  # === .insert_column()
-  Anstatt <b class="BOLD">.insert_column</b> kann man auch das
-  einfachere <b>append_column</b> verwenden.
   Dazu nutzen wir TreeViewColumn - siehe an anderer Stelle
   in diesem Dokument.
@@ -12165,7 +12417,6 @@ div(css_class: 'default extra_css', css_style: 'padding: 1em', id: 'gtk_tree_vie
   'elsif event.event_type == Gdk::Event::BUTTON_PRESS
   p "(should be) one click here"
   'end
   Auf das loslassen kann man wie folgt reagieren:
   @tree_view.signal_connect(:button_release_event)
@@ -12230,15 +12481,11 @@ div(css_class: 'default extra_css', css_style: 'padding: 1em', id: 'gtk_tree_vie
 # ======================================================================= #
 # === GTK MAIN, gtk tag
 # ======================================================================= #
-div(css_class: 'default extra_css', css_style: 'padding: 1em', id: 'gtk_main') {
 ## Gtk.main','gtk_main
   Zum Ausführen des <b>Main Events</b> (kommt meistens am Schluss):
     Gtk.main
-  Explizit kann man Fenster auch mittels destroy zerstören:
-    @window.destroy
   Explizites positionieren ist auch einfach, wie zum Beispiel so:
@@ -12461,6 +12708,7 @@ div(css_class: 'default extra_css', css_style: 'padding: 1em', id: 'gtk_tree_vie
   Gtk::Label.new.set_markup(%Q(<span weight="bold" foreground="#009999">_Test</span>), true)
   Gtk::Label.new.set_markup(%Q(<span style="italic"
   weight="bold" foreground="#abc">_Test</span>),
   true)
@@ -12712,11 +12960,11 @@ div(css_class: 'default extra_css', css_style: 'padding: 1em', id: 'dnd') {
   Den Wert einer ComboBox erhält man so:
-  "@combo_box.signal_connect(:changed) {
-  if @combo_box.active_iter
+  @combo_box.signal_connect(:changed) {
+    if @combo_box.active_iter
       p "- #@combo_box.activeend: #@combo_box.active_iter[0]"
-  end
-  '}
+    end
+  }
   Immer wenn es geändert wurde, fragen wir die Nummer des Entry ab
   (mit <b>.active</b>) und mit .active_iter[0] erhält man den
@@ -13091,22 +13339,9 @@ div(css_class: 'default extra_css', css_style: 'padding: 1em', id: 'gtk_entry')
   when Gdk::EventScroll::UP
   when Gdk::EventScroll::DOWN
-# ======================================================================= #
-# === Gtk::ComboBox               (combo box tag)
-#
-# GTK KEYBOARD TASTEN EINLESEN, KEYBOARD GTK COMBO BOX Gdk::EventKey
-# combobox tag.
-#
-# Remote URL is:
-#
-#   http://ruby-gnome2.osdn.jp/hiki.cgi?Gtk%3A%3AComboBox
-#
-#   rf ruby gtk_combo_box
-#
-# ======================================================================= #
-# http://localhost/DATA/viewer/ruby_viewer.cgi#gtk_combo_box
-# ======================================================================= #
-div(css_class: 'default extra_css', css_style: 'padding: 1em', id: 'gtk_combo_box') {
+id: 'gtk_combo_box'
 ## Gtk::ComboBox und GTK KEYBOARD (TASTEN EINLESEN)
   <b>keyval</b> ist die Methode, um den Wert der Taste herauszufinden.
   Siehe auch nächster Absatz.
@@ -13148,9 +13383,6 @@ div(css_class: 'default extra_css', css_style: 'padding: 1em', id: 'gtk_combo_bo
     %w( abc def ghi ).each { |value| combo_box.append_text(value) }
-  Das Setzen eines aktiven Elementes geht so: # activate comboboxentry
-    @combo_box.active = 0
   Um herauszufinden welcher Eintrag gerade aktiv ist funktioniert
   dies hier:
@@ -13161,7 +13393,7 @@ div(css_class: 'default extra_css', css_style: 'padding: 1em', id: 'gtk_combo_bo
   am rechten Bild zeigen wir einfach eine Kombination
   diverser Möglichkeiten):
-  gtk_img('COMBO_BOX2.png','bblack1 marl2em mar1em', :drag)+
   gtk_img('COMBOBOX_ALL_IN_ONE_EXAMPLE.png','bblack1 marl2em mar1em', :drag)+
@@ -14308,12 +14540,11 @@ br+
   # ===================================================================== #
   # === Flags im button
   # ===================================================================== #
-  Jeder <b>gtk-button</b> hat bestimmte Flags, die verändert werden
-  können - im folgenden Beispiel (<b>CAN_FOCUS</b>):
-    @button_quit.set_flags(Gtk::Widget::CAN_FOCUS)
-  lem3('(<b class="BOLD">.set_flags()</b> ist übrigens Widget spezifisch,
+    (<b class="BOLD">.set_flags()</b> ist übrigens Widget spezifisch,
   nicht Button spezifisch.)
   Anstatt set_flags kann man auch dies nutzen:
@@ -14337,16 +14568,8 @@ br+
   Gtk.main_quit
   }
-  Ich verwende jedoch keine proc-callbacks mehr seit
-  einigen Jahren; meiner Meinung nach sind einfache Methoden
-  einfacher und logischer als proc-callbacks.
-  # ===================================================================== #
   # === Gtk Relief
-  # ===================================================================== #
-  Ein <b>Relief</b> setzen kann man wie im folgenden
-  Beispiel gezeigt:','','gtk_relief
   (RELIEF_NORMAL ist der Default Zustand, RELIEF_NONE
@@ -15245,13 +15468,10 @@ div(css_class: 'default extra_css', css_style: 'padding: 1em', id: 'gtk_label')
 # ======================================================================= #
 # === Gdk TAG
 # ======================================================================= #
-div(css_class: 'default extra_css', css_style: 'padding: 1em', id: 'gdk_gdk') {
-## Alles über GDK','gdk
   Weitere Beispiele zu Gdk:
-  Gtk::grab_add(self)','gdk
+  Gtk.grab_add(self)
   unless Gdk::pointer_is_grabbed?
       Gdk::pointer_grab(self.window, false,
@@ -15262,7 +15482,7 @@ div(css_class: 'default extra_css', css_style: 'padding: 1em', id: 'gdk_gdk') {
       Gdk::Event::CURRENT_TIME)
   end
-  if Gdk::pointer_is_grabbed?
+  if Gdk.pointer_is_grabbed?
       Gdk::pointer_ungrab(Gdk::Event::CURRENT_TIME)
       Gtk::grab_remove(self)
   end
@@ -15291,10 +15511,6 @@ div(css_class: 'default extra_css', css_style: 'padding: 1em', id: 'gdk_gdk') {
   p Gdk.pointer_is_grabbed?
-  Den aktuellen Screen kann man so abgreifen:
-    @screen = Gdk::Screen.default
   Werte innerhalb dieses @screen kann man so erhalten:
     @screen.get_setting("gtk-double-click-time")
@@ -15319,18 +15535,9 @@ div(css_class: 'default extra_css', css_style: 'padding: 1em', id: 'gdk_gdk') {
   a(WIKI_URL+'Gdk', content: 'Gdk')
 # ======================================================================= #
-# === GDK Drawable gdk_drawable tag.
+# === GDK Drawable gdk_drawable tag
 # ======================================================================= #
-div(css_class: 'default extra_css', css_style: 'padding: 1em', id: 'drawable') {
-## GDK Drawable','gdk_drawable
-  <b class="BOLD">Gdk::Drawable</b> ist die Grundklasse für alle Objekte,
-  die <i>drawing commands</i> akzeptieren.','','draw
-    .draw_drawable(@bgc, @buffer, rec.x, rec.y,
-  rec.x, rec.y, rec.width, rec.height)
-  The Gdk::Drawable interface enables one to draw lines,
-  points, elliptical arcs, rectangles, text, or images.
+## Gdk::Drawable
   Um <b class="BOLD">Gdk::Drawable</b> verwenden zu können benötigt
   man eine Instanz von <b class="BOLD">Gdk::GC</b>
@@ -15452,15 +15659,6 @@ require 'gst'
   (Der Ausdruck link points bzw pads kommt vom Löten.
   pads sind Drähte, die angelötet werden können.
-  # ===================================================================== #
-  # gst element factory
-  # ===================================================================== #
-  h3('Gstreamer und Element Factory
-  Zum Erstellen eines Gstreamer Framework, das MAD versteht,
-  würde wohl folgender Code helfen:
-    @element_factory = Gst::ElementFactory.find("mad")
-')
 # ======================================================================= #
 # === GLIB TAG
@@ -15540,11 +15738,7 @@ self.signal_new :value2_changed, GLib::Signal::RUN_FIRST, nil, GLib::Type['void'
 # ======================================================================= #
 div(css_class: 'default extra_css', css_style: 'padding: 1em', id: 'gdk_colours') {
 ## Gdk::Colour - Farben in GTK/Gdk','gdk_colour
-    include Gtk::Colours','Color
-  Den Background eines Widgets verändern geht wie folgt:','','Colour
     self.modify_bg(Gtk::STATE_NORMAL, BLACK)','colours
     self.modify_bg(Gtk::STATE_NORMAL, DARKBLUE)
@@ -15556,9 +15750,6 @@ div(css_class: 'default extra_css', css_style: 'padding: 1em', id: 'gdk_colours'
   einem also keine besseren Farben einfallen für seine Applikation,
   dann ist dies wohl eine Option.
-  <b>Farbigen Text</b> kann man auch erreichen, allerdings ist
-  dies etwas umständlich, denn es geschieht über <b>GTK::Label.new</b>,
-  und der Methode <b>set_markup</b>','','gtk_markup
 # ======================================================================= #
@@ -15696,11 +15887,6 @@ div(css_class: 'default extra_css', css_style: 'padding: 1em', id: 'gtk_event_ke
     Gtk::VBox.new(homogeneous = false, spacing = nil
     @v_box = Gtk::VBox.new(false,10)
-  a('http://ruby-gnome2.sourceforge.jp/hiki.cgi?cmd=view&p=Gtk%3A%3AContainer&key=set_border_width#set_border_width',
-    content: 'Hier etabliert'
   Nun kann man Methoden wie <b>pack_start</b> und <b>pack_end</b>
   verwenden, oder einfach nur die altbekannte <b>.add</b> Methode. # add tag
@@ -16324,11 +16510,6 @@ div(css_class: 'default extra_css', css_style: 'padding: 1em', id: 'modify_a_fon
   Damit man einen Überblick hat wie das dann mit diesem
   <b>Spacing</b> aussieht:
-  # ===================================================================== #
-  # === EXAMPLE_TABLE.png
-  # ===================================================================== #
-  gtk_image('EXAMPLE_TABLE.png','bblack1 mars3em mar3px
   Hier ein weiteres Beispiel einer Gtk::Table, die in einem
   Gtk::Frame vorzufinden ist:
   # ===================================================================== #
@@ -16453,16 +16634,8 @@ div(css_class: 'default extra_css', css_style: 'padding: 1em', id: 'modify_a_fon
 #   rf rubygtk gtk_toolbar
 #
 # ======================================================================= #
-# http://localhost/DATA/viewer/ruby_viewer.cgi#gtk_toolbar
-# ======================================================================= #
-## Gtk::Toolbar','gtk_toolbar
-  Eine GTK Toolbar','BO s1em larger
-  Eine Toolbar ist eine Leiste mit Icons, Buttons und anderen
-  Widgets, und sieht ungefähr so aus:
-  gtk_image('TOOLBAR.png','mars2em', :drag)+
+## Gtk::Toolbar
   gtk_image('SMALL_TOOLBAR_EXAMPLE.png',
     'mars2em bblack2', 'drag_small_toolbar_example'
@@ -16607,20 +16780,6 @@ div(css_class: 'default extra_css', css_style: 'padding: 1em', id: 'gtk3') {
     @status_icon.set_blinking(true)
-# ======================================================================= #
-# === Gtk::Tooltip.new
-# ======================================================================= #
-## Gtk::Tooltip','gtk_tooltip
-  Einen Tooltip zu verwenden der fette Schrift inkludiert,
-  geht so:
-  @button1.tooltip_markup = 'And this appears in <b>bold</b>.'
-  Dokumentation zu <b>Gtk::Tooltip</b> sieht man hier:
-  a('http://ruby-gnome2.sourceforge.jp/hiki.cgi?Gtk%3A%3ATooltip',content:'SELF
 # ======================================================================= #
 # === Gtk::ListStore GTK LISTSTORE TAG. list store tag.
 #
@@ -16815,10 +16974,10 @@ div(css_class: 'default extra_css', css_style: 'padding: 1em', id: 'gtk_frame')
 #
 # ======================================================================= #
-## Gtk.main','gtk_gtk
+## Gtk.main
   Methoden die man im <b>Gtk.</b>::Modul finden kann, sind
   folgende welche:
-  p('s1em'){
     Gtk.disable_setlocale
     Gtk.default_language
     Gtk.events_pending?
@@ -16835,20 +16994,7 @@ div(css_class: 'default extra_css', css_style: 'padding: 1em', id: 'gtk_frame')
   }+
   Und noch ein paar mehr.
-  Hier ein Beispiel wie man <b>Double Clicks</b> realisiert.','',
-  'double_clicks','double_clicks # rf ruby double_clicks
-  @window.add_events(:button_press_mask)
-  @window.signal_connect(:button_press_event) do |widget, event|
-  if event.event_type == Gdk::Event::BUTTON2_PRESS
-       p "double click" #
-  elsif event.event_type == Gdk::Event::BUTTON3_PRESS
-       p "triple click"
-  elseif event.event_type == Gdk::Event::BUTTON_PRESS
-       p "(should be) one click"
-  end
-  end
   Zum Abfragen des Event Namens:
@@ -16865,20 +17011,16 @@ div(css_class: 'default extra_css', css_style: 'padding: 1em', id: 'gtk_frame')
   Die <b>Argumente bedeuten</b>:
-  marl2em('<b>(a)</b> <b>expand</b>: ist es true dann bekommt das
+  <b>(a)</b> <b>expand</b>: ist es true dann bekommt das
   Child Widget Extraplatz. Dieser Platz wird gleichmässig
   aufgeteilt.
-  marl2em('<b>(b)</b> <b>fill</b>: ist dieses Argument true,
+  <b>(b)</b> <b>fill</b>: ist dieses Argument true,
   dann wird anstatt gepadded der Extra-Platz dem Kind
   gegeben.
   Das geht aber NICHT wenn expand auf <b>false</b> gesetzt ist.
-  a(
-    WIKI_URL+'Gtk%3A%3ABox#pack_start',
-    content: 'GtkBox.pack_start '
 # ======================================================================= #
@@ -16889,10 +17031,7 @@ div(css_class: 'default extra_css', css_style: 'padding: 1em', id: 'gtk_frame')
 #   rf ruby gtk_about_dialog
 #
 # ======================================================================= #
-## Gtk::AboutDialog','gtk_about_dialog
-  Einen <b>About Dialog</b> kann man auch erstellen.','','about
+## Gtk::AboutDialog
   @about_dialog.documenters = ['Robert A. Heiler']
   @about_dialog.license = 'This program is licenced under a ' +
@@ -16937,9 +17076,7 @@ div(css_class: 'default extra_css', css_style: 'padding: 1em', id: 'gtk_frame')
   '  end
-  Copyright des Programmes setzen:
-    about.set_copyright "(c) Jan Bodnar"
   Um den Dialog zu starten, und danach zu zerstören:
@@ -16948,22 +17085,8 @@ div(css_class: 'default extra_css', css_style: 'padding: 1em', id: 'gtk_frame')
 # ======================================================================= #
 # === Gtk::TextView
-#
-# GTK TextView TAG.
-#
-#   rf ruby gtk_text_view
-#
 # ======================================================================= #
-div(css_class: 'default extra_css', css_style: 'padding: 1em', id: 'gtktextview') {
-## Gtk::TextView','gtk_text_view
-  Da man oft die Dokumentation zu <b>TextBuffer</b> brauchen
-  wird:
-  Den Buffer kann man so manipulieren:
-    buffer = @text_view.buffer # Mittels .buffer() erhält man
+## Gtk::TextView
   the TextBuffer widget.','textview
     buffer.signal_connect(:mark_set) { |buffer, iter, mark|
@@ -17034,13 +17157,11 @@ end
 # === GTK SOURCE VIEW TAG SOURCEVIEW TAG. rf ruby gtk_source_view
 # ======================================================================= #
 div(css_class: 'default extra_css', css_style: 'padding: 1em', id: 'source_view') {
-## Gtk::SourceView','gtk_source_view
-  gtk_image('SOURCE_VIEW1.png','bblack1 marl2em mar3px',
-  'drag_edit
-  gtk_image('SOURCE_VIEW2.png','bblack1 mar3px',
-  'drag_sourceview
-  gtk_image('SOURCE_VIEW3.png','bblack0 mar3px',
-  'drag_sourceview_3
+## Gtk::SourceView
+  gtk_image('SOURCE_VIEW3.png
   Das linke Bild ist <b>SourceView.new</b> in quasi Rohform, das
   mittlere Bild ist SourceView mit etwas Text. Man sieht das man Farbe
@@ -17052,12 +17173,7 @@ div(css_class: 'default extra_css', css_style: 'padding: 1em', id: 'source_view'
   <a href="gtk_source_buffer">SourceBuffer</a> verändern.)
   SourceView ist ein Child von TextView, hat also auch dessen
-  Methoden.','','gtksourceview
-  beziehungsweise
+  Methoden.
     @source_view = Gtk::SourceView.new(@source_buffer)
@@ -17169,7 +17285,7 @@ div(css_class: 'default extra_css', css_style: 'padding: 1em', id: 'source_view'
   Was haben diese seltsamen <b>create_tag</b>s zu bedeuten?
-  marMan kann mit ihnen einen TextBuffer <b>farbig</b> darstellen,
+  Man kann mit ihnen einen TextBuffer <b>farbig</b> darstellen,
   ein comment, wie im nächsten Bild unten zu sehen ist, hätte so
   zum Beispiel eine rote Farbe.
@@ -17203,11 +17319,7 @@ div(css_class: 'default extra_css', css_style: 'padding: 1em', id: 'source_view'
     @text_buffer.line_count
-  Hier ein Bild um zu zeigen, das man damit auch farbige Wörter
-  im Text gesondert darstellen kann:
-  br +
-  gtk_image('TEXT_BUFFER1.png','marl3em bblack1 mar5px',
-  'drag_text_buffer1
   Hier noch ein wenig Information über meine virtuelle Methode
   <b>get_iter_at_cursor</b>
@@ -17232,21 +17344,6 @@ div(css_class: 'default extra_css', css_style: 'padding: 1em', id: 'source_view'
 # === Gtk::ScrolledWindow
 # ======================================================================= #
-## Gtk::ScrolledWindow','gtk_scrolled_window
-  Man kann natürlich auch festlegen wo die <b>Scrollbar</b>
-  zu erscheinen hat. Zuerst die Konstanten dafür angeben,
-  danach folgt ein Beispiel:
-  CORNER_TOP_LEFT
-  CORNER_BOTTOM_LEFT
-  CORNER_TOP_RIGHT
-  CORNER_BOTTOM_RIGHT
-  @scrolled_window.window_placement = Gtk::CORNER_BOTTOM_LEFT
-  @scrolled_window.window_placement = Gtk::CORNER_BOTTOM_RIGHT
   <b>window_placement</b> sagt, wo das Child Element ist. BOTTOM_LEFT
   heisst, das es links unten ist, die Scrollbars erscheinen dann
   rechts, und oben.
@@ -17356,13 +17453,6 @@ div(css_class: 'default extra_css', css_style: 'padding: 1em', id: 'source_view'
     kann man in allen Gtk::Windows setzen, und dies bestimmt
     die Minimum Größe eines Widgets. Darunter geht nichts.
-    s2('API Doku zu set_size_request
-    a(
-  WIKI_URL+'Gtk%3A%3AWidget#set_size_request',
-  content: 'hier',
-  css_class: 'mars1em BOLD'
       @window.set_size_request(600, 400)
     Size Request eines Widgets ist die kleinst-mögliche Größe
@@ -17394,31 +17484,7 @@ div(css_class: 'default extra_css', css_style: 'padding: 1em', id: 'source_view'
       @window.modify_bg(Gtk::STATE_NORMAL, BLACK)
       @window.modify_bg(Gtk::STATE_NORMAL, GREY)
-    Die verschiedenen <b>GtkStateType States</b> sind:
-    table2('s4em','','',
-     '<b>STATE_NORMAL</b>','State during normal operation.',
-     '<b>STATE_ACTIVE</b>','State of a currently active widget, such
-  as a depressed button. ',
-     '<b>STATE_PRELIGHT</b>','State indicating that the mouse
-  pointer is over the widget and the widget will
-  respond to mouse clicks.',
-     '<b>STATE_SELECTED</b>','State of a selected item, such the
-  selected row in a list.',
-     '<b>STATE_INSENSITIVE</b>','State indicating that the
-  widget is unresponsive to user actions.'
-    Auch die Größe des Rahmen lässt sich setzen:
-      @window.set_border_width(2)
-    bzw auch:
-      @window.border_width = 12
-    Lässt sich auch auf <b>Buttons</b> und so weiter
-    anwenden.
     Will man das Window irgendwo positionen (absolute positioning),
     geht dies mittels <b>.move</b>: # position tag, abs tag.
@@ -17546,30 +17612,13 @@ div(css_class: 'default extra_css', css_style: 'padding: 1em', id: 'gtk_eventbox
 # ======================================================================= #
-# === DIE GTK STATUSBAR TAG status tag.
+# === DIE GTK STATUSBAR TAG
 # ======================================================================= #
+## Gtk::Statusbar
-  # Gtk::Statusbar
-  Diese ID muss einzigartig sein, und kann mittels
-  <b>get_context_id</b> generiert werden.
-    @status_bar = Gtk::Statusbar.new','Statusbar
-    @status_bar.has_resize_grip = true
-    @status_bar_context_id = @status_bar.get_context_id("DsaSimulator")
-  Eine neue Nachricht kann man dann mittels <b>push</b> hinzufügen:
-    @status_bar.push(@status_bar_context_id, "DSA4 Simulator") # Add message
-  gtk_image('STATUS_BAR.png','bblack1 mart4px mars4em', :drag)+
-  Um automatisch die Statusbar zu ändern, kann man Threads nutzen
-  '  x = Thread.new {
-    sleep 10
-    @status_bar.push(@status_bar_context_id, which_message)
-  '  }
   Übrigens kann eine Statusbar einen <b>Resize Grip</b> besitze;
   dies ist so eine Art Pfeil nach unten in der rechten, unteren
@@ -17591,10 +17640,10 @@ div(css_class: 'default extra_css', css_style: 'padding: 1em', id: 'gtk_eventbox
 # === Gtk::Image
 # ======================================================================= #
-## Gtk::Image','gtk_image
+## Gtk::Image
   Normalerweise lädt man ein Image mittels <b>GdkPixbuf::Pixbuf</b>
   ("pixel buffer") aus einem File, und stellt dieses dann dar.
   beziehungsweise mittels der Nutzung von ENV:
@@ -17623,97 +17672,23 @@ div(css_class: 'default extra_css', css_style: 'padding: 1em', id: 'gtk_eventbox
     @event_box = Gtk::EventBox.new.add(@main_image)
     @event_box.signal_connect(:button_press_event) {  puts "Clicked." }
-  Man kann auch stock Icons nutzen:
-    Gtk::Image.new(stock_id, size)
-    Gtk::Image.new(Gtk::Stock::CONVERT, Gtk::IconSize::SMALL_TOOLBAR)
-  Die erlaubten IconSize sind:
-  IconSize::BUTTON
-  IconSize::DND
-  IconSize::DIALOG
-  IconSize::INVALID
-  IconSize::LARGE_TOOLBAR
-  IconSize::MENU
-  IconSize::SMALL_TOOLBAR
-  a(WIKI_URL+'Gtk%3A%3AImage#set', content: 'hier
   set_image könnte man auch nutzen.
   Da Gtk::Image ein Kind von Gtk::Misc ist, kann man <b>align
   Methoden</b> anwenden - also <b>center, left, right</b>,
   und auch padding.
-  Also, nun ein Beispiel zum <b>padding</b> (x-Achse, y-Achse+):
-    @image.set_padding(10,40)
-    @image.clear
    Eine Anmerkung: Hat man viele Bilder, kann es zu Speicherproblemen
   kommen. In diesem Fall sollte man immer <b>GC.start</b> aufrufen
   bevor man ein neues Bild anzeigt.
-  gtk_api_docu('Image')
-# ======================================================================= #
-# === Gdk PixbufSimpleAnim tag. gdk_pixbuf_simple_anim. pixma tag.
-# ======================================================================= #
-  ## GDK PixbufSimpleAnim','gdk_pixbuf_simple_anim
-    Dies erstellt eine neue, leere Animation.
-    Argumente sind:
-      * width:  the width of the animation (Fixnum)
-      * height: the height of the animation (Fixnum)
-      * rate: the speed of the animation, in frames per second (Float)
-      * Returns: a newly-created Gdk::PixbufSimpleAnim
-# ======================================================================= #
-# === GTK WIDGETS
-#
-# Gtk::Widget tag.
-#
-# Zeigt unter anderem wie man den Maus Pointer erhält.
-#
-#   rf ruby gtk_widget
-#
-# ======================================================================= #
-  ## Gtk::Widget','gtk_widget
-    s2('<b>GTK Widgets</b> (sozusagen die Divs in der <b>GTK-Welt</b>,
-    die Arbeitstiere) haben sogenannte Boxen, zB HBox oder VBox.
-    Will man eine andere Hintergrundfarbe setzen, so kann
-    man folgende Methode verwenden:
-      gtk_widget.override_background_color()
-      gtk_widget.override_background_color(:normal,
-   Gdk::RGBA.new(0.02, 0.02, 0.02, 1)
-    )
-    Das erste Argument hier, <b>state</b> genannt, definiert den
-    state der verändert werden sollte. :normal ist hierbei eine
-    Möglichkeit.
-    Das zweite Argument, <b>color</b>, ist eben die Farbe die
-    wir verwenden möchten.
-    Die Einträge stehen für die Farben:
-      red:   value
-      green: value
-      blue:  value
-      alpha: value
-    gtk_api_docu('Widget
 # Gtk::Tooltips
-  Mittels <b>Tooltips</b> kann man kleine, helfende <b>Popups</b>
-  einbringen, die neben einem Widget erscheinen. (<i>helping hover</i>)',
-  '','tooltip
   Die <b>API</b> zu den Tooltips ist folgende:
   Gtk::Tooltips.new(','hover
@@ -17759,51 +17734,12 @@ div(css_class: 'default extra_css', css_style: 'padding: 1em', id: 'gtk_eventbox
   button.tooltip_window = tooltip_window
-  gtk_api_docu('Tooltips
   Gtk::Tooltips ist deprecated. Man sollte Gtk::Tooltip verwenden.
   Das geht am besten wie folgt:
   object.tooltip_text = 'Hello, I am a static tooltip.'")
-# ======================================================================= #
-# === Gtk::Window   (GTK WINDOW. GTK2 WINDOW. @window initialisieren)
-#
-# Window tag.
-#   rf ruby gtk_main_window
-# ======================================================================= #
-## Gtk::Window
-  Um ein Fenster zu schliessen (close gtk, close gtk window)
-  wird die <b>Message destroy</b> geschickt, die man mit
-  main_quit verbinden muss.
-  Folgendes Beispiel zeigt dies:
-  @window.signal_connect(:destroy) Gtk.main_quit end
-  Border-width (in  html border-width:10px)
-  kann man auch setzen:
-    window.border_width = 10
-  Und um den <b>Button ins Fenster</b> reinzugeben nutzt man
-  in etwa diesen Code:
-    window.add(@button_quit)
-    window.show_all
-  Man kann auch multiple Events an einen Button hinzufügen. In
-  diesem Falle werden sie nacheinander ausgeführt. Manuell kann man
-  diesen Vorgang auch durchführen - dies lädt praktisch dazu ein,
-  <b>Automatismen durchzuführen</b>.
-  Um also einen Button zu <i>"klicken"</i> (ohne diesen aber mit
-  der Maus auswählen zu müssen), so schickt man ein <b>Signal</b>
-  an diesen "Button Widget":
 # ======================================================================= #
 # === GdkPixbuf::Pixbuf           (GdkPixbuf::Pixbuf tag)
 #
@@ -17961,9 +17897,6 @@ def to_png(file = 'screenshot')
     GdkPixbuf::Pixbuf.new(colorspace, has_alpha, bits_per_sample, width,
   height)
   Weitere Information über das Bild erhält man damit:
     p @pixbuf_image.bits_per_sample
@@ -18003,7 +17936,7 @@ def to_png(file = 'screenshot')
   Was bedeuten die <b>GdkInterpType</b>?
-  marGdkInterpType beschreibt die verschiedenen Interpolationsmöglichkeiten,
+  GdkInterpType beschreibt die verschiedenen Interpolationsmöglichkeiten,
   die mit der Scale Funktion genutzt werden können.
   GdkPixbuf::Pixbuf::INTERP_NEAREST ist die schnellste Scaling Methode,
@@ -18136,8 +18069,7 @@ div(css_class: 'default extra_css', css_style: 'padding: 1em', id: 'gtk_events')
     stock_cut_24.png  'Gtk::Stock::CUT
     stock_trash_24.png  'Gtk::Stock::DELETE
     stock_dialog_authentication_48.png    'Gtk::Stock::DIALOG_AUTHENTICATION
-    stock_dialog_error_48.png
-    'Gtk::Stock::DIALOG_ERROR
+    stock_dialog_error_48.png 'Gtk::Stock::DIALOG_ERROR
     stock_dialog_info_48.png
     'Gtk::Stock::DIALOG_INFO
     stock_dialog_question_48.png
@@ -18325,6 +18257,6 @@ div('s1em BO','anhang_a','border:3px solid darkgrey'){
      RELEASE_MASK - not used in GDK itself. GTK+ uses it
      to differentiate between (keyval, modifiers) pairs from
      key press and release events.
-     MODIFIER_MASK - UNKNOWN')
+     MODIFIER_MASK - UNKNOWN'
 end