[gtk-web/new-website: 118/191] added new docs
- From: Emmanuele Bassi <ebassi src gnome org>
- To: commits-list gnome org
- Cc:
- Subject: [gtk-web/new-website: 118/191] added new docs
- Date: Thu, 21 Nov 2019 12:28:23 +0000 (UTC)
commit 13e4a711cdfba9eb84c1c179f64eab76edf3761a
Author: ravgeetdhillon <ravgeetdhillon gmail com>
Date: Mon Jul 22 15:40:16 2019 +0530
added new docs
README.md | 14 ++--
_data/navigation.yml | 5 +-
_layouts/documentation.html | 20 ++++-
assets/img/docs/doc-gtk-architecture.png | Bin 0 -> 25094 bytes
assets/img/docs/doc-gtk-windows.png | Bin 0 -> 12803 bytes
assets/img/docs/doc-hello-world-c.png | Bin 0 -> 3411 bytes
collections/_docs/architecture.md | 19 ++++-
collections/_docs/hello-world.md | 110 +++++++++++++++++++++++++
collections/_docs/language-bindings.md | 20 ++++-
collections/_docs/linux.md | 55 +++++++++++++
collections/_docs/mono-develop.md | 52 +++++++++++-
collections/_docs/windows.md | 133 +++++++++++++++++++++++++++++++
docs.html | 16 ++--
13 files changed, 422 insertions(+), 22 deletions(-)
---
diff --git a/README.md b/README.md
index f680ad0..ca01a2e 100644
--- a/README.md
+++ b/README.md
@@ -68,28 +68,28 @@ To get the site up and running locally, follow the below steps:
1. Install a full [Ruby development environment](https://jekyllrb.com/docs/installation/).
2. Install Jekyll and [bundler](https://jekyllrb.com/docs/ruby-101/#bundler)
[gems](https://jekyllrb.com/docs/ruby-101/#gems).
-```
+```shell
$ gem install jekyll bundler
```
3. Create a local clone of the website:
-```
+```shell
$ git clone https://gitlab.gnome.org/ravgeetdhillon/gtk-web.git
```
4. Change into the gtk-web directory
-```
+```shell
$ cd gtk-web
```
5. Install the NPM and Gem dependencies by running the following commands:
-```
-$ npm install
+```shell
+$ nshellpm install
$ bundle install
```
6. Perform the following commands to structure the website properly:
-```
+```shell
$ structurize.sh --trace
```
7. Build the site and make it available on a local server
-```
+```shell
$ bundle exec jekyll serve
```
8. Browse to [http://localhost:4000](http://localhost:4000) to view the website.
diff --git a/_data/navigation.yml b/_data/navigation.yml
index 38876d2..bf54040 100644
--- a/_data/navigation.yml
+++ b/_data/navigation.yml
@@ -192,4 +192,7 @@ sidebar_links:
section: Architecture
- title: Cairo
name: cairo
- section: Architecture
\ No newline at end of file
+ section: Architecture
+ - title: Hello World
+ name: hello-world
+ section: Getting Started
\ No newline at end of file
diff --git a/_layouts/documentation.html b/_layouts/documentation.html
index f6d217d..95221bf 100644
--- a/_layouts/documentation.html
+++ b/_layouts/documentation.html
@@ -3,7 +3,7 @@
{% include header.html %}
-<section class="pb-4" id="{{ page.name }}">
+<section>
<div class="container-fluid">
<div class="row">
<div class="col-lg-3 col-md-4 small p-0 order-2 order-md-1">
@@ -65,8 +65,26 @@
</section>
<script>
+ // implements the bootstrap tooltip functionality
$(document).ready(function () {
$('[data-toggle="tooltip"]').tooltip();
});
+
+ console.log(markdownImages);
+ var i, l, img, markdownImages;
+ markdownImages = document.querySelectorAll("p img");
+ l = markdownImages.length;
+ for (i = 0; i < l; i++) {
+ img = markdownImages[i]
+ imgNodeValue = img.attributes.src.nodeValue;
+ if (imgNodeValue.search("https://";) == -1 || imgNodeValue.search("http://";) == -1) {
+ continue;
+ }
+ else {
+ img.baseURI = "{{ site.url }}" + imgNodeValue;
+ }
+ }
+ console.log(markdownImages);
+
</script>
{% include footer.html %}
\ No newline at end of file
diff --git a/assets/img/docs/doc-gtk-architecture.png b/assets/img/docs/doc-gtk-architecture.png
new file mode 100644
index 0000000..bea70ca
Binary files /dev/null and b/assets/img/docs/doc-gtk-architecture.png differ
diff --git a/assets/img/docs/doc-gtk-windows.png b/assets/img/docs/doc-gtk-windows.png
new file mode 100644
index 0000000..7553792
Binary files /dev/null and b/assets/img/docs/doc-gtk-windows.png differ
diff --git a/assets/img/docs/doc-hello-world-c.png b/assets/img/docs/doc-hello-world-c.png
new file mode 100644
index 0000000..f73d49f
Binary files /dev/null and b/assets/img/docs/doc-hello-world-c.png differ
diff --git a/collections/_docs/architecture.md b/collections/_docs/architecture.md
index 2059779..287e705 100644
--- a/collections/_docs/architecture.md
+++ b/collections/_docs/architecture.md
@@ -1,6 +1,21 @@
---
permalink: /docs/:name/
---
-architecture
+# Overview of GTK and its Libraries
-
\ No newline at end of file
+
+
+Over time GTK has been built up to be based on four libraries, also developed by the GTK team.
+
+## GLib
+
+[GLib](https://developer.gnome.org/glib/) is a low-level core library that forms the basis of GTK. It
provides data structure handling for C, portability wrappers and interfaces for such run-time functionality
as an event loop, threads, dynamic loading and an object system.
+
+## Pango
+[Pango](https://www.pango.org/) is a library for layout and rendering of text with an emphasis on
internationalization. It forms the core of text and font handling for GTK.
+
+## Cairo
+[Cairo](https://www.cairographics.org/) is a library for 2D graphics with support for multiple output
devices (including the X Window System, Win32) while producing a consistent output on all media while taking
advantage of display hardware acceleration when available.
+
+## ATK
+[ATK](https://developer.gnome.org/atk/) is a library for a set of interfaces providing accessibility. By
supporting the ATK interfaces, an application or toolkit can be used with tools such as screen readers,
magnifiers, and alternative input devices.
\ No newline at end of file
diff --git a/collections/_docs/hello-world.md b/collections/_docs/hello-world.md
new file mode 100644
index 0000000..ae87d52
--- /dev/null
+++ b/collections/_docs/hello-world.md
@@ -0,0 +1,110 @@
+---
+permalink: /docs/getting-started/:name/
+---
+# Getting Started
+
+GTK is a widget toolkit. Each user interface created by GTK consists of widgets. This is implemented in C
using GObject, an object-oriented framework for C. Widgets are organized in a hierachy. The window widget is
the main container. The user interface is then built by adding buttons, drop-down menus, input fields, and
other widgets to the window. If you are creating complex user interfaces it is recommended to use GtkBuilder
and its GTK-specific markup description language, instead of assembling the interface manually. You can also
use a visual user interface editor, like Glade.
+
+GTK is event-driven. The toolkit listens for events such as a click on a button, and passes the event to
your application.
+
+Below are some examples to get you started with GTK programming.
+
+> *Note: We assume that you have GTK, its dependencies and a C compiler installed and ready to use. If you
need to build GTK itself first, refer to the Compiling the GTK libraries section in this reference.*
+
+## Hello World App in C
+
+
+
+To begin our introduction to GTK, we'll start with a simple `Hello World` GTK application.
+
+Create a new file with the following content named `hello-world-gtk.c`.
+
+```c
+#include <gtk/gtk.h>
+
+static void
+print_hello (GtkWidget *widget,
+ gpointer data)
+{
+ g_print ("Hello World\n");
+}
+
+static void
+activate (GtkApplication *app,
+ gpointer user_data)
+{
+ GtkWidget *window;
+ GtkWidget *button;
+ GtkWidget *button_box;
+
+ window = gtk_application_window_new (app);
+ gtk_window_set_title (GTK_WINDOW (window), "Window");
+ gtk_window_set_default_size (GTK_WINDOW (window), 200, 200);
+
+ button_box = gtk_button_box_new (GTK_ORIENTATION_HORIZONTAL);
+ gtk_container_add (GTK_CONTAINER (window), button_box);
+
+ button = gtk_button_new_with_label ("Hello World");
+ g_signal_connect (button, "clicked", G_CALLBACK (print_hello), NULL);
+ g_signal_connect_swapped (button, "clicked", G_CALLBACK (gtk_widget_destroy), window);
+ gtk_container_add (GTK_CONTAINER (button_box), button);
+
+ gtk_widget_show_all (window);
+}
+
+int
+main (int argc,
+ char **argv)
+{
+ GtkApplication *app;
+ int status;
+
+ app = gtk_application_new ("org.gtk.example", G_APPLICATION_FLAGS_NONE);
+ g_signal_connect (app, "activate", G_CALLBACK (activate), NULL);
+ status = g_application_run (G_APPLICATION (app), argc, argv);
+ g_object_unref (app);
+
+ return status;
+}
+```
+
+You can compile the program above with GCC using:
+
+```shell
+gcc `pkg-config --cflags gtk+-3.0` -o hello-world-gtk hello-world-gtk.c `pkg-config --libs gtk+-3.0
+```
+
+<div class="alert alert-tertiary">
+For more information on how to compile a GTK application, please refer to the [Compiling GTK
Applications](https://developer.gnome.org/gtk3/stable/gtk-compiling.html) section in this reference.
+</div>
+
+## Explaination
+
+### Initialising the App
+
+In a GTK application, the purpose of the `main()` function is to create a `GtkApplication` object and run
it. In this example a `GtkApplication` pointer named app is called and then initialized using
`gtk_application_new()`.
+
+When creating a `GtkApplication` you need to pick an application identifier (a name) and input to
`gtk_application_new()` as parameter. For this example, `org.gtk.example` is used but for choosing an
identifier for your application see this guide. Lastly `gtk_application_new()` takes a `GApplicationFlags` as
input for your application, if your application would have special needs.
+
+Next the activate signal is connected to the `activate()` function above the `main()` functions. The
activate signal will be sent when your application is launched with `g_application_run()` on the line below.
The `gtk_application_run()` also takes as arguments the pointers to the command line arguments counter and
string array; this allows GTK to parse specific command line arguments that control the behavior of GTK
itself. The parsed arguments will be removed from the array, leaving the unrecognized ones for your
application to parse.
+
+Within `g_application_run` the `activate()` signal is sent and we then proceed into the `activate()`
function of the application. Inside the `activate()` function we want to construct our GTK window, so that a
window is shown when the application is launched. The call to `gtk_application_window_new()` will create a
new `GtkWindow` and store it inside the window pointer. The window will have a frame, a title bar, and window
controls depending on the platform.
+
+A window title is set using `gtk_window_set_title()`. This function takes a `GtkWindow*` pointer and a
string as input. As our window pointer is a GtkWidget pointer, we need to cast it to `GtkWindow*`. But
instead of casting window via `GtkWindow*`, window can be cast using the macro `GTK_WINDOW()`. `GTK_WINDOW()`
will check if the pointer is an instance of the `GtkWindow` class, before casting, and emit a warning if the
check fails. More information about this convention can be found here.
+
+Finally the window size is set using `gtk_window_set_default_size` and the window is then shown by GTK via
`gtk_widget_show_all()`.
+
+When you exit the window, by for example pressing the X, the `g_application_run()` in the main loop returns
with a number which is saved inside an integer named "status". Afterwards, the `GtkApplication` object is
freed from memory with `g_object_unref()`. Finally the status integer is returned and the GTK application
exits.
+
+### Adding Button
+As seen above, `hello-world-gtk.c` adds a button to our window, with the label "Hello World". Two new
GtkWidget pointers are declared to accomplish this, `button` and `button_box`. The button_box variable is
created to store a `GtkButtonBox` which is GTK's way of controlling the size and layout of buttons. The
`GtkButtonBox` is created and assigned to `gtk_button_box_new()` which takes a `GtkOrientation` enum as
parameter. The buttons which this box will contain can either be stored horizontally or vertically but this
does not matter in this particular case as we are dealing with only one button. After initializing
`button_box` with horizontal orientation, the code adds the `button_box` widget to the window widget using
`gtk_container_add()`.
+
+### Adding Label
+
+Next the button variable is initialized in similar manner. `gtk_button_new_with_label()` is called which
returns a GtkButton to be stored inside button. Afterwards button is added to our `button_box`. Using
`g_signal_connect` the button is connected to a function in our app called `print_hello()`, so that when the
button is clicked, GTK will call this function. As the `print_hello()` function does not use any data as
input, NULL is passed to it. `print_hello()` calls `g_print()` with the string "Hello World" which will print
Hello World in a terminal if the GTK application was started from one.
+
+### Controlling Event Handling
+
+After connecting `print_hello()`, another signal is connected to the "clicked" state of the button using
`g_signal_connect_swapped()`. This functions is similar to a `g_signal_connect()` with the difference lying
in how the callback function is treated. `g_signal_connect_swapped()` allow you to specify what the callback
function should take as parameter by letting you pass it as data. In this case the function being called back
is `gtk_widget_destroy()` and the window pointer is passed to it. This has the effect that when the button is
clicked, the whole GTK window is destroyed. In contrast if a `normal g_signal_connect()` were used to connect
the "clicked" signal with `gtk_widget_destroy()`, then the button itself would have been destroyed, not the
window. More information about creating buttons can be found here.
+
+Next section will elaborate further on how to add several GtkWidgets to your GTK application.
\ No newline at end of file
diff --git a/collections/_docs/language-bindings.md b/collections/_docs/language-bindings.md
index 5d13950..eaa0c47 100644
--- a/collections/_docs/language-bindings.md
+++ b/collections/_docs/language-bindings.md
@@ -1,4 +1,22 @@
---
permalink: /docs/:name/
---
-bindings
\ No newline at end of file
+# Language Bindings
+
+Language Bindings or Wrappers allow GTK to be used from other programming languages, in the style of those
languages. They are relatively easy to create because GTK is designed with them in mind.
+
+The official GNOME bindings follow the GNOME release schedule which guarantees API stability and time-based
releases.
+
+Language | v3 | v4
+--- | :---: | :---:
+Python | <i class="far fa-check-circle"></i> | <i class="far fa-check-circle"></i>
+JavaScript | <i class="far fa-check-circle"></i> | <i class="far fa-check-circle"></i>
+C++ | <i class="far fa-check-circle"></i> | <i class="far fa-check-circle"></i>
+Perl | <i class="far fa-check-circle"></i> | <i class="far fa-check-circle"></i>
+D | <i class="far fa-check-circle"></i> | <i class="far fa-check-circle"></i>
+Rust | <i class="far fa-check-circle"></i> | <i class="far fa-check-circle"></i>
+
+- Code examples for all of them would be great; small, short, "hello world" type ones
+- Links to project pages and documentation
+- A short description of the GObject Introspection project, which is used to describe the C API in a way
that can
+be consumed by dynamic and static languages
\ No newline at end of file
diff --git a/collections/_docs/linux.md b/collections/_docs/linux.md
new file mode 100644
index 0000000..cf98f7b
--- /dev/null
+++ b/collections/_docs/linux.md
@@ -0,0 +1,55 @@
+---
+permalink: /docs/installations/:name/
+---
+
+# Installing GTK for GNU/Linux and Unix
+
+## Stable Release
+
+In order to install GTK for GNU/Linux and Unix systems, you will need to get the GLib,
GObject-Introspection, Pango, Gdk-Pixbuf, ATK and GTK packages to build GTK. To read more about these
packages, please refer to the [Architecture](/docs/architecture/).
+
+To build an environment for GTK, install all te dependencies listed below:
+
+Dependency | Version | Source
+--- | --- | :---:
+GTK | 3.24 | [<i class="fas fa-download"></i>](http://ftp.gnome.org/pub/gnome/sources/gtk+/3.24/)
+GLib | 2.60 | [<i class="fas fa-download"></i>](http://ftp.gnome.org/pub/gnome/sources/glib/2.60/)
+Pango | 1.42 | [<i class="fas fa-download"></i>](http://ftp.gnome.org/pub/gnome/sources/pango/1.42/)
+Gdk-pixbuf | 2.38 | [<i class="fas
fa-download"></i>](http://ftp.gnome.org/pub/gnome/sources/gdk-pixbuf/2.38/)
+ATK | 2.26 | [<i class="fas fa-download"></i>](http://ftp.gnome.org/pub/gnome/sources/atk/2.26/)
+GObject-Introspection | 1.60 | [<i class="fas
fa-download"></i>](http://ftp.gnome.org/pub/gnome/sources/gobject-introspection/1.60/)
+
+To build GTK 3.24, see the [installation guide](https://developer.gnome.org/gtk3/stable/gtk-building.html).
For additional help, [FAQ](https://developer.gnome.org/gtk3/stable/gtk-question-index.html) is a good
starting point.
+
+## Older Versions
+
+Some applications still require GTK 2, an older stable version of GTK. You can have the run-time and
development environments for GTK 3.x, GTK 2.x and GTK 1.2 installed simultaneously on your computer.
+
+### GTK v3.x
+
+Version | Packages
+--- | ---
+GTK 3.22 | [Sources](http://ftp.gnome.org/pub/gnome/sources/gtk+/3.22/)
+GTK 3.20 | [Sources](http://ftp.gnome.org/pub/gnome/sources/gtk+/3.20/)
+GTK 3.18 | [Sources](http://ftp.gnome.org/pub/gnome/sources/gtk+/3.18/)
+GTK 3.16 | [Sources](http://ftp.gnome.org/pub/gnome/sources/gtk+/3.16/)
+GTK 3.14 | [Sources](http://ftp.gnome.org/pub/gnome/sources/gtk+/3.14/)
+GTK 3.12 | [Sources](http://ftp.gnome.org/pub/gnome/sources/gtk+/3.12/)
+GTK 3.10 | [Sources](http://ftp.gnome.org/pub/gnome/sources/gtk+/3.10/)
+GTK 3.8 | [Sources](http://ftp.gnome.org/pub/gnome/sources/gtk+/3.8/)
+GTK 3.6 | [Sources](http://ftp.gnome.org/pub/gnome/sources/gtk+/3.6/)
+GTK 3.4 | [Sources](http://ftp.gnome.org/pub/gnome/sources/gtk+/3.4/)
+GTK 3.2 | [Sources](http://ftp.gnome.org/pub/gnome/sources/gtk+/3.2/)
+GTK 3.0 | [Sources](http://ftp.gnome.org/pub/gnome/sources/gtk+/3.0/)
+
+### GTK v2.x
+
+Version | Packages
+--- | ---
+GTK 2.24 | [Sources](http://ftp.gnome.org/pub/gnome/sources/gtk+/2.24/)
+
+### GTK v1.x
+
+Version | Packages
+--- | ---
+GTK 1.2 | [Sources](http://ftp.gnome.org/pub/gnome/sources/gtk+/1.2/)
\ No newline at end of file
diff --git a/collections/_docs/mono-develop.md b/collections/_docs/mono-develop.md
index 38870d8..878b065 100644
--- a/collections/_docs/mono-develop.md
+++ b/collections/_docs/mono-develop.md
@@ -3,8 +3,56 @@ permalink: /docs/dev-tools/:name/
---
# Mono Develop
-
+
MonoDevelop enables developers to quickly write desktop and web applications on Linux, Windows and macOS. It
also makes it easy for developers to port .NET applications created with Visual Studio to Linux and macOS
maintaining a single code base for all platforms.
-***
\ No newline at end of file
+GNOME Builder is a toolsmith for GNOME-based applications. It is a tool to help you write and contribute to
great GNOME-based applications.
+
+Visit the [official site for GNOME Builder](https://wiki.gnome.org/Apps/Builder).
+
+***
+
+## Features
+
+* **Multi-platform**
+ Supports Linux, Windows and macOS.
+
+* ### Advanced Text Editing
+Code completion support for C#, code templates, code folding.
+
+Configurable workbench
+Fully customizable window layouts, user defined key bindings, external tools
+
+Multiple language support
+C#, F#, Visual Basic .NET, Vala
+
+Integrated Debugger
+For debugging Mono and native applications
+
+GTK# Visual Designer
+Easily build GTK# applications
+
+ASP.NET
+Create web projects with full code completion support and test on XSP, the Mono web server.
+
+Other tools
+Source control, makefile integration, unit testing, packaging and deployment, localization
+
+* Search for files, classes, and functions with lightning fast fuzzy search.
+* Explore APIs used by your project with auto-completion for C/C++, Python, Rust, and Vala. For languages
without native support, ctags integration is provided.
+* Never lose your place in large code bases thanks to Builder's source code map.
+
+## Getting Builder
+Builder is available for download through most popular distributions' software centers. Source code can be
obtained from Builder's git repository. Builder can also be installed and run via
[Flatpak](https://wiki.gnome.org/Projects/SandboxedApps):
+
+```
+$ flatpak install --from https://flathub.org/repo/appstream/org.gnome.Builder.flatpakref
+$ flatpak run org.gnome.Builder
+```
+
+## Getting in Touch
+Questions regarding use and development of Builder are welcome though Builder's [IRC
channel](irc://irc.gnome.org/%23gnome-builder) (`#gnome-builder` at `irc.gnome.org`).
+
+## Filing a bug
+If you found a problem or have a feature suggestion, feel free to [file a bug at GNOME's bug
tracker](https://gitlab.gnome.org/GNOME/gnome-builder/issues).
\ No newline at end of file
diff --git a/collections/_docs/windows.md b/collections/_docs/windows.md
new file mode 100644
index 0000000..d07f812
--- /dev/null
+++ b/collections/_docs/windows.md
@@ -0,0 +1,133 @@
+---
+permalink: /docs/installations/:name/
+---
+
+# Setting up GTK for Windows
+
+
+
+
+
+> Note: These instructions are intended for developers wanting to create Windows applications based on GTK,
not for end-users. On Windows, GTK applications are typically bundled with GTK already, so end-users do not
need to worry about how to install GTK itself.
+
+There are two methods to install GTK on Windows development machines.
+
+* ### First Method
+ This method is based on the packages available from the [Microsoft vcpkg
project](https://docs.microsoft.com/en-us/cpp/vcpkg), which are built using Visual Studio, and therefore work
well if you intend to develop using that platform.
+* ### Second Method
+ This method is based on the packages provided by [MSYS2](https://www.msys2.org/), which provides a
UNIX-like environment for Windows. Both of these repositories also provide packages for a large number of
other useful open source libraries.
+
+If you really want to build GTK from the pristine sources yourself, you can use the project files for
Microsoft Visual Studio provided by the GTK releases. Learn more on [how to build the GTK stack using
Microsoft Visual Studio](https://wiki.gnome.org/Projects/GTK/Win32/MSVCCompilationOfGTKStack) and read these
other tips on [how to build GTK with MSVC on
Windows](https://blogs.gnome.org/nacho/2015/02/19/building-gtk-3-with-msvc-2013/). In almost all cases, using
the packages from `vcpkg` or `MSYS2` is much simpler though.
+
+We assume that you are using Windows 7 or later. For older versions of Windows, you will need to do a custom
build of older versions of GLib and GTK.
+
+## Using GTK from vcpkg packages
+
+<div class="alert alert-warning">
+WARNING: The `vcpkg` packaging is not maintained by the GTK team, and it uses a different build system than
the one used by GTK. If something breaks when building GTK or its dependencies using `vcpkg`, make sure to
open an issue in the [vcpkg issue tracker](https://github.com/Microsoft/vcpkg/issues), instead of the GTK one.
+</div>
+
+### Installation
+
+The GTK library, as well as all pre-requisites and many language bindings (e.g. the C++ bindings gtkmm) are
packaged by the Microsoft `vcpkg` project for use with Visual Studio. This provides a very simple way to
setup a development environment to create GTK apps. If you prefer a more UNIX-like experience, building from
the command line instead of using Visual Studio, you may want to consider installing GTK from MSYS2 instead.
+
+In order to use `vcpkg` packages, you first need to clone the `vcpkg` repository,
+
+```
+git clone https://github.com/Microsoft/vcpkg
+cd vcpkg
+.\bootstrap-vcpkg.bat You can then install the GTK packages with
+vcpkg install gtk:x64-windows
+```
+
+The part behind the colon ':' specifies the target. After this step, any project created in Visual Studio
will now automatically see the GTK libraries.
+
+If you build from the command line using `CMake`, you need to tell `CMake` where to find the libraries. This
is done by adding
+
+`-DCMAKE_TOOLCHAIN_FILE=[vcpkg root]\scripts\buildsystems\vcpkg.cmake`
+
+to the CMake options, where `vcpkg` root is the location where you cloned the `vcpkg` repository.
+
+### Building and distributing your application
+
+<div class="alert alert-tertiary">
+Once you have installed the GTK as above, you should have little problem compiling a GTK app. In order to
run it successfully, you will also need a GTK theme. There is some old builtin support for a Windows theme in
GTK, but that makes your app look like a Windows 7 app. It is better to get a Windows 10 theme, for instance
the [Windows 10 Transformation Pack](https://github.com/B00merang-Project/Windows-10).
+</div>
+
+**Step 1.** Copy the `gtk-3.20` folder of that repository to a folder `share/themes/Windows10/gtk-3.0/` in
your installation folder.
+
+**Step 2.** You also need to copy the icons from the Adwaita theme, which you can get from Linux box, where
they are stored in `/usr/share/icons/Adwaita/`; copy this entire folder to a share/icons folder in your
installation folder.
+
+**Step 3.** Perform the same steps for the `hicolor icons`.
+
+**Step 4.** To make GTK pick up this theme, put a file
+`settings.ini` in `etc/gtk-3.0` in your installation folder. This should contain
+```
+[Settings]
+gtk-theme-name=Windows10
+gtk-font-name=Segoe UI 9
+```
+
+**Step 5.** And to top it all off, find the `gschemas.compiled` file in `/usr/share/glib-2.0/schemas/` and
copy that to `share/glib-2.0/schemas`.
+
+**Step 6.** You can then zip up your installation folder, or use an installer generator to do that for you,
and distribute the result.
+
+## Using GTK from MSYS2 packages
+
+### Installation
+
+The [MSYS2](https://msys2.github.io/) project provides a UNIX-like development environment for Windows. It
provides packages for many software applications and libraries, including the GTK stack. If you prefer
developing using Visual Studio, you may be better off installing GTK from vcpkg instead.
+
+In MSYS2 packages are installed using the [pacman package
manager](https://github.com/msys2/msys2/wiki/MSYS2-installation#iv-general-package-management).
+
+
+> Note: in the following steps, we will assume you're using a `64-bit Windows`. Therefore, the package names
include the x86_64 architecture identifier. If you're using a 32-bit Windows, please adapt the instructions
below using the i686 architecture identifier.
+
+**Step 1.**: Download the [MSYS2 installer](https://www.msys2.org/) that matches your platform and follow
the installation instructions.
+
+**Step 2.**: Install GTK3 and its dependencies. Open a MSYS2 shell, and run:
+
+```
+pacman -S mingw-w64-x86_64-gtk3
+```
+
+**Step 3. (recommended)**: Install the GTK core applications. `Glade` is a GUI designer for GTK. It lets you
design your GUI and export it in XML format. You can then import your GUI from your code using the GtkBuilder
API. Read the GtkBuilder section in the GTK manual for more information.
+
+To install Glade:
+```
+pacman -S mingw-w64-x86_64-glade
+```
+
+`Devhelp` is a help browser. It lets you easily navigate offline in the GTK, glib and gobject API help
relative to the version of these libraries installed on your system.
+
+To install Devhelp:
+```
+pacman -S mingw-w64-x86_64-devhelp
+```
+
+**Step 4. (optional)**: If you want to develop a GTK3 application in Python, you need to install the Python
bindings.
+
+If you develop in Python 3:
+```
+pacman -S mingw-w64-x86_64-python3-gobject
+```
+
+If you develop in Python 2:
+```
+pacman -S mingw-w64-x86_64-python2-gobject
+```
+
+**Step 5. (optional)**: Install the build tools. If you want to develop a GTK3 application in other
languages like C, C++, Fortran, etc, you'll need a compiler like gcc and other development tools:
+```
+pacman -S mingw-w64-x86_64-toolchain base-devel
+```
+
+### Building and distributing your application
+
+You may use MSYS2 to [build your GTK application and create an installer to distribute
it](https://blogs.gnome.org/nacho/2014/08/01/how-to-build-your-gtk-application-on-windows/). Your installer
will need to ship your application build artifacts as well as GTK binaries and runtime dependencies; see the
instructions above for vcpkg for more details.
+
+### Legal notes on distributing GTK with your application
+
+You are welcome to redistribute GTK binaries, including applications that bundle them, on other web sites,
CD-ROM, and other media. You don't have to ask for permission. That's one of the points of Free Software.
+
+One important thing that the [GNU licenses](http://www.fsf.org/licenses/licenses.html) require is that you
must also redistribute the source code. This usually means at least the gettext, GLib, GTK, Pango and ATK
sources.
\ No newline at end of file
diff --git a/docs.html b/docs.html
index 6df6bdd..8725cde 100644
--- a/docs.html
+++ b/docs.html
@@ -34,7 +34,7 @@ permalink: /docs/
<i class="fas fa-cogs fa-fw fa-3x pb-4 text-primary"></i>
<h5>Getting Started</h5>
<span class="text-muted small">Get started now by building a Hello World app and playing around
it.</span>
- <a href="/docs/getting-started/" class="stretched-link"></a>
+ <a href="{{ '/docs/getting-started/' | prepend: site.url }}" class="stretched-link"></a>
</div>
</div>
<div class="col-md-4 pb-5">
@@ -43,7 +43,7 @@ permalink: /docs/
<i class="fas fa-tools fa-fw fa-3x pb-4 text-primary"></i>
<h5>Dev Tools</h5>
<span class="text-muted small">Learn how to setup your development environment with GTK
recommended tools.</span>
- <a href="/docs/dev-tools/" class="stretched-link"></a>
+ <a href="{{ '/docs/dev-tools/' | prepend: site.url }}" class="stretched-link"></a>
</div>
</div>
<div class="col-md-4 pb-5">
@@ -53,16 +53,16 @@ permalink: /docs/
<h5>Language Bindings</h5>
<span class="text-muted small">Learn to integrate your favorite programming language with GTK
through
bindings.</span>
- <a href="/docs/language-bindings/" class="stretched-link"></a>
+ <a href="{{ '/docs/language-bindings/' | prepend: site.url }}" class="stretched-link"></a>
</div>
</div>
<div class="col-md-4 pb-5">
<div class="col h-100 py-5 text-center bg-white d-flex flex-column align-items-center shadow-sm
shadow-hover rounded border-bottom border-primary"
style="border-width:2px!important;">
- <i class="fas fa-box-open fa-fw fa-3x pb-4 text-primary"></i>
+ <i class="fas fa-cubes fa-fw fa-3x pb-4 text-primary"></i>
<h5>API References</h5>
<span class="text-muted small">Dig deep into the API references for GTK3 and GTK4.</span>
- <a href="/docs/apis/" class="stretched-link"></a>
+ <a href="{{ '/docs/apis/' | prepend: site.url }}" class="stretched-link"></a>
</div>
</div>
<div class="col-md-4 pb-5">
@@ -71,16 +71,16 @@ permalink: /docs/
<i class="fas fa-vector-square fa-fw fa-3x pb-4 text-primary"></i>
<h5>Architecture</h5>
<span class="text-muted small">Learn about the sub modules the GTK has been built upon.</span>
- <a href="/docs/architecture/" class="stretched-link"></a>
+ <a href="{{ '/docs/architecture/' | prepend: site.url }}" class="stretched-link"></a>
</div>
</div>
<div class="col-md-4 pb-5">
<div class="col h-100 py-5 text-center bg-white d-flex flex-column align-items-center shadow-sm
shadow-hover rounded border-bottom border-primary"
style="border-width:2px!important;">
- <i class="fas fa-tools fa-fw fa-3x pb-4 text-primary"></i>
+ <i class="fas fa-box-open fa-fw fa-3x pb-4 text-primary"></i>
<h5>Installations</h5>
<span class="text-muted small">Figure out how to install GTK on different platforms.</span>
- <a href="/docs/installations/" class="stretched-link"></a>
+ <a href="{{ '/docs/installations/' | prepend: site.url }}" class="stretched-link"></a>
</div>
</div>
</div>
[
Date Prev][
Date Next] [
Thread Prev][
Thread Next]
[
Thread Index]
[
Date Index]
[
Author Index]
